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

full_name: Aesop.unificationGoalPenalty
code: def unificationGoalPenalty : Percent 
goal: Aesop.Percent

full_name: Aesop.postponedSafeRuleSuccessProbability
code: def postponedSafeRuleSuccessProbability : Percent 
goal: Aesop.Percent
File: .lake/packages/aesop/Aesop/Percent.lean

full_name: Aesop.instInhabitedPercent
code: structure Percent where
  toFloat : Float
  deriving Inhabited
goal: Inhabited Aesop.Percent

full_name: Aesop.Percent.toFloat
code: structure Percent where
  toFloat : Float
  deriving Inhabited
goal: Float

full_name: Aesop.Percent
code: structure Percent where
  toFloat : Float
  deriving Inhabited
goal: Type

full_name: Aesop.Percent.ofFloat
code: protected def ofFloat (f : Float) : Option Percent 
goal: Option Aesop.Percent

full_name: Aesop.Percent.instMul
code: instance : Mul Percent 
goal: Mul Aesop.Percent

full_name: Aesop.Percent.δ
code: @[inline]
def δ : Percent 
goal: Aesop.Percent

full_name: Aesop.Percent.instBEq
code: instance : BEq Percent 
goal: BEq Aesop.Percent

full_name: Aesop.Percent.instOrd
code: instance : Ord Percent 
goal: Ord Aesop.Percent

full_name: Aesop.Percent.instLT
code: instance : LT Percent 
goal: LT Aesop.Percent

full_name: Aesop.Percent.instLE
code: instance : LE Percent 
goal: LE Aesop.Percent

full_name: Aesop.Percent.instToString
code: instance : ToString Percent 
goal: ToString Aesop.Percent

full_name: Aesop.Percent.instHPowNat
code: instance : HPow Percent Nat Percent 
goal: HPow Aesop.Percent Nat Aesop.Percent

full_name: Aesop.Percent.hundred
code: def hundred : Percent 
goal: Aesop.Percent

full_name: Aesop.Percent.fifty
code: def fifty : Percent 
goal: Aesop.Percent

full_name: Aesop.Percent.toHumanString
code: def toHumanString (p : Percent) : String 
goal: String

full_name: Aesop.Percent.ofNat
code: protected def ofNat (n : Nat) : Option Percent 
goal: Option Aesop.Percent
File: Cache/Main.lean

full_name: help
code: def help : String 
goal: String

full_name: toPaths
code: /-- Note that this normalizes the path strings, which is needed when running from a unix shell
(which uses `/` in paths) on windows (which uses `\` in paths) as otherwise our filename keys won't
match. -/
def toPaths (args : List String) : List FilePath 
goal: List System.FilePath

full_name: curlArgs
code: def curlArgs : List String 
goal: List String

full_name: leanTarArgs
code: def leanTarArgs : List String 
goal: List String

full_name: main
code: def main (args : List String) : IO Unit 
goal: IO Unit
File: .lake/packages/aesop/Aesop/Nanos.lean

full_name: Aesop.instInhabitedNanos
code: structure Nanos where
  nanos : Nat
  deriving Inhabited, BEq, Ord
goal: Inhabited Aesop.Nanos

full_name: Aesop.Nanos
code: structure Nanos where
  nanos : Nat
  deriving Inhabited, BEq, Ord
goal: Type

full_name: Aesop.instOrdNanos
code: structure Nanos where
  nanos : Nat
  deriving Inhabited, BEq, Ord
goal: Ord Aesop.Nanos

full_name: Aesop.Nanos.nanos
code: structure Nanos where
  nanos : Nat
  deriving Inhabited, BEq, Ord
goal: Nat

full_name: Aesop.instBEqNanos
code: structure Nanos where
  nanos : Nat
  deriving Inhabited, BEq, Ord
goal: BEq Aesop.Nanos

full_name: Aesop.Nanos.instOfNat
code: instance : OfNat Nanos n 
goal: OfNat Aesop.Nanos n

full_name: Aesop.Nanos.instAdd
code: instance : Add Nanos 
goal: Add Aesop.Nanos

full_name: Aesop.Nanos.instHDivNat
code: instance : HDiv Nanos Nat Nanos 
goal: HDiv Aesop.Nanos Nat Aesop.Nanos

full_name: Aesop.Nanos.printAsMillis
code: def printAsMillis (n : Nanos) : String 
goal: String
File: .lake/packages/aesop/Aesop/RuleTac.lean

full_name: Aesop.RuleTacDescr.run
code: protected def run : RuleTacDescr → RuleTac
  
goal: Aesop.RuleTacDescr → Aesop.RuleTac
File: .lake/packages/aesop/Aesop/Tree/UnsafeQueue.lean

full_name: Aesop.PostponedSafeRule.rule
code: structure PostponedSafeRule where
  rule : SafeRule
  output : RuleTacOutput
  deriving Inhabited
goal: Aesop.SafeRule

full_name: Aesop.PostponedSafeRule
code: structure PostponedSafeRule where
  rule : SafeRule
  output : RuleTacOutput
  deriving Inhabited
goal: Type

full_name: Aesop.PostponedSafeRule.output
code: structure PostponedSafeRule where
  rule : SafeRule
  output : RuleTacOutput
  deriving Inhabited
goal: Aesop.RuleTacOutput

full_name: Aesop.instInhabitedPostponedSafeRule
code: structure PostponedSafeRule where
  rule : SafeRule
  output : RuleTacOutput
  deriving Inhabited
goal: Inhabited Aesop.PostponedSafeRule

full_name: Aesop.PostponedSafeRule.toUnsafeRule
code: def toUnsafeRule (r : PostponedSafeRule) : UnsafeRule 
goal: Aesop.UnsafeRule

full_name: Aesop.instInhabitedUnsafeQueueEntry
code: inductive UnsafeQueueEntry
  | unsafeRule (r : IndexMatchResult UnsafeRule)
  | postponedSafeRule (r : PostponedSafeRule)
  deriving Inhabited
goal: Inhabited Aesop.UnsafeQueueEntry

full_name: Aesop.UnsafeQueueEntry
code: inductive UnsafeQueueEntry
  | unsafeRule (r : IndexMatchResult UnsafeRule)
  | postponedSafeRule (r : PostponedSafeRule)
  deriving Inhabited
goal: Type

full_name: Aesop.UnsafeQueueEntry.unsafeRule
code: inductive UnsafeQueueEntry
  | unsafeRule (r : IndexMatchResult UnsafeRule)
  | postponedSafeRule (r : PostponedSafeRule)
  deriving Inhabited
goal: Aesop.UnsafeQueueEntry

full_name: Aesop.UnsafeQueueEntry.postponedSafeRule
code: inductive UnsafeQueueEntry
  | unsafeRule (r : IndexMatchResult UnsafeRule)
  | postponedSafeRule (r : PostponedSafeRule)
  deriving Inhabited
goal: Aesop.UnsafeQueueEntry

full_name: Aesop.UnsafeQueueEntry.instToString
code: instance : ToString UnsafeQueueEntry 
goal: ToString Aesop.UnsafeQueueEntry

full_name: Aesop.UnsafeQueueEntry.successProbability
code: def successProbability : UnsafeQueueEntry → Percent
  
goal: Aesop.UnsafeQueueEntry → Aesop.Percent

full_name: Aesop.UnsafeQueueEntry.name
code: def name : UnsafeQueueEntry → RuleName
  
goal: Aesop.UnsafeQueueEntry → Aesop.RuleName

full_name: Aesop.UnsafeQueueEntry.instOrd
code: instance : Ord UnsafeQueueEntry 
goal: Ord Aesop.UnsafeQueueEntry

full_name: Aesop.UnsafeQueue
code: def UnsafeQueue 
goal: Type

full_name: Aesop.UnsafeQueue.instEmptyCollection
code: instance : EmptyCollection UnsafeQueue 
goal: EmptyCollection Aesop.UnsafeQueue

full_name: Aesop.UnsafeQueue.instInhabited
code: instance : Inhabited UnsafeQueue 
goal: Inhabited Aesop.UnsafeQueue

full_name: Aesop.UnsafeQueue.initial
code: def initial (postponedSafeRules : Array PostponedSafeRule)
    (unsafeRules : Array (IndexMatchResult UnsafeRule)) : UnsafeQueue 
goal: Aesop.UnsafeQueue

full_name: Aesop.UnsafeQueue.entriesToMessageData
code: def entriesToMessageData (q : UnsafeQueue) : Array MessageData 
goal: Array Lean.MessageData
File: .lake/packages/aesop/Aesop/RuleTac/Apply.lean

full_name: Aesop.RuleTac.applyExpr'
code: def applyExpr' (goal : MVarId) (e : Expr) (eStx : Term)
    (pat? : Option RulePattern) (patInst : RulePatternInstantiation)
    (md : TransparencyMode) : MetaM RuleApplication 
goal: Lean.MetaM Aesop.RuleApplication

full_name: Aesop.RuleTac.applyExpr
code: def applyExpr (goal : MVarId) (e : Expr) (eStx : Term)
    (pat? : Option RulePattern) (patInsts : HashSet RulePatternInstantiation)
    (md : TransparencyMode) : MetaM RuleTacOutput 
goal: Lean.MetaM Aesop.RuleTacOutput

full_name: Aesop.RuleTac.applyConst
code: def applyConst (decl : Name) (pat? : Option RulePattern)
    (md : TransparencyMode) : RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.applyTerm
code: def applyTerm (stx : Term) (pat? : Option RulePattern) (md : TransparencyMode) :
    RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.apply
code: def apply (t : RuleTerm) (pat? : Option RulePattern) (md : TransparencyMode) :
    RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.applyConsts
code: def applyConsts (decls : Array Name) (md : TransparencyMode) :
    RuleTac 
goal: Aesop.RuleTac
File: .lake/packages/aesop/Aesop/ElabM.lean

full_name: Aesop.ElabM.Context.parsePriorities
code: structure Context where
  parsePriorities : Bool
  goal : MVarId
goal: Bool

full_name: Aesop.ElabM.Context
code: structure Context where
  parsePriorities : Bool
  goal : MVarId
goal: Type

full_name: Aesop.ElabM.Context.goal
code: structure Context where
  parsePriorities : Bool
  goal : MVarId
goal: Lean.MVarId

full_name: Aesop.ElabM.Context.forAdditionalRules
code: def forAdditionalRules (goal : MVarId) : Context 
goal: Aesop.ElabM.Context

full_name: Aesop.ElabM.Context.forAdditionalGlobalRules
code: def forAdditionalGlobalRules : MetaM Context 
goal: Lean.MetaM Aesop.ElabM.Context

full_name: Aesop.ElabM.Context.forErasing
code: def forErasing (goal : MVarId) : Context 
goal: Aesop.ElabM.Context

full_name: Aesop.ElabM.Context.forGlobalErasing
code: def forGlobalErasing : MetaM Context 
goal: Lean.MetaM Aesop.ElabM.Context

full_name: Aesop.ElabM
code: abbrev ElabM 
goal: Type

full_name: Aesop.instMonadElabM
code: instance : Monad ElabM 
goal: Monad Aesop.ElabM

full_name: Aesop.ElabM.run
code: protected def ElabM.run (ctx : Context) (x : ElabM α) : TermElabM α 
goal: Lean.Elab.TermElabM α

full_name: Aesop.shouldParsePriorities
code: def shouldParsePriorities : ElabM Bool 
goal: Aesop.ElabM Bool

full_name: Aesop.getGoal
code: def getGoal : ElabM MVarId 
goal: Aesop.ElabM Lean.MVarId
File: .lake/packages/aesop/Aesop/RuleTac/Preprocess.lean

full_name: Aesop.RuleTac.preprocess
code: /--
This `RuleTac` is applied once to the root goal, before any other rules are
tried.
-/
def preprocess : RuleTac 
goal: Aesop.RuleTac
File: .lake/packages/aesop/Aesop/RuleTac/Tactic.lean

full_name: Aesop.RuleTac.tacticMImpl
code: unsafe def tacticMImpl (decl : Name) : RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.tacticM
code: @[implemented_by tacticMImpl]
opaque tacticM (decl : Name) : RuleTac
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.ruleTacImpl
code: unsafe def ruleTacImpl (decl : Name) : RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.ruleTac
code: @[implemented_by ruleTacImpl]
opaque ruleTac (decl : Name) : RuleTac
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.singleRuleTacImpl
code: unsafe def singleRuleTacImpl (decl : Name) : RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.singleRuleTac
code: @[implemented_by singleRuleTacImpl]
opaque singleRuleTac (decl : Name) : RuleTac
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.tacticStx
code: /--
Elaborates and runs the given tactic syntax `stx`. The syntax `stx` must be of
kind `tactic` or `tacticSeq`.
-/
def tacticStx (stx : Syntax) : RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.tacGenImpl
code: unsafe def tacGenImpl (decl : Name) : RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.tacGen
code: @[implemented_by tacGenImpl]
opaque tacGen (decl : Name) : RuleTac
goal: Aesop.RuleTac
File: .lake/packages/aesop/Aesop/Exception.lean

full_name: Aesop.«_aux_.lake_packages_aesop_Aesop_Exception___macroRules_Aesop_commandDeclare_aesop_exception____1»
code: macro "declare_aesop_exception"
    excName:ident idName:ident testName:ident : command =>
  `(initialize $idName : InternalExceptionId ←
      Lean.registerInternalExceptionId $(quote $ `Aesop ++ excName.getId)

    def $excName : Exception :=
      .internal $idName

    def $testName : Exception → Bool
      | .internal id _ => id == $idName
      | _ => false)
goal: Lean.Macro

full_name: Aesop.commandDeclare_aesop_exception___
code: macro "declare_aesop_exception"
    excName:ident idName:ident testName:ident : command =>
  `(initialize $idName : InternalExceptionId ←
      Lean.registerInternalExceptionId $(quote $ `Aesop ++ excName.getId)

    def $excName : Exception :=
      .internal $idName

    def $testName : Exception → Bool
      | .internal id _ => id == $idName
      | _ => false)
goal: Lean.ParserDescr
File: .lake/packages/aesop/Aesop/Tree/RunMetaM.lean

full_name: Aesop.Rapp.runMetaM
code: def Rapp.runMetaM (x : MetaM α) (r : Rapp) : MetaM (α × Meta.SavedState) 
goal: Lean.MetaM (α × Lean.Meta.SavedState)

full_name: Aesop.Rapp.runMetaM'
code: def Rapp.runMetaM' (x : MetaM α) (r : Rapp) : MetaM α 
goal: Lean.MetaM α

full_name: Aesop.Rapp.runMetaMModifying
code: def Rapp.runMetaMModifying (x : MetaM α) (r : Rapp) : MetaM (α × Rapp) 
goal: Lean.MetaM (α × Aesop.Rapp)

full_name: Aesop.RappRef.runMetaMModifying
code: def RappRef.runMetaMModifying (x : MetaM α) (rref : RappRef) : MetaM α 
goal: Lean.MetaM α

full_name: Aesop.Goal.runMetaMInPostNormState
code: def Goal.runMetaMInPostNormState (x : MVarId → MetaM α) (g : Goal) :
    MetaM (α × Meta.SavedState) 
goal: Lean.MetaM (α × Lean.Meta.SavedState)

full_name: Aesop.Goal.runMetaMInPostNormState'
code: def Goal.runMetaMInPostNormState' (x : MVarId → MetaM α) (g : Goal) : MetaM α 
goal: Lean.MetaM α

full_name: Aesop.Goal.runMetaMInParentState
code: def Goal.runMetaMInParentState (x : MetaM α) (g : Goal) :
    MetaM (α × Meta.SavedState) 
goal: Lean.MetaM (α × Lean.Meta.SavedState)

full_name: Aesop.Goal.runMetaMInParentState'
code: def Goal.runMetaMInParentState' (x : MetaM α) (g : Goal) :
    MetaM α 
goal: Lean.MetaM α

full_name: Aesop.Goal.runMetaMModifyingParentState
code: def Goal.runMetaMModifyingParentState (x : MetaM α) (g : Goal) :
    MetaM α 
goal: Lean.MetaM α

full_name: Aesop.Rapp.runMetaMInParentState
code: def Rapp.runMetaMInParentState (x : MetaM α) (r : Rapp) :
    MetaM (α × Meta.SavedState) 
goal: Lean.MetaM (α × Lean.Meta.SavedState)

full_name: Aesop.Rapp.runMetaMInParentState'
code: def Rapp.runMetaMInParentState' (x : MetaM α) (r : Rapp) :
    MetaM α 
goal: Lean.MetaM α

full_name: Aesop.Rapp.runMetaMModifyingParentState
code: def Rapp.runMetaMModifyingParentState (x : MetaM α) (r : Rapp) :
    MetaM α 
goal: Lean.MetaM α
File: .lake/packages/aesop/Aesop/RuleTac/Cases.lean

full_name: Aesop.CasesPattern.toExpr
code: def CasesPattern.toExpr (p : CasesPattern) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Aesop.CasesTarget'
code: inductive CasesTarget' where
  | decl (decl : Name)
  | patterns (ps : Array (Expr × Meta.SavedState))
goal: Type

full_name: Aesop.CasesTarget'.patterns
code: inductive CasesTarget' where
  | decl (decl : Name)
  | patterns (ps : Array (Expr × Meta.SavedState))
goal: Aesop.CasesTarget'

full_name: Aesop.CasesTarget'.decl
code: inductive CasesTarget' where
  | decl (decl : Name)
  | patterns (ps : Array (Expr × Meta.SavedState))
goal: Aesop.CasesTarget'

full_name: Aesop.CasesTarget.toCasesTarget'
code: def CasesTarget.toCasesTarget' : CasesTarget → MetaM CasesTarget'
  
goal: Aesop.CasesTarget → Lean.MetaM Aesop.CasesTarget'

full_name: Aesop.RuleTac.cases.findFirstApplicableHyp
code: partial def cases (target : CasesTarget) (md : TransparencyMode)
    (isRecursiveType : Bool) (ctorNames : Array CtorNames) : RuleTac 
goal: Lean.MetaM (Option Lean.FVarId)

full_name: Aesop.RuleTac.cases
code: partial def cases (target : CasesTarget) (md : TransparencyMode)
    (isRecursiveType : Bool) (ctorNames : Array CtorNames) : RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.cases.go
code: partial def cases (target : CasesTarget) (md : TransparencyMode)
    (isRecursiveType : Bool) (ctorNames : Array CtorNames) : RuleTac 
goal: Aesop.ScriptM (Option (Array Lean.MVarId))
File: .lake/packages/aesop/Aesop/Tree/Free.lean

full_name: _private.«.lake».packages.aesop.Aesop.Tree.Free.0.Aesop.mkDummyRefs
code: private def mkDummyRefs : BaseIO (GoalRef × MVarClusterRef) 
goal: BaseIO (Aesop.GoalRef × Aesop.MVarClusterRef)

full_name: Aesop.GoalRef.free
code: def GoalRef.free (gref : GoalRef) : BaseIO Unit 
goal: BaseIO Unit

full_name: Aesop.RappRef.free
code: def RappRef.free (rref : RappRef) : BaseIO Unit 
goal: BaseIO Unit

full_name: Aesop.MVarClusterRef.free
code: def MVarClusterRef.free (cref : MVarClusterRef) : BaseIO Unit 
goal: BaseIO Unit

full_name: Aesop.freeTree
code: def freeTree : TreeM Unit 
goal: Aesop.TreeM Unit
File: .lake/packages/aesop/Aesop/RuleTac/ElabRuleTerm.lean

full_name: Aesop.elabGlobalRuleIdent?
code: def elabGlobalRuleIdent? (stx : Term) : TermElabM (Option Name) 
goal: Lean.Elab.TermElabM (Option Lean.Name)

full_name: Aesop.elabInductiveRuleIdent?
code: def elabInductiveRuleIdent? (stx : Term) : TermElabM (Option InductiveVal) 
goal: Lean.Elab.TermElabM (Option Lean.InductiveVal)

full_name: Aesop.runTacticMAsTermElabM
code: def runTacticMAsTermElabM (goal : MVarId) (x : TacticM α) : TermElabM α 
goal: Lean.Elab.TermElabM α

full_name: Aesop.runTacticMAsElabM
code: def runTacticMAsElabM (x : TacticM α) : ElabM α 
goal: Aesop.ElabM α

full_name: Aesop.withFullElaboration
code: def withFullElaboration (x : TermElabM α) : TermElabM α 
goal: Lean.Elab.TermElabM α

full_name: Aesop.elabRuleTermForApplyLikeCore
code: def elabRuleTermForApplyLikeCore (goal : MVarId) (stx : Term): TermElabM Expr 
goal: Lean.Elab.TermElabM Lean.Expr

full_name: Aesop.elabRuleTermForApplyLikeMetaM
code: def elabRuleTermForApplyLikeMetaM (goal : MVarId) (stx : Term) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Aesop.elabRuleTermForApplyLike
code: def elabRuleTermForApplyLike (stx : Term) : ElabM Expr 
goal: Aesop.ElabM Lean.Expr

full_name: Aesop.elabSimpTheorems
code: def elabSimpTheorems (stx : Syntax) (ctx : Simp.Context)
    (simprocs : Simp.SimprocsArray) (isSimpAll : Bool) :
    TacticM (Simp.Context × Simp.SimprocsArray) 
goal: Lean.Elab.Tactic.TacticM (Lean.Meta.Simp.Context × Lean.Meta.Simp.SimprocsArray)

full_name: Aesop.mkSimpArgs
code: def mkSimpArgs (simpTheorem : Term) : Syntax 
goal: Lean.Syntax

full_name: Aesop.elabRuleTermForSimpCore
code: def elabRuleTermForSimpCore (goal : MVarId) (term : Term) (ctx : Simp.Context)
    (simprocs : Simp.SimprocsArray) (isSimpAll : Bool) :
    TermElabM (Simp.Context × Simp.SimprocsArray) 
goal: Lean.Elab.TermElabM (Lean.Meta.Simp.Context × Lean.Meta.Simp.SimprocsArray)

full_name: Aesop.checkElabRuleTermForSimp
code: def checkElabRuleTermForSimp (term : Term) (isSimpAll : Bool) : ElabM Unit 
goal: Aesop.ElabM Unit

full_name: Aesop.elabRuleTermForSimpMetaM
code: def elabRuleTermForSimpMetaM (goal : MVarId) (term : Term) (ctx : Simp.Context)
    (simprocs : Simp.SimprocsArray) (isSimpAll : Bool) :
    MetaM (Simp.Context × Simp.SimprocsArray) 
goal: Lean.MetaM (Lean.Meta.Simp.Context × Lean.Meta.Simp.SimprocsArray)
File: .lake/packages/aesop/Aesop/Tree/Traversal.lean

full_name: Aesop.TreeRef.mvarCluster
code: inductive TreeRef
  | goal (gref : GoalRef)
  | rapp (rref : RappRef)
  | mvarCluster (cref : MVarClusterRef)
goal: Aesop.TreeRef

full_name: Aesop.TreeRef.rapp
code: inductive TreeRef
  | goal (gref : GoalRef)
  | rapp (rref : RappRef)
  | mvarCluster (cref : MVarClusterRef)
goal: Aesop.TreeRef

full_name: Aesop.TreeRef.goal
code: inductive TreeRef
  | goal (gref : GoalRef)
  | rapp (rref : RappRef)
  | mvarCluster (cref : MVarClusterRef)
goal: Aesop.TreeRef

full_name: Aesop.TreeRef
code: inductive TreeRef
  | goal (gref : GoalRef)
  | rapp (rref : RappRef)
  | mvarCluster (cref : MVarClusterRef)
goal: Type

full_name: Aesop.traverseDown
code: @[specialize]
partial def traverseDown : TreeRef → m Unit
  
goal: Aesop.TreeRef → m Unit

full_name: Aesop.traverseUp
code: @[specialize]
partial def traverseUp : TreeRef → m Unit
  
goal: Aesop.TreeRef → m Unit

full_name: Aesop.preTraverseDown
code: @[inline]
def preTraverseDown (visitGoal : GoalRef → m Bool)
    (visitRapp : RappRef → m Bool) (visitMVarCluster : MVarClusterRef → m Bool) :
    TreeRef → m Unit 
goal: Aesop.TreeRef → m Unit

full_name: Aesop.preTraverseUp
code: @[inline]
def preTraverseUp (visitGoal : GoalRef → m Bool) (visitRapp : RappRef → m Bool)
    (visitMVarCluster : MVarClusterRef → m Bool) : TreeRef → m Unit 
goal: Aesop.TreeRef → m Unit

full_name: Aesop.postTraverseDown
code: @[inline]
def postTraverseDown (visitGoal : GoalRef → m Unit)
    (visitRapp : RappRef → m Unit) (visitMVarCluster : MVarClusterRef → m Unit) :
    TreeRef → m Unit 
goal: Aesop.TreeRef → m Unit

full_name: Aesop.postTraverseUp
code: @[inline]
def postTraverseUp (visitGoal : GoalRef → m Unit) (visitRapp : RappRef → m Unit)
    (visitMVarCluster : MVarClusterRef → m Unit) : TreeRef → m Unit 
goal: Aesop.TreeRef → m Unit
File: .lake/packages/aesop/Aesop/Tree/ExtractScript.lean

full_name: Aesop.ExtractScriptM.Context
code: structure ExtractScriptM.Context where
  completeProof : Bool
goal: Type

full_name: Aesop.ExtractScriptM.Context.completeProof
code: structure ExtractScriptM.Context where
  completeProof : Bool
goal: Bool

full_name: Aesop.ExtractScriptM.State
code: structure ExtractScriptM.State where
  script : UScript := #[]
goal: Type

full_name: Aesop.ExtractScriptM.State.script
code: structure ExtractScriptM.State where
  script : UScript := #[]
goal: Aesop.Script.UScript

full_name: Aesop.ExtractScriptM
code: abbrev ExtractScriptM 
goal: Type

full_name: Aesop.ExtractScriptM.run
code: def ExtractScriptM.run (completeProof : Bool) (x : ExtractScriptM α) :
    TreeM UScript 
goal: Aesop.TreeM Aesop.Script.UScript

full_name: Aesop.ExtractScript.lazyStepToStep
code: def lazyStepToStep (ruleName : DisplayRuleName) (lstep : LazyStep) :
    MetaM Step 
goal: Lean.MetaM Aesop.Script.Step

full_name: Aesop.ExtractScript.lazyStepsToSteps
code: def lazyStepsToSteps (ruleName : DisplayRuleName) :
    Option (Array LazyStep) → MetaM (Array Step)
  
goal: Option (Array Aesop.Script.LazyStep) → Lean.MetaM (Array Aesop.Script.Step)

full_name: Aesop.ExtractScript.recordStep
code: def recordStep (step : Script.Step) : ExtractScriptM Unit 
goal: Aesop.ExtractScriptM Unit

full_name: Aesop.ExtractScript.recordLazySteps
code: def recordLazySteps (ruleName : DisplayRuleName)
    (steps? : Option (Array Script.LazyStep)) : ExtractScriptM Unit 
goal: Aesop.ExtractScriptM Unit

full_name: Aesop.ExtractScript.visitGoal
code: def visitGoal (g : Goal) : ExtractScriptM Unit 
goal: Aesop.ExtractScriptM Unit

full_name: Aesop.ExtractScript.visitRapp
code: def visitRapp (r : Rapp) : ExtractScriptM Unit 
goal: Aesop.ExtractScriptM Unit

full_name: Aesop.extractScript
code: @[inline]
def extractScript : TreeM UScript 
goal: Aesop.TreeM Aesop.Script.UScript

full_name: Aesop.extractSafePrefixScript
code: def extractSafePrefixScript : TreeM UScript 
goal: Aesop.TreeM Aesop.Script.UScript