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

full_name: Aesop.ScriptT
code: abbrev ScriptT m 
goal: Type

full_name: Aesop.ScriptT.run
code: protected def run [Monad m] [MonadLiftT (ST IO.RealWorld) m] (x : ScriptT m α) :
    m (α × Array LazyStep) 
goal: m (α × Array Aesop.Script.LazyStep)

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

full_name: Aesop.recordScriptStep
code: def recordScriptStep (step : LazyStep) : m Unit 
goal: m Unit

full_name: Aesop.recordScriptSteps
code: def recordScriptSteps (steps : Array LazyStep) : m Unit 
goal: m Unit

full_name: Aesop.withScriptStep
code: def withScriptStep (preGoal : MVarId) (postGoals : α → Array MVarId)
    (success : α → Bool) (tacticBuilder : α → TacticBuilder) (x : MetaM α) :
    ScriptM α 
goal: Aesop.ScriptM α

full_name: Aesop.withOptScriptStep
code: def withOptScriptStep (preGoal : MVarId) (postGoals : α → Array MVarId)
    (tacticBuilder : α → TacticBuilder) (x : MetaM (Option α)) :
    ScriptM (Option α) 
goal: Aesop.ScriptM (Option α)
File: .lake/packages/aesop/Aesop/Script/TacticState.lean

full_name: Aesop.Script.TacticState.invisibleGoals
code: structure TacticState where
  visibleGoals : Array GoalWithMVars
  invisibleGoals : HashSet MVarId
  deriving Inhabited
goal: Lean.HashSet Lean.MVarId

full_name: Aesop.Script.TacticState
code: structure TacticState where
  visibleGoals : Array GoalWithMVars
  invisibleGoals : HashSet MVarId
  deriving Inhabited
goal: Type

full_name: Aesop.Script.TacticState.visibleGoals
code: structure TacticState where
  visibleGoals : Array GoalWithMVars
  invisibleGoals : HashSet MVarId
  deriving Inhabited
goal: Array Aesop.GoalWithMVars

full_name: Aesop.Script.instInhabitedTacticState
code: structure TacticState where
  visibleGoals : Array GoalWithMVars
  invisibleGoals : HashSet MVarId
  deriving Inhabited
goal: Inhabited Aesop.Script.TacticState

full_name: Aesop.Script.TacticState.mkInitial
code: def mkInitial (goal : MVarId) : MetaM TacticState 
goal: Lean.MetaM Aesop.Script.TacticState

full_name: _private.«.lake».packages.aesop.Aesop.Script.TacticState.0.Aesop.Script.TacticState.throwUnknownGoalError
code: private def throwUnknownGoalError (goal : MVarId) (pre : MessageData) : m α 
goal: m α

full_name: Aesop.Script.TacticState.getVisibleGoalIndex?
code: def getVisibleGoalIndex? (ts : TacticState) (goal : MVarId) : Option Nat 
goal: Option Nat

full_name: Aesop.Script.TacticState.getVisibleGoalIndex
code: def getVisibleGoalIndex (ts : TacticState) (goal : MVarId) : m Nat 
goal: m Nat

full_name: Aesop.Script.TacticState.getMainGoal?
code: def getMainGoal? (ts : TacticState) : Option MVarId 
goal: Option Lean.MVarId

full_name: Aesop.Script.TacticState.visibleGoalsHaveMVars
code: def visibleGoalsHaveMVars (ts : TacticState) : Bool 
goal: Bool

full_name: Aesop.Script.TacticState.solveVisibleGoals
code: def solveVisibleGoals (ts : TacticState) : TacticState 
goal: Aesop.Script.TacticState

full_name: _private.«.lake».packages.aesop.Aesop.Script.TacticState.0.Aesop.Script.TacticState.replaceWithArray
code: private def replaceWithArray [BEq α] (xs : Array α) (x : α) (r : Array α) :
    Option (Array α) 
goal: Option (Array α)

full_name: Aesop.Script.TacticState.eraseSolvedGoals
code: def eraseSolvedGoals (ts : TacticState) (preMCtx postMCtx : MetavarContext) :
    TacticState 
goal: Aesop.Script.TacticState

full_name: Aesop.Script.TacticState.eraseSolvedGoals.mvarWasSolved
code: def eraseSolvedGoals (ts : TacticState) (preMCtx postMCtx : MetavarContext) :
    TacticState 
goal: Bool

full_name: Aesop.Script.TacticState.applyTactic
code: def applyTactic (ts : TacticState) (inGoal : MVarId)
    (outGoals : Array GoalWithMVars) (preMCtx postMCtx : MetavarContext) :
    m TacticState 
goal: m Aesop.Script.TacticState

full_name: Aesop.Script.TacticState.focus
code: def focus (ts : TacticState) (goal : MVarId) : m TacticState 
goal: m Aesop.Script.TacticState

full_name: Aesop.Script.TacticState.onGoalM
code: @[inline, always_inline]
def onGoalM (ts : TacticState) (g : MVarId)
    (f : TacticState → m (α × TacticState)) : m (α × TacticState) 
goal: m (α × Aesop.Script.TacticState)
File: .lake/packages/aesop/Aesop/BuiltinRules/DestructProducts.lean

full_name: _private.«.lake».packages.aesop.Aesop.BuiltinRules.DestructProducts.0.Aesop.BuiltinRules.destructProductHyp?
code: private def destructProductHyp? (goal : MVarId) (hyp : FVarId)
    (md : TransparencyMode) : MetaM (Option (LazyStep × MVarId)) 
goal: Lean.MetaM (Option (Aesop.Script.LazyStep × Lean.MVarId))

full_name: _private.«.lake».packages.aesop.Aesop.BuiltinRules.DestructProducts.0.Aesop.BuiltinRules.destructProductHyp?.go
code: private def destructProductHyp? (goal : MVarId) (hyp : FVarId)
    (md : TransparencyMode) : MetaM (Option (LazyStep × MVarId)) 
goal: Lean.MetaM (Aesop.Script.LazyStep × Lean.MVarId)

full_name: _private.«.lake».packages.aesop.Aesop.BuiltinRules.DestructProducts.0.Aesop.BuiltinRules.destructProductHyp?.tac
code: private def destructProductHyp? (goal : MVarId) (hyp : FVarId)
    (md : TransparencyMode) : MetaM (Option (LazyStep × MVarId)) 
goal: Lean.MetaM (Lean.MVarId × Lean.Name × Lean.Name)

full_name: Aesop.BuiltinRules.destructProductsCore.go
code: partial def destructProductsCore (goal : MVarId) (md : TransparencyMode) :
    MetaM (MVarId × Array LazyStep) 
goal: Aesop.ScriptM Lean.MVarId

full_name: Aesop.BuiltinRules.destructProductsCore
code: partial def destructProductsCore (goal : MVarId) (md : TransparencyMode) :
    MetaM (MVarId × Array LazyStep) 
goal: Lean.MetaM (Lean.MVarId × Array Aesop.Script.LazyStep)

full_name: Aesop.BuiltinRules.destructProducts
code: @[aesop norm 0 (rule_sets := [builtin]) tactic
    (index := [hyp And _ _, hyp Prod _ _, hyp PProd _ _, hyp MProd _ _,
               hyp Exists _, hyp Subtype _, hyp Sigma _, hyp PSigma _])]
partial def destructProducts : RuleTac 
goal: Aesop.RuleTac
File: .lake/packages/aesop/Aesop/Script/CtorNames.lean

full_name: Aesop.CtorNames.args
code: structure CtorNames where
  ctor : Name
  args : Array Name
  /-- Whether the constructor has at least one implicit argument. -/
  hasImplicitArg : Bool
goal: Array Lean.Name

full_name: Aesop.CtorNames.ctor
code: structure CtorNames where
  ctor : Name
  args : Array Name
  /-- Whether the constructor has at least one implicit argument. -/
  hasImplicitArg : Bool
goal: Lean.Name

full_name: Aesop.CtorNames
code: structure CtorNames where
  ctor : Name
  args : Array Name
  /-- Whether the constructor has at least one implicit argument. -/
  hasImplicitArg : Bool
goal: Type

full_name: Aesop.CtorNames.hasImplicitArg
code: structure CtorNames where
  ctor : Name
  args : Array Name
  /-- Whether the constructor has at least one implicit argument. -/
  hasImplicitArg : Bool
goal: Bool

full_name: Aesop.CtorNames.toRCasesPat
code: def toRCasesPat (cn : CtorNames) : TSyntax `rcasesPat 
goal: Lean.TSyntax `rcasesPat

full_name: _private.«.lake».packages.aesop.Aesop.Script.CtorNames.0.Aesop.CtorNames.nameBase
code: private def nameBase : Name → Name
  
goal: Lean.Name → Lean.Name

full_name: Aesop.CtorNames.toInductionAltLHS
code: def toInductionAltLHS (cn : CtorNames) :
    TSyntax ``inductionAltLHS 
goal: Lean.TSyntax `Lean.Parser.Tactic.inductionAltLHS

full_name: Aesop.CtorNames.toInductionAlt
code: def toInductionAlt (cn : CtorNames) (tacticSeq : Array Syntax.Tactic) :
    TSyntax ``inductionAlt 
goal: Lean.TSyntax `Lean.Parser.Tactic.inductionAlt

full_name: Aesop.CtorNames.toAltVarNames
code: def toAltVarNames (cn : CtorNames) : AltVarNames 
goal: Lean.Meta.AltVarNames

full_name: Aesop.CtorNames.mkFreshArgNames
code: def mkFreshArgNames (lctx : LocalContext) (cn : CtorNames) :
    CtorNames × LocalContext 
goal: Aesop.CtorNames × Lean.LocalContext

full_name: Aesop.ctorNamesToRCasesPats
code: def ctorNamesToRCasesPats (cns : Array CtorNames) : TSyntax ``rcasesPatMed 
goal: Lean.TSyntax `Lean.Parser.Tactic.rcasesPatMed

full_name: Aesop.ctorNamesToInductionAlts
code: def ctorNamesToInductionAlts (cns : Array (CtorNames × Array Syntax.Tactic)) :
    TSyntax ``inductionAlts 
goal: Lean.TSyntax `Lean.Parser.Tactic.inductionAlts

full_name: Aesop.mkCtorNames
code: def mkCtorNames (iv : InductiveVal) : CoreM (Array CtorNames) 
goal: Lean.CoreM (Array Aesop.CtorNames)
File: .lake/packages/aesop/Aesop/Script/UScriptToSScript.lean

full_name: Aesop.Script.StepTree
code: inductive StepTree where
  | empty
  | node (step : Step) (index : Nat) (children : Array StepTree)
  deriving Nonempty
goal: Type

full_name: Aesop.Script.StepTree.node
code: inductive StepTree where
  | empty
  | node (step : Step) (index : Nat) (children : Array StepTree)
  deriving Nonempty
goal: Aesop.Script.StepTree

full_name: Aesop.Script.StepTree.empty
code: inductive StepTree where
  | empty
  | node (step : Step) (index : Nat) (children : Array StepTree)
  deriving Nonempty
goal: Aesop.Script.StepTree

full_name: Aesop.Script.instNonemptyStepTree
code: inductive StepTree where
  | empty
  | node (step : Step) (index : Nat) (children : Array StepTree)
  deriving Nonempty
goal: Nonempty Aesop.Script.StepTree

full_name: Aesop.Script.StepTree.toMessageData?
code: protected partial def toMessageData? : StepTree → Option MessageData
  
goal: Aesop.Script.StepTree → Option Lean.MessageData

full_name: Aesop.Script.StepTree.toMessageData
code: protected def toMessageData (t : StepTree) : MessageData 
goal: Lean.MessageData

full_name: Aesop.Script.instToMessageDataStepTree
code: instance : ToMessageData StepTree 
goal: Lean.ToMessageData Aesop.Script.StepTree

full_name: Aesop.Script.UScript.toStepTree.go
code: partial def UScript.toStepTree (s : UScript) : StepTree 
goal: Aesop.Script.StepTree

full_name: Aesop.Script.UScript.toStepTree
code: partial def UScript.toStepTree (s : UScript) : StepTree 
goal: Aesop.Script.StepTree

full_name: Aesop.Script.sortDedupArrays
code: def sortDedupArrays [Ord α] (as : Array (Array α)) : Array α 
goal: Array α

full_name: Aesop.Script.isConsecutiveSequence
code: def isConsecutiveSequence (ns : Array Nat) : Bool 
goal: Bool

full_name: Aesop.Script.StepTree.focusableGoals
code: partial def focusableGoals (t : StepTree) : HashMap MVarId Nat 
goal: Lean.HashMap Lean.MVarId Nat

full_name: Aesop.Script.StepTree.focusableGoals.go
code: partial def focusableGoals (t : StepTree) : HashMap MVarId Nat 
goal: Aesop.Script.StepTree → StateRefT' σ (Lean.HashMap Lean.MVarId Nat) (ST σ) (Array Nat)

full_name: Aesop.Script.StepTree.numSiblings
code: partial def numSiblings (t : StepTree) : HashMap MVarId Nat 
goal: Lean.HashMap Lean.MVarId Nat

full_name: Aesop.Script.StepTree.numSiblings.go
code: partial def numSiblings (t : StepTree) : HashMap MVarId Nat 
goal: Aesop.Script.StepTree → StateRefT' σ (Lean.HashMap Lean.MVarId Nat) (ST σ) Unit

full_name: Aesop.Script.orderedUScriptToSScript
code: partial def orderedUScriptToSScript (uscript : UScript) (tacticState : TacticState) : CoreM SScript 
goal: Lean.CoreM Aesop.Script.SScript

full_name: Aesop.Script.orderedUScriptToSScript.go
code: partial def orderedUScriptToSScript (uscript : UScript) (tacticState : TacticState) : CoreM SScript 
goal: Lean.CoreM (Aesop.Script.SScript × Aesop.Script.TacticState)
File: .lake/packages/aesop/Aesop/Stats/Report.lean

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

full_name: Aesop.StatsReport.instToStringNanos
code: local instance : ToString Nanos 
goal: ToString Aesop.Nanos

full_name: _private.«.lake».packages.aesop.Aesop.Stats.Report.0.Aesop.StatsReport.fmtTime
code: private def fmtTime (n : Nanos) (samples : Nat) : Format 
goal: Lean.Format

full_name: Aesop.StatsReport.default.fmtRuleStats
code: def default : StatsReport 
goal: Lean.Format

full_name: Aesop.StatsReport.default
code: def default : StatsReport 
goal: Aesop.StatsReport

full_name: Aesop.StatsReport.scripts
code: def scripts : StatsReport 
goal: Aesop.StatsReport
File: .lake/packages/aesop/Aesop/Options/Internal.lean

full_name: Aesop.Options'.forwardMaxDepth?
code: structure Options' extends Options where
  generateScript : Bool
  forwardMaxDepth? : Option Nat
  deriving Inhabited
goal: Option Nat

full_name: Aesop.instInhabitedOptions'
code: structure Options' extends Options where
  generateScript : Bool
  forwardMaxDepth? : Option Nat
  deriving Inhabited
goal: Inhabited Aesop.Options'

full_name: Aesop.Options'.generateScript
code: structure Options' extends Options where
  generateScript : Bool
  forwardMaxDepth? : Option Nat
  deriving Inhabited
goal: Bool

full_name: Aesop.Options'
code: structure Options' extends Options where
  generateScript : Bool
  forwardMaxDepth? : Option Nat
  deriving Inhabited
goal: Type

full_name: Aesop.Options.toOptions'
code: def Options.toOptions' [Monad m] [MonadOptions m] (opts : Options)
    (forwardMaxDepth? : Option Nat := none) : m Options' 
goal: m Aesop.Options'
File: .lake/packages/aesop/Aesop/Builder/Unfold.lean

full_name: Aesop.RuleBuilder.hasConst
code: def hasConst (c : Name) (e : Expr) : Bool 
goal: Bool

full_name: Aesop.RuleBuilder.checkUnfoldableConst
code: def checkUnfoldableConst (decl : Name) : MetaM (Option Name) 
goal: Lean.MetaM (Option Lean.Name)

full_name: Aesop.RuleBuilder.unfoldCore
code: def unfoldCore (decl : Name) : MetaM LocalRuleSetMember 
goal: Lean.MetaM Aesop.LocalRuleSetMember

full_name: Aesop.RuleBuilder.unfold
code: def unfold : RuleBuilder 
goal: Aesop.RuleBuilder
File: .lake/packages/aesop/Aesop/Builder/Cases.lean

full_name: Aesop.CasesPattern.check
code: def check (decl : Name) (p : CasesPattern) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Aesop.CasesPattern.toIndexingMode
code: def toIndexingMode (p : CasesPattern) : MetaM IndexingMode 
goal: Lean.MetaM Aesop.IndexingMode

full_name: Aesop.RuleBuilderOptions.casesTransparency
code: def casesTransparency (opts : RuleBuilderOptions) : TransparencyMode 
goal: Lean.Meta.TransparencyMode

full_name: Aesop.RuleBuilderOptions.casesIndexTransparency
code: def casesIndexTransparency (opts : RuleBuilderOptions) : TransparencyMode 
goal: Lean.Meta.TransparencyMode

full_name: Aesop.RuleBuilderOptions.casesPatterns
code: def casesPatterns (opts : RuleBuilderOptions) : Array CasesPattern 
goal: Array Aesop.CasesPattern

full_name: Aesop.RuleBuilder.mkCasesTarget
code: def mkCasesTarget (decl : Name) (casesPatterns : Array CasesPattern) :
    CasesTarget 
goal: Aesop.CasesTarget

full_name: Aesop.RuleBuilder.getCasesIndexingMode
code: def getCasesIndexingMode (decl : Name) (indexMd : TransparencyMode)
    (casesPatterns : Array CasesPattern) : MetaM IndexingMode 
goal: Lean.MetaM Aesop.IndexingMode

full_name: Aesop.RuleBuilder.casesCore
code: def casesCore (info : InductiveVal) (pats : Array CasesPattern)
    (imode? : Option IndexingMode) (md indexMd : TransparencyMode)
    (phase : PhaseSpec) : MetaM LocalRuleSetMember 
goal: Lean.MetaM Aesop.LocalRuleSetMember

full_name: Aesop.RuleBuilder.cases
code: def cases : RuleBuilder 
goal: Aesop.RuleBuilder
File: .lake/packages/aesop/Aesop/Builder/Constructors.lean

full_name: Aesop.RuleBuilderOptions.constructorsTransparency
code: def constructorsTransparency (opts : RuleBuilderOptions) : TransparencyMode 
goal: Lean.Meta.TransparencyMode

full_name: Aesop.RuleBuilderOptions.constructorsIndexTransparency
code: def constructorsIndexTransparency (opts : RuleBuilderOptions) : TransparencyMode 
goal: Lean.Meta.TransparencyMode

full_name: Aesop.RuleBuilder.getConstructorsIndexingMode
code: def getConstructorsIndexingMode (indexMd : TransparencyMode)
    (info : InductiveVal) : MetaM IndexingMode 
goal: Lean.MetaM Aesop.IndexingMode

full_name: Aesop.RuleBuilder.constructorsCore
code: def constructorsCore (info : InductiveVal) (imode? : Option IndexingMode)
    (md indexMd : TransparencyMode) (phase : PhaseSpec) :
    MetaM LocalRuleSetMember 
goal: Lean.MetaM Aesop.LocalRuleSetMember

full_name: Aesop.RuleBuilder.constructors
code: def constructors : RuleBuilder 
goal: Aesop.RuleBuilder
File: .lake/packages/aesop/Aesop/Builder/Apply.lean

full_name: Aesop.RuleBuilderOptions.applyTransparency
code: def applyTransparency (opts : RuleBuilderOptions) : TransparencyMode 
goal: Lean.Meta.TransparencyMode

full_name: Aesop.RuleBuilderOptions.applyIndexTransparency
code: def applyIndexTransparency (opts : RuleBuilderOptions) : TransparencyMode 
goal: Lean.Meta.TransparencyMode

full_name: Aesop.RuleBuilder.getApplyIndexingMode
code: def getApplyIndexingMode (indexMd : TransparencyMode) (type : Expr) :
    MetaM IndexingMode 
goal: Lean.MetaM Aesop.IndexingMode

full_name: Aesop.RuleBuilder.applyCore
code: def applyCore (t : ElabRuleTerm) (pat? : Option RulePattern)
    (imode? : Option IndexingMode) (md indexMd : TransparencyMode)
    (phase : PhaseSpec) : MetaM LocalRuleSetMember 
goal: Lean.MetaM Aesop.LocalRuleSetMember

full_name: Aesop.RuleBuilder.apply
code: def apply : RuleBuilder 
goal: Aesop.RuleBuilder
File: .lake/packages/aesop/Aesop/Builder/NormSimp.lean

full_name: _private.«.lake».packages.aesop.Aesop.Builder.NormSimp.0.Aesop.getSimpEntriesFromPropConst
code: private def getSimpEntriesFromPropConst (decl : Name) :
    MetaM (Array SimpEntry) 
goal: Lean.MetaM (Array Lean.Meta.SimpEntry)

full_name: _private.«.lake».packages.aesop.Aesop.Builder.NormSimp.0.Aesop.getSimpEntriesForConst
code: private def getSimpEntriesForConst (decl : Name) : MetaM (Array SimpEntry) 
goal: Lean.MetaM (Array Lean.Meta.SimpEntry)

full_name: Aesop.PhaseSpec.getSimpPrio
code: def PhaseSpec.getSimpPrio [Monad m] [MonadError m] : PhaseSpec → m Nat
  
goal: Aesop.PhaseSpec → m Nat

full_name: Aesop.RuleBuilder.simpCore
code: def simpCore (decl : Name) (phase : PhaseSpec) : MetaM LocalRuleSetMember 
goal: Lean.MetaM Aesop.LocalRuleSetMember

full_name: Aesop.RuleBuilder.simp
code: def simp : RuleBuilder 
goal: Aesop.RuleBuilder
File: .lake/packages/aesop/Aesop/Builder/Tactic.lean

full_name: Aesop.matchByTactic?
code: def matchByTactic? : Term → Option (TSyntax ``tacticSeq)
  
goal: Lean.Term → Option (Lean.TSyntax `Lean.Parser.Tactic.tacticSeq)

full_name: Aesop.RuleBuilder.tacticIMode
code: def tacticIMode (imode? : Option IndexingMode) : IndexingMode 
goal: Aesop.IndexingMode

full_name: Aesop.RuleBuilder.tacticCore
code: def tacticCore (t : Sum Name (TSyntax ``tacticSeq)) (imode? : Option IndexingMode) (phase : PhaseSpec) :
    MetaM LocalRuleSetMember 
goal: Lean.MetaM Aesop.LocalRuleSetMember

full_name: Aesop.RuleBuilder.tactic
code: def tactic : RuleBuilder 
goal: Aesop.RuleBuilder
File: .lake/packages/aesop/Aesop/Builder/Default.lean

full_name: Aesop.RuleBuilder.default.err
code: def RuleBuilder.default : RuleBuilder 
goal: Aesop.RuleBuilderInput → Aesop.ElabM Aesop.LocalRuleSetMember

full_name: Aesop.RuleBuilder.default
code: def RuleBuilder.default : RuleBuilder 
goal: Aesop.RuleBuilder
File: .lake/packages/aesop/Aesop/BuiltinRules.lean

full_name: Aesop.BuiltinRules.not_intro
code: @[aesop (rule_sets := [builtin]) safe 0]
theorem not_intro (h : P → False) : ¬ P 
goal: ¬P

full_name: Aesop.BuiltinRules.empty_false
code: @[aesop (rule_sets := [builtin]) norm destruct]
theorem empty_false (h : Empty) : False 
goal: False

full_name: Aesop.BuiltinRules.pEmpty_false
code: @[aesop (rule_sets := [builtin]) norm destruct]
theorem pEmpty_false (h : PEmpty) : False 
goal: False

full_name: Aesop.BuiltinRules.heq_iff_eq
code: @[aesop (rule_sets := [builtin]) norm simp]
theorem heq_iff_eq (x y : α) : HEq x y ↔ x = y 
goal: HEq x y ↔ x = y
File: .lake/packages/aesop/Aesop/Search/Queue/Class.lean

full_name: Aesop.Queue.popGoal
code: class Queue (Q : Type) where
  init : BaseIO Q
  addGoals : Q → Array GoalRef → BaseIO Q
  popGoal : Q → BaseIO (Option GoalRef × Q)
goal: Q → BaseIO (Option Aesop.GoalRef × Q)

full_name: Aesop.Queue.addGoals
code: class Queue (Q : Type) where
  init : BaseIO Q
  addGoals : Q → Array GoalRef → BaseIO Q
  popGoal : Q → BaseIO (Option GoalRef × Q)
goal: Q → Array Aesop.GoalRef → BaseIO Q

full_name: Aesop.Queue.init
code: class Queue (Q : Type) where
  init : BaseIO Q
  addGoals : Q → Array GoalRef → BaseIO Q
  popGoal : Q → BaseIO (Option GoalRef × Q)
goal: BaseIO Q

full_name: Aesop.Queue
code: class Queue (Q : Type) where
  init : BaseIO Q
  addGoals : Q → Array GoalRef → BaseIO Q
  popGoal : Q → BaseIO (Option GoalRef × Q)
goal: Type

full_name: Aesop.Queue.init'
code: def init' [Queue Q] (grefs : Array GoalRef) : BaseIO Q 
goal: BaseIO Q
File: .lake/packages/aesop/Aesop/Builder/Forward.lean

full_name: Aesop.RuleBuilderOptions.forwardTransparency
code: def forwardTransparency (opts : RuleBuilderOptions) : TransparencyMode 
goal: Lean.Meta.TransparencyMode

full_name: Aesop.RuleBuilderOptions.forwardIndexTransparency
code: def forwardIndexTransparency (opts : RuleBuilderOptions) : TransparencyMode 
goal: Lean.Meta.TransparencyMode

full_name: _private.«.lake».packages.aesop.Aesop.Builder.Forward.0.Aesop.RuleBuilder.forwardIndexingModeCore
code: private def forwardIndexingModeCore (type : Expr)
    (immediate : UnorderedArraySet Nat) (md : TransparencyMode) :
    MetaM IndexingMode 
goal: Lean.MetaM Aesop.IndexingMode

full_name: Aesop.RuleBuilder.getForwardIndexingMode
code: def getForwardIndexingMode (type : Expr) (immediate : UnorderedArraySet Nat)
    (md indexMd : TransparencyMode) : MetaM IndexingMode 
goal: Lean.MetaM Aesop.IndexingMode

full_name: Aesop.RuleBuilder.getImmediatePremises.errPrefix
code: def getImmediatePremises  (type : Expr) (pat? : Option RulePattern)
    (md : TransparencyMode) :
    Option (Array Name) → MetaM (UnorderedArraySet Nat)
  
goal: Lean.MessageData

full_name: Aesop.RuleBuilder.getImmediatePremises.isPatternInstantiated
code: def getImmediatePremises  (type : Expr) (pat? : Option RulePattern)
    (md : TransparencyMode) :
    Option (Array Name) → MetaM (UnorderedArraySet Nat)
  
goal: Bool

full_name: Aesop.RuleBuilder.getImmediatePremises
code: def getImmediatePremises  (type : Expr) (pat? : Option RulePattern)
    (md : TransparencyMode) :
    Option (Array Name) → MetaM (UnorderedArraySet Nat)
  
goal: Option (Array Lean.Name) → Lean.MetaM (Aesop.UnorderedArraySet Nat)

full_name: Aesop.RuleBuilder.forwardCore
code: def forwardCore (t : ElabRuleTerm) (immediate? : Option (Array Name))
    (pat? : Option RulePattern) (imode? : Option IndexingMode)
    (md indexMd : TransparencyMode) (phase : PhaseSpec) (isDestruct : Bool) :
    MetaM LocalRuleSetMember 
goal: Lean.MetaM Aesop.LocalRuleSetMember

full_name: Aesop.RuleBuilder.forward
code: def forward (isDestruct : Bool) : RuleBuilder 
goal: Aesop.RuleBuilder