ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/aesop/Aesop/Search/Expansion/Simp.lean

full_name: Aesop.SimpResult
code: inductive SimpResult
  | solved (usedTheorems : Simp.UsedSimps)
  | unchanged
  | simplified (newGoal : MVarId) (usedTheorems : UsedSimps)
goal: Type

full_name: Aesop.SimpResult.solved
code: inductive SimpResult
  | solved (usedTheorems : Simp.UsedSimps)
  | unchanged
  | simplified (newGoal : MVarId) (usedTheorems : UsedSimps)
goal: Aesop.SimpResult

full_name: Aesop.SimpResult.unchanged
code: inductive SimpResult
  | solved (usedTheorems : Simp.UsedSimps)
  | unchanged
  | simplified (newGoal : MVarId) (usedTheorems : UsedSimps)
goal: Aesop.SimpResult

full_name: Aesop.SimpResult.simplified
code: inductive SimpResult
  | solved (usedTheorems : Simp.UsedSimps)
  | unchanged
  | simplified (newGoal : MVarId) (usedTheorems : UsedSimps)
goal: Aesop.SimpResult

full_name: Aesop.SimpResult.newGoal?
code: def newGoal? : SimpResult → Option MVarId
  
goal: Aesop.SimpResult → Option Lean.MVarId

full_name: Aesop.addLetDeclsToSimpTheorems
code: /--
Add all `let` hypotheses in the local context as `simp` theorems.

Background: by default, in the goal `x : _ := v ⊢ P[x]`, `simp` does not
substitute `x` by `v` in the target. The `simp` option `zetaDelta` can be used
to make `simp` perform this substitution, but we don't want to set it because
then Aesop `simp` would diverge from default `simp`, so we would have to adjust
the `aesop?` output as well. Instead, we add `let` hypotheses explicitly. This
way, `simp?` picks them up as well.

See lean4#3520.
-/
def addLetDeclsToSimpTheorems (ctx : Simp.Context) : MetaM Simp.Context 
goal: Lean.MetaM Lean.Meta.Simp.Context

full_name: Aesop.addLetDeclsToSimpTheoremsUnlessZetaDelta
code: def addLetDeclsToSimpTheoremsUnlessZetaDelta (ctx : Simp.Context) :
    MetaM Simp.Context 
goal: Lean.MetaM Lean.Meta.Simp.Context

full_name: Aesop.simpGoal
code: def simpGoal (mvarId : MVarId) (ctx : Simp.Context)
    (simprocs : Simp.SimprocsArray) (discharge? : Option Simp.Discharge := none)
    (simplifyTarget : Bool := true) (fvarIdsToSimp : Array FVarId := #[])
    (stats : Simp.Stats := {}) : MetaM SimpResult 
goal: Lean.MetaM Aesop.SimpResult

full_name: Aesop.simpGoalWithAllHypotheses
code: def simpGoalWithAllHypotheses (mvarId : MVarId) (ctx : Simp.Context)
    (simprocs : Simp.SimprocsArray) (discharge? : Option Simp.Discharge := none)
    (simplifyTarget : Bool := true) (stats : Simp.Stats := {}) :
    MetaM SimpResult 
goal: Lean.MetaM Aesop.SimpResult

full_name: Aesop.simpAll
code: def simpAll (mvarId : MVarId) (ctx : Simp.Context)
    (simprocs : Simp.SimprocsArray) (stats : Simp.Stats := {}) :
    MetaM SimpResult 
goal: Lean.MetaM Aesop.SimpResult
File: .lake/packages/aesop/Aesop/Search/ExpandSafePrefix.lean

full_name: Aesop.safeExpansionFailedException
code: declare_aesop_exception
  safeExpansionFailedException safeExpansionFailedExceptionId
  isSafeExpansionFailedException
goal: Lean.Exception

full_name: Aesop.safeExpansionFailedExceptionId
code: declare_aesop_exception
  safeExpansionFailedException safeExpansionFailedExceptionId
  isSafeExpansionFailedException
goal: Lean.InternalExceptionId

full_name: Aesop.initFn._@..lake.packages.aesop.Aesop.Search.ExpandSafePrefix._hyg.8
code: declare_aesop_exception
  safeExpansionFailedException safeExpansionFailedExceptionId
  isSafeExpansionFailedException
goal: IO Lean.InternalExceptionId

full_name: Aesop.isSafeExpansionFailedException
code: declare_aesop_exception
  safeExpansionFailedException safeExpansionFailedExceptionId
  isSafeExpansionFailedException
goal: Lean.Exception → Bool

full_name: Aesop.SafeExpansionM.State.numRapps
code: structure SafeExpansionM.State where
  numRapps : Nat := 0
goal: Nat

full_name: Aesop.SafeExpansionM.State
code: structure SafeExpansionM.State where
  numRapps : Nat := 0
goal: Type

full_name: Aesop.SafeExpansionM
code: abbrev SafeExpansionM Q [Queue Q] 
goal: Type

full_name: _private.«.lake».packages.aesop.Aesop.Search.ExpandSafePrefix.0.Aesop.Goal.isSafeExpanded
code: private def Goal.isSafeExpanded (g : Goal) : BaseIO Bool 
goal: BaseIO Bool

full_name: _private.«.lake».packages.aesop.Aesop.Search.ExpandSafePrefix.0.Aesop.liftSearchM
code: private def liftSearchM (x : SearchM Q α) : SafeExpansionM Q α 
goal: Aesop.SafeExpansionM Q α

full_name: Aesop.expandSafePrefix
code: def expandSafePrefix : SearchM Q Bool 
goal: Aesop.SearchM Q Bool
File: .lake/packages/aesop/Aesop/Saturate.lean

full_name: Aesop.isForwardOrDestructRuleName
code: def isForwardOrDestructRuleName (n : RuleName) : Bool 
goal: Bool

full_name: Aesop.SaturateM.Context
code: structure SaturateM.Context where
  options : Aesop.Options'
goal: Type

full_name: Aesop.SaturateM.Context.options
code: structure SaturateM.Context where
  options : Aesop.Options'
goal: Aesop.Options'

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

full_name: Aesop.getSingleGoal
code: def getSingleGoal [Monad m] [MonadError m] (o : RuleTacOutput) :
    m (MVarId × Meta.SavedState × Option (Array Script.LazyStep)) 
goal: m (Lean.MVarId × Lean.Meta.SavedState × Option (Array Aesop.Script.LazyStep))

full_name: Aesop.initFn._@..lake.packages.aesop.Aesop.Saturate._hyg.185
code: initialize
  registerTraceClass `saturate
goal: IO Unit

full_name: Aesop.saturateCore.go
code: partial def saturateCore (rs : LocalRuleSet) (goal : MVarId) : SaturateM MVarId 
goal: Aesop.SaturateM Lean.MVarId

full_name: Aesop.saturateCore.runFirstRule
code: partial def saturateCore (rs : LocalRuleSet) (goal : MVarId) : SaturateM MVarId 
goal: Aesop.SaturateM (Option Lean.MVarId)

full_name: Aesop.saturateCore
code: partial def saturateCore (rs : LocalRuleSet) (goal : MVarId) : SaturateM MVarId 
goal: Aesop.SaturateM Lean.MVarId

full_name: Aesop.saturateCore.runRule
code: partial def saturateCore (rs : LocalRuleSet) (goal : MVarId) : SaturateM MVarId 
goal: Aesop.SaturateM (Option (Lean.MVarId × Option (Array Aesop.Script.LazyStep)))

full_name: Aesop.saturate
code: def saturate (rs : LocalRuleSet) (goal : MVarId) (options : Aesop.Options') :
    MetaM MVarId 
goal: Lean.MetaM Lean.MVarId
File: .lake/packages/aesop/Aesop/Search/RuleSelection.lean

full_name: Aesop.selectNormRules
code: def selectNormRules [Monad m] [MonadStats m] [MonadLiftT MetaM m]
    (rs : LocalRuleSet) (goal : MVarId) :
    m (Array (IndexMatchResult NormRule)) 
goal: m (Array (Aesop.IndexMatchResult Aesop.NormRule))

full_name: Aesop.preprocessRule
code: def preprocessRule : SafeRule 
goal: Aesop.SafeRule

full_name: Aesop.selectSafeRules
code: def selectSafeRules (g : Goal) :
    SearchM Q (Array (IndexMatchResult SafeRule)) 
goal: Aesop.SearchM Q (Array (Aesop.IndexMatchResult Aesop.SafeRule))

full_name: Aesop.selectUnsafeRules
code: def selectUnsafeRules (postponedSafeRules : Array PostponedSafeRule)
    (gref : GoalRef) : SearchM Q UnsafeQueue 
goal: Aesop.SearchM Q Aesop.UnsafeQueue
File: .lake/packages/aesop/Aesop/Frontend/Basic.lean

full_name: Lean.Parser.Category.Aesop.bool_lit
code: declare_syntax_cat Aesop.bool_lit (behavior := symbol)
goal: Lean.Parser.Category

full_name: Aesop.Frontend.Parser.bool_litTrue
code: syntax "true" : Aesop.bool_lit
goal: Lean.ParserDescr

full_name: Aesop.Frontend.Parser.bool_litFalse
code: syntax "false" : Aesop.bool_lit
goal: Lean.ParserDescr

full_name: Aesop.Frontend.elabBoolLit
code: def elabBoolLit [Monad m] [MonadRef m] [MonadExceptOf Exception m]
    (stx : TSyntax `Aesop.bool_lit) : m Bool 
goal: m Bool
File: .lake/packages/aesop/Aesop/Search/Expansion/Basic.lean

full_name: Aesop.runRuleTac
code: def runRuleTac (tac : RuleTac) (ruleName : RuleName)
    (preState : Meta.SavedState) (input : RuleTacInput) :
    MetaM (Sum Exception RuleTacOutput) 
goal: Lean.MetaM (Lean.Exception ⊕ Aesop.RuleTacOutput)
File: .lake/packages/aesop/Aesop/Frontend/Attribute.lean

full_name: Lean.Parser.Category.Aesop.attr_rules
code: declare_syntax_cat Aesop.attr_rules
goal: Lean.Parser.Category

full_name: Aesop.Frontend.Parser.attr_rules_
code: syntax Aesop.rule_expr : Aesop.attr_rules
goal: Lean.ParserDescr

full_name: Aesop.Frontend.Parser.«attr_rules[_]»
code: syntax "[" Aesop.rule_expr,+,? "]" : Aesop.attr_rules
goal: Lean.ParserDescr

full_name: Aesop.Frontend.Parser.aesop
code: syntax (name := aesop) "aesop" Aesop.attr_rules : attr
goal: Lean.ParserDescr

full_name: Aesop.Frontend.AttrConfig
code: structure AttrConfig where
  rules : Array RuleExpr
  deriving Inhabited
goal: Type

full_name: Aesop.Frontend.AttrConfig.rules
code: structure AttrConfig where
  rules : Array RuleExpr
  deriving Inhabited
goal: Array Aesop.Frontend.RuleExpr

full_name: Aesop.Frontend.instInhabitedAttrConfig
code: structure AttrConfig where
  rules : Array RuleExpr
  deriving Inhabited
goal: Inhabited Aesop.Frontend.AttrConfig

full_name: Aesop.Frontend.AttrConfig.elab
code: def «elab» (stx : Syntax) : TermElabM AttrConfig 
goal: Lean.Elab.TermElabM Aesop.Frontend.AttrConfig

full_name: Aesop.Frontend.initFn._@..lake.packages.aesop.Aesop.Frontend.Attribute._hyg.379
code: initialize registerBuiltinAttribute {
  name := `aesop
  descr := "Register a declaration as an Aesop rule."
  applicationTime := .afterCompilation
  add := λ decl stx attrKind => withRef stx do
    let rules ← runTermElabMAsCoreM do
      let config ← AttrConfig.elab stx
      config.rules.concatMapM (·.buildAdditionalGlobalRules decl)
    for (rule, rsNames) in rules do
      for rsName in rsNames do
        addGlobalRule rsName rule attrKind (checkNotExists := true)
  erase := λ decl =>
    let ruleFilter :=
      { name := decl, scope := .global, builders := #[], phases := #[] }
    eraseGlobalRules RuleSetNameFilter.all ruleFilter (checkExists := true)
}
goal: IO Unit
File: .lake/packages/aesop/Aesop/Util/Tactic.lean

full_name: Aesop.replaceFVar
code: /--
A `MetaM` version of the `replace` tactic. If `fvarId` refers to the
hypothesis `h`, this tactic asserts a new hypothesis `h : type` with proof
`proof : type` and then tries to clear `fvarId`. Unlike `replaceLocalDecl`,
`replaceFVar` always adds the new hypothesis at the end of the local context.

`replaceFVar` returns the new goal, the `FVarId` of the newly asserted
hypothesis and whether the old hypothesis was cleared.
-/
def replaceFVar (goal : MVarId) (fvarId : FVarId) (type : Expr) (proof : Expr) :
    MetaM (MVarId × FVarId × Bool) 
goal: Lean.MetaM (Lean.MVarId × Lean.FVarId × Bool)

full_name: Aesop.introsUnfolding.run
code: /-- Introduce as many binders as possible while unfolding definitions with the
ambient transparency. -/
partial def introsUnfolding (mvarId : MVarId) : MetaM (Array FVarId × MVarId) 
goal: Lean.MetaM (Array Lean.FVarId × Lean.MVarId)

full_name: Aesop.introsUnfolding
code: /-- Introduce as many binders as possible while unfolding definitions with the
ambient transparency. -/
partial def introsUnfolding (mvarId : MVarId) : MetaM (Array FVarId × MVarId) 
goal: Lean.MetaM (Array Lean.FVarId × Lean.MVarId)
File: .lake/packages/batteries/Batteries/Control/ForInStep/Basic.lean

full_name: ForInStep.bind
code: /--
This is similar to a monadic `bind` operator, except that the two type parameters have to be
the same, which prevents putting a monad instance on `ForInStepT m α := m (ForInStep α)`.
-/
@[inline] protected def ForInStep.bind [Monad m]
    (a : ForInStep α) (f : α → m (ForInStep α)) : m (ForInStep α) 
goal: m (ForInStep α)

full_name: ForInStep.bindM
code: @[inherit_doc ForInStep.bind] protected abbrev ForInStep.bindM [Monad m]
    (a : m (ForInStep α)) (f : α → m (ForInStep α)) : m (ForInStep α) 
goal: m (ForInStep α)

full_name: ForInStep.run
code: /--
Get the value out of a `ForInStep`.
This is usually done at the end of a `forIn` loop to scope the early exit to the loop body.
-/
@[inline] def ForInStep.run : ForInStep α → α
  
goal: ForInStep α → α

full_name: ForInStep.bindList
code: /-- Applies function `f` to each element of a list to accumulate a `ForInStep` value. -/
def ForInStep.bindList [Monad m]
      (f : α → β → m (ForInStep β)) : List α → ForInStep β → m (ForInStep β)
  
goal: List α → ForInStep β → m (ForInStep β)
File: .lake/packages/batteries/Batteries/Control/ForInStep/Lemmas.lean

full_name: ForInStep.bind_done
code: @[simp] theorem ForInStep.bind_done [Monad m] (a : α) (f : α → m (ForInStep α)) :
    (ForInStep.done a).bind (m := m) f = pure (.done a) 
goal: (ForInStep.done a).bind f = pure (ForInStep.done a)

full_name: ForInStep.bind_yield
code: @[simp] theorem ForInStep.bind_yield [Monad m] (a : α) (f : α → m (ForInStep α)) :
    (ForInStep.yield a).bind (m := m) f = f a 
goal: (ForInStep.yield a).bind f = f a

full_name: ForInStep.run_done
code: @[simp] theorem ForInStep.run_done : (ForInStep.done a).run = a 
goal: ∀ {α : Type u_1} {a : α}, (ForInStep.done a).run = a

full_name: ForInStep.run_yield
code: @[simp] theorem ForInStep.run_yield : (ForInStep.yield a).run = a 
goal: ∀ {α : Type u_1} {a : α}, (ForInStep.yield a).run = a

full_name: ForInStep.bindList_nil
code: @[simp] theorem ForInStep.bindList_nil [Monad m] (f : α → β → m (ForInStep β))
    (s : ForInStep β) : s.bindList f [] = pure s 
goal: ForInStep.bindList f [] s = pure s

full_name: ForInStep.bindList_cons
code: @[simp] theorem ForInStep.bindList_cons [Monad m]
    (f : α → β → m (ForInStep β)) (s : ForInStep β) (a l) :
    s.bindList f (a::l) = s.bind fun b => f a b >>= (·.bindList f l) 
goal: ForInStep.bindList f (a :: l) s =
  s.bind fun b => do
    let x ← f a b
    ForInStep.bindList f l x

full_name: ForInStep.done_bindList
code: @[simp] theorem ForInStep.done_bindList [Monad m]
    (f : α → β → m (ForInStep β)) (a l) :
    (ForInStep.done a).bindList f l = pure (.done a) 
goal: ForInStep.bindList f l (ForInStep.done a) = pure (ForInStep.done a)

full_name: ForInStep.bind_yield_bindList
code: @[simp] theorem ForInStep.bind_yield_bindList [Monad m]
    (f : α → β → m (ForInStep β)) (s : ForInStep β) (l) :
    (s.bind fun a => (yield a).bindList f l) = s.bindList f l 
goal: (s.bind fun a => ForInStep.bindList f l (ForInStep.yield a)) = ForInStep.bindList f l s

full_name: ForInStep.bind_bindList_assoc
code: @[simp] theorem ForInStep.bind_bindList_assoc [Monad m] [LawfulMonad m]
    (f : β → m (ForInStep β)) (g : α → β → m (ForInStep β)) (s : ForInStep β) (l) :
    s.bind f >>= (·.bindList g l) = s.bind fun b => f b >>= (·.bindList g l)  
goal: (do
    let x ← s.bind f
    ForInStep.bindList g l x) =
  s.bind fun b => do
    let x ← f b
    ForInStep.bindList g l x

full_name: ForInStep.bindList_cons'
code: theorem ForInStep.bindList_cons' [Monad m] [LawfulMonad m]
    (f : α → β → m (ForInStep β)) (s : ForInStep β) (a l) :
    s.bindList f (a::l) = s.bind (f a) >>= (·.bindList f l) 
goal: ForInStep.bindList f (a :: l) s = do
  let x ← s.bind (f a)
  ForInStep.bindList f l x

full_name: ForInStep.bindList_append
code: @[simp] theorem ForInStep.bindList_append [Monad m] [LawfulMonad m]
    (f : α → β → m (ForInStep β)) (s : ForInStep β) (l₁ l₂) :
    s.bindList f (l₁ ++ l₂) = s.bindList f l₁ >>= (·.bindList f l₂) 
goal: ForInStep.bindList f (l₁ ++ l₂) s = do
  let x ← ForInStep.bindList f l₁ s
  ForInStep.bindList f l₂ x
File: .lake/packages/aesop/Aesop/Util/Tactic/Ext.lean

full_name: Aesop.ExtResult.commonFVarIds
code: structure ExtResult where
  depth : Nat
  commonFVarIds : Array FVarId
  goals : Array (MVarId × Array FVarId)
goal: Array Lean.FVarId

full_name: Aesop.ExtResult
code: structure ExtResult where
  depth : Nat
  commonFVarIds : Array FVarId
  goals : Array (MVarId × Array FVarId)
goal: Type

full_name: Aesop.ExtResult.goals
code: structure ExtResult where
  depth : Nat
  commonFVarIds : Array FVarId
  goals : Array (MVarId × Array FVarId)
goal: Array (Lean.MVarId × Array Lean.FVarId)

full_name: Aesop.ExtResult.depth
code: structure ExtResult where
  depth : Nat
  commonFVarIds : Array FVarId
  goals : Array (MVarId × Array FVarId)
goal: Nat

full_name: Aesop.straightLineExt
code: partial def straightLineExt (goal : MVarId) : MetaM ExtResult 
goal: Lean.MetaM Aesop.ExtResult

full_name: Aesop.straightLineExt.go
code: partial def straightLineExt (goal : MVarId) : MetaM ExtResult 
goal: Lean.MetaM Aesop.ExtResult

full_name: Aesop.straightLineExtProgress
code: def straightLineExtProgress (goal : MVarId) : MetaM ExtResult 
goal: Lean.MetaM Aesop.ExtResult
File: .lake/packages/aesop/Aesop/Rule/Basic.lean

full_name: Aesop.instInhabitedRule
code: structure Rule (α : Type) where
  name : RuleName
  indexingMode : IndexingMode
  pattern? : Option RulePattern
  extra : α
  tac : RuleTacDescr
  deriving Inhabited
goal: {a : Type} → [inst : Inhabited a] → Inhabited (Aesop.Rule a)

full_name: Aesop.Rule
code: structure Rule (α : Type) where
  name : RuleName
  indexingMode : IndexingMode
  pattern? : Option RulePattern
  extra : α
  tac : RuleTacDescr
  deriving Inhabited
goal: Type

full_name: Aesop.Rule.name
code: structure Rule (α : Type) where
  name : RuleName
  indexingMode : IndexingMode
  pattern? : Option RulePattern
  extra : α
  tac : RuleTacDescr
  deriving Inhabited
goal: Aesop.RuleName

full_name: Aesop.Rule.pattern?
code: structure Rule (α : Type) where
  name : RuleName
  indexingMode : IndexingMode
  pattern? : Option RulePattern
  extra : α
  tac : RuleTacDescr
  deriving Inhabited
goal: Option Aesop.RulePattern

full_name: Aesop.Rule.extra
code: structure Rule (α : Type) where
  name : RuleName
  indexingMode : IndexingMode
  pattern? : Option RulePattern
  extra : α
  tac : RuleTacDescr
  deriving Inhabited
goal: α

full_name: Aesop.Rule.tac
code: structure Rule (α : Type) where
  name : RuleName
  indexingMode : IndexingMode
  pattern? : Option RulePattern
  extra : α
  tac : RuleTacDescr
  deriving Inhabited
goal: Aesop.RuleTacDescr

full_name: Aesop.Rule.indexingMode
code: structure Rule (α : Type) where
  name : RuleName
  indexingMode : IndexingMode
  pattern? : Option RulePattern
  extra : α
  tac : RuleTacDescr
  deriving Inhabited
goal: Aesop.IndexingMode

full_name: Aesop.Rule.instBEq
code: instance : BEq (Rule α) 
goal: BEq (Aesop.Rule α)

full_name: Aesop.Rule.instOrd
code: instance : Ord (Rule α) 
goal: Ord (Aesop.Rule α)

full_name: Aesop.Rule.instHashable
code: instance : Hashable (Rule α) 
goal: Hashable (Aesop.Rule α)

full_name: Aesop.Rule.compareByPriority
code: def compareByPriority [Ord α] (r s : Rule α) : Ordering 
goal: Ordering

full_name: Aesop.Rule.compareByName
code: def compareByName (r s : Rule α) : Ordering 
goal: Ordering

full_name: Aesop.Rule.compareByPriorityThenName
code: def compareByPriorityThenName [Ord α] (r s : Rule α) : Ordering 
goal: Ordering

full_name: Aesop.Rule.map
code: @[inline]
protected def map (f : α → β) (r : Rule α) : Rule β 
goal: Aesop.Rule β

full_name: Aesop.Rule.mapM
code: @[inline]
protected def mapM [Monad m] (f : α → m β) (r : Rule α) : m (Rule β) 
goal: m (Aesop.Rule β)
File: .lake/packages/aesop/Aesop/RuleSet/Filter.lean

full_name: Aesop.RuleFilter.scope
code: structure RuleFilter where
  name : Name
  scope : ScopeName
  /--
  `#[]` means 'match any builder'
  -/
  builders : Array BuilderName
  /--
  `#[]` means 'match any phase'
  -/
  phases : Array PhaseName
goal: Aesop.ScopeName

full_name: Aesop.RuleFilter.builders
code: structure RuleFilter where
  name : Name
  scope : ScopeName
  /--
  `#[]` means 'match any builder'
  -/
  builders : Array BuilderName
  /--
  `#[]` means 'match any phase'
  -/
  phases : Array PhaseName
goal: Array Aesop.BuilderName

full_name: Aesop.RuleFilter.phases
code: structure RuleFilter where
  name : Name
  scope : ScopeName
  /--
  `#[]` means 'match any builder'
  -/
  builders : Array BuilderName
  /--
  `#[]` means 'match any phase'
  -/
  phases : Array PhaseName
goal: Array Aesop.PhaseName

full_name: Aesop.RuleFilter.name
code: structure RuleFilter where
  name : Name
  scope : ScopeName
  /--
  `#[]` means 'match any builder'
  -/
  builders : Array BuilderName
  /--
  `#[]` means 'match any phase'
  -/
  phases : Array PhaseName
goal: Lean.Name

full_name: Aesop.RuleFilter
code: structure RuleFilter where
  name : Name
  scope : ScopeName
  /--
  `#[]` means 'match any builder'
  -/
  builders : Array BuilderName
  /--
  `#[]` means 'match any phase'
  -/
  phases : Array PhaseName
goal: Type

full_name: Aesop.RuleFilter.matchesPhase
code: def matchesPhase (f : RuleFilter) (p : PhaseName) : Bool 
goal: Bool

full_name: Aesop.RuleFilter.matchesBuilder
code: def matchesBuilder (f : RuleFilter) (b : BuilderName) : Bool 
goal: Bool

full_name: Aesop.RuleFilter.matches
code: def «matches» (f : RuleFilter) (n : RuleName) : Bool 
goal: Bool

full_name: Aesop.RuleFilter.matchesSimpTheorem?
code: def matchesSimpTheorem? (f : RuleFilter) : Option Name 
goal: Option Lean.Name

full_name: Aesop.RuleFilter.matchesLocalNormSimpRule?
code: /--
Returns the identifier of the local norm simp rule matched by `f`, if any.
-/
def matchesLocalNormSimpRule? (f : RuleFilter) : Option Name 
goal: Option Lean.Name

full_name: Aesop.RuleSetNameFilter.ns
code: structure RuleSetNameFilter where
  ns : Array RuleSetName
goal: Array Aesop.RuleSetName

full_name: Aesop.RuleSetNameFilter
code: structure RuleSetNameFilter where
  ns : Array RuleSetName
goal: Type

full_name: Aesop.RuleSetNameFilter.all
code: protected def all : RuleSetNameFilter 
goal: Aesop.RuleSetNameFilter

full_name: Aesop.RuleSetNameFilter.matchesAll
code: def matchesAll (f : RuleSetNameFilter) : Bool 
goal: Bool

full_name: Aesop.RuleSetNameFilter.matches
code: def «matches» (f : RuleSetNameFilter) (n : RuleSetName) : Bool 
goal: Bool

full_name: Aesop.RuleSetNameFilter.matchedRuleSetNames
code: def matchedRuleSetNames (f : RuleSetNameFilter) : Option (Array RuleSetName) 
goal: Option (Array Aesop.RuleSetName)
File: .lake/packages/aesop/Aesop/RuleSet/Name.lean

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

full_name: Aesop.defaultRuleSetName
code: def defaultRuleSetName : RuleSetName 
goal: Aesop.RuleSetName

full_name: Aesop.builtinRuleSetName
code: def builtinRuleSetName : RuleSetName 
goal: Aesop.RuleSetName

full_name: Aesop.localRuleSetName
code: def localRuleSetName : RuleSetName 
goal: Aesop.RuleSetName

full_name: Aesop.builtinRuleSetNames
code: def builtinRuleSetNames : Array RuleSetName 
goal: Array Aesop.RuleSetName

full_name: Aesop.RuleSetName.isReserved
code: def RuleSetName.isReserved (n : RuleSetName) : Bool 
goal: Bool
File: .lake/packages/batteries/Batteries/Classes/BEq.lean

full_name: PartialEquivBEq.symm
code: /-- `PartialEquivBEq α` says that the `BEq` implementation is a
partial equivalence relation, that is:
* it is symmetric: `a == b → b == a`
* it is transitive: `a == b → b == c → a == c`.
-/
class PartialEquivBEq (α) [BEq α] : Prop where
  /-- Symmetry for `BEq`. If `a == b` then `b == a`. -/
  symm : (a : α) == b → b == a
  /-- Transitivity for `BEq`. If `a == b` and `b == c` then `a == c`. -/
  trans : (a : α) == b → b == c → a == c
goal: (a == b) = true → (b == a) = true

full_name: PartialEquivBEq
code: /-- `PartialEquivBEq α` says that the `BEq` implementation is a
partial equivalence relation, that is:
* it is symmetric: `a == b → b == a`
* it is transitive: `a == b → b == c → a == c`.
-/
class PartialEquivBEq (α) [BEq α] : Prop where
  /-- Symmetry for `BEq`. If `a == b` then `b == a`. -/
  symm : (a : α) == b → b == a
  /-- Transitivity for `BEq`. If `a == b` and `b == c` then `a == c`. -/
  trans : (a : α) == b → b == c → a == c
goal: Prop

full_name: PartialEquivBEq.trans
code: /-- `PartialEquivBEq α` says that the `BEq` implementation is a
partial equivalence relation, that is:
* it is symmetric: `a == b → b == a`
* it is transitive: `a == b → b == c → a == c`.
-/
class PartialEquivBEq (α) [BEq α] : Prop where
  /-- Symmetry for `BEq`. If `a == b` then `b == a`. -/
  symm : (a : α) == b → b == a
  /-- Transitivity for `BEq`. If `a == b` and `b == c` then `a == c`. -/
  trans : (a : α) == b → b == c → a == c
goal: (a == b) = true → (b == c) = true → (a == c) = true