File: .lake/packages/aesop/Aesop/Util/Basic.lean

full_name: Aesop.Array.size_modify
code: theorem size_modify (a : Array α) (i : Nat) (f : α → α) :
    (a.modify i f).size = a.size 
goal: (a.modify i f).size = a.size

full_name: Aesop.time
code: @[inline]
def time [Monad m] [MonadLiftT BaseIO m] (x : m α) : m (α × Aesop.Nanos) 
goal: m (α × Aesop.Nanos)

full_name: Aesop.time'
code: @[inline]
def time' [Monad m] [MonadLiftT BaseIO m] (x : m Unit) : m Aesop.Nanos 
goal: m Aesop.Nanos

full_name: Aesop.HashSet.filter
code: def filter [BEq α] [Hashable α] (hs : HashSet α) (p : α → Bool) : HashSet α 
goal: Lean.HashSet α

full_name: Aesop.PersistentHashSet.toList
code: @[inline]
def toList [BEq α] [Hashable α] (s : PersistentHashSet α) :
    List α 
goal: List α

full_name: Aesop.PersistentHashSet.toArray
code: @[inline]
def toArray [BEq α] [Hashable α] (s : PersistentHashSet α) :
    Array α 
goal: Array α

full_name: Aesop.getConclusionDiscrTreeKeys
code: def getConclusionDiscrTreeKeys (type : Expr) (config : WhnfCoreConfig) :
    MetaM (Array Key) 
goal: Lean.MetaM (Array Lean.Meta.DiscrTree.Key)

full_name: Aesop.getConstDiscrTreeKeys
code: def getConstDiscrTreeKeys (decl : Name) : MetaM (Array Key) 
goal: Lean.MetaM (Array Lean.Meta.DiscrTree.Key)

full_name: Aesop.isEmptyTrie
code: def isEmptyTrie : Trie α → Bool
  
goal: Lean.Meta.DiscrTree.Trie α → Bool

full_name: _private.«.lake».packages.aesop.Aesop.Util.Basic.0.Aesop.filterTrieM
code: @[specialize]
private partial def filterTrieM [Monad m] [Inhabited σ] (f : σ → α → m σ)
    (p : α → m (ULift Bool)) (init : σ) : Trie α → m (Trie α × σ)
  
goal: Lean.Meta.DiscrTree.Trie α → m (Lean.Meta.DiscrTree.Trie α × σ)

full_name: _private.«.lake».packages.aesop.Aesop.Util.Basic.0.Aesop.filterTrieM.go
code: @[specialize]
private partial def filterTrieM [Monad m] [Inhabited σ] (f : σ → α → m σ)
    (p : α → m (ULift Bool)) (init : σ) : Trie α → m (Trie α × σ)
  
goal: m (Array (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) × σ)

full_name: Aesop.filterDiscrTreeM
code: /--
Remove elements for which `p` returns `false` from the given `DiscrTree`.
The removed elements are monadically folded over using `f` and `init`, so `f`
is called once for each removed element and the final state of type `σ` is
returned.
-/
@[specialize]
def filterDiscrTreeM [Monad m] [Inhabited σ] (p : α → m (ULift Bool))
    (f : σ → α → m σ) (init : σ) (t : DiscrTree α) :
    m (DiscrTree α × σ) 
goal: m (Lean.Meta.DiscrTree α × σ)

full_name: Aesop.filterDiscrTree
code: /--
Remove elements for which `p` returns `false` from the given `DiscrTree`.
The removed elements are folded over using `f` and `init`, so `f` is called
once for each removed element and the final state of type `σ` is returned.
-/
def filterDiscrTree [Inhabited σ] (p : α → Bool) (f : σ → α → σ) (init : σ)
    (t : DiscrTree α) : DiscrTree α × σ 
goal: Lean.Meta.DiscrTree α × σ

full_name: Aesop.SimpTheorems.addSimpEntry
code: def addSimpEntry (s : SimpTheorems) : SimpEntry → SimpTheorems
  
goal: Lean.Meta.SimpEntry → Lean.Meta.SimpTheorems

full_name: Aesop.SimpTheorems.foldSimpEntriesM
code: def foldSimpEntriesM [Monad m] (f : σ → SimpEntry → m σ) (init : σ)
    (thms : SimpTheorems) : m σ 
goal: m σ

full_name: Aesop.SimpTheorems.foldSimpEntriesM.processTheorem
code: def foldSimpEntriesM [Monad m] (f : σ → SimpEntry → m σ) (init : σ)
    (thms : SimpTheorems) : m σ 
goal: m σ

full_name: Aesop.SimpTheorems.foldSimpEntries
code: def foldSimpEntries (f : σ → SimpEntry → σ) (init : σ) (thms : SimpTheorems) :
    σ 
goal: σ

full_name: Aesop.SimpTheorems.simpEntries
code: def simpEntries (thms : SimpTheorems) : Array SimpEntry 
goal: Array Lean.Meta.SimpEntry

full_name: Aesop.SimpTheorems.containsDecl
code: def containsDecl (thms : SimpTheorems) (decl : Name) : Bool 
goal: Bool

full_name: Aesop.setThe
code: @[inline]
def setThe (σ) {m} [MonadStateOf σ m] (s : σ) : m PUnit 
goal: m PUnit

full_name: Aesop.runMetaMAsCoreM
code: @[inline]
def runMetaMAsCoreM (x : MetaM α) : CoreM α 
goal: Lean.CoreM α

full_name: Aesop.runTermElabMAsCoreM
code: @[inline]
def runTermElabMAsCoreM (x : Elab.TermElabM α) : CoreM α 
goal: Lean.CoreM α

full_name: Aesop.runTacticMAsMetaM
code: def runTacticMAsMetaM (x : TacticM α) (goals : List MVarId) :
    MetaM (α × List MVarId) 
goal: Lean.MetaM (α × List Lean.MVarId)

full_name: Aesop.runTacticSyntaxAsMetaM
code: def runTacticSyntaxAsMetaM (stx : Syntax) (goals : List MVarId) :
    MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Aesop.updateSimpEntryPriority
code: def updateSimpEntryPriority (priority : Nat) (e : SimpEntry) : SimpEntry 
goal: Lean.Meta.SimpEntry

full_name: Aesop.getMVarDependencies
code: def getMVarDependencies (e : Expr) : MetaM (HashSet MVarId) 
goal: Lean.MetaM (Lean.HashSet Lean.MVarId)

full_name: Aesop.hasSorry
code: partial def hasSorry [Monad m] [MonadMCtx m] (e : Expr) : m Bool 
goal: m Bool

full_name: Aesop.hasSorry.go
code: partial def hasSorry [Monad m] [MonadMCtx m] (e : Expr) : m Bool 
goal: Bool

full_name: Aesop.isAppOfUpToDefeq
code: def isAppOfUpToDefeq (f : Expr) (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Aesop.getAppUpToDefeq.go
code: /--
If the input expression `e` reduces to `f x₁ ... xₙ` via repeated `whnf`, this
function returns `f` and `[x₁, ⋯, xₙ]`. Otherwise it returns `e` (unchanged, not
in WHNF!) and `[]`.
-/
partial def getAppUpToDefeq (e : Expr) : MetaM (Expr × Array Expr) 
goal: Lean.MetaM (Lean.Expr × Array Lean.Expr)

full_name: Aesop.getAppUpToDefeq
code: /--
If the input expression `e` reduces to `f x₁ ... xₙ` via repeated `whnf`, this
function returns `f` and `[x₁, ⋯, xₙ]`. Otherwise it returns `e` (unchanged, not
in WHNF!) and `[]`.
-/
partial def getAppUpToDefeq (e : Expr) : MetaM (Expr × Array Expr) 
goal: Lean.MetaM (Lean.Expr × Array Lean.Expr)

full_name: Aesop.partitionGoalsAndMVars
code: /--
Partition an array of `MVarId`s into 'goals' and 'proper mvars'. An `MVarId`
from the input array `ms` is classified as a proper mvar if any of the `ms`
depend on it, and as a goal otherwise. Additionally, for each goal, we report
the set of mvars that the goal depends on.
-/
def partitionGoalsAndMVars (goals : Array MVarId) :
    MetaM (Array (MVarId × UnorderedArraySet MVarId) × UnorderedArraySet MVarId) 
goal: Lean.MetaM (Array (Lean.MVarId × Aesop.UnorderedArraySet Lean.MVarId) × Aesop.UnorderedArraySet Lean.MVarId)

full_name: Aesop.runTacticMCapturingPostState
code: def runTacticMCapturingPostState (t : TacticM Unit) (preState : Meta.SavedState)
    (preGoals : List MVarId) : MetaM (Meta.SavedState × List MVarId) 
goal: Lean.MetaM (Lean.Meta.SavedState × List Lean.MVarId)

full_name: Aesop.runTacticCapturingPostState
code: def runTacticCapturingPostState (t : Syntax.Tactic) (preState : Meta.SavedState)
    (preGoals : List MVarId) : MetaM (Meta.SavedState × List MVarId) 
goal: Lean.MetaM (Lean.Meta.SavedState × List Lean.MVarId)

full_name: Aesop.runTacticSeqCapturingPostState
code: def runTacticSeqCapturingPostState (t : TSyntax ``Lean.Parser.Tactic.tacticSeq)
    (preState : Meta.SavedState) (preGoals : List MVarId) :
    MetaM (Meta.SavedState × List MVarId) 
goal: Lean.MetaM (Lean.Meta.SavedState × List Lean.MVarId)

full_name: Aesop.runTacticsCapturingPostState
code: def runTacticsCapturingPostState (ts : Array Syntax.Tactic)
    (preState : Meta.SavedState) (preGoals : List MVarId) :
    MetaM (Meta.SavedState × List MVarId) 
goal: Lean.MetaM (Lean.Meta.SavedState × List Lean.MVarId)

full_name: Aesop.withTransparencySeqSyntax
code: def withTransparencySeqSyntax (md : TransparencyMode)
    (k : TSyntax ``tacticSeq) : TSyntax ``tacticSeq 
goal: Lean.TSyntax `Lean.Parser.Tactic.tacticSeq

full_name: Aesop.withAllTransparencySeqSyntax
code: def withAllTransparencySeqSyntax (md : TransparencyMode)
    (k : TSyntax ``tacticSeq) : TSyntax ``tacticSeq 
goal: Lean.TSyntax `Lean.Parser.Tactic.tacticSeq

full_name: Aesop.withTransparencySyntax
code: def withTransparencySyntax (md : TransparencyMode) (k : TSyntax `tactic) :
    TSyntax `tactic 
goal: Lean.TSyntax `tactic

full_name: Aesop.withAllTransparencySyntax
code: def withAllTransparencySyntax (md : TransparencyMode) (k : TSyntax `tactic) :
    TSyntax `tactic 
goal: Lean.TSyntax `tactic

full_name: Aesop.addTryThisTacticSeqSuggestion
code: /--
Register a "Try this" suggestion for a tactic sequence.

It works when the tactic to replace appears on its own line:

```lean
by
  aesop?
```

It doesn't work (i.e., the suggestion will appear but in the wrong place) when
the tactic to replace is preceded by other text on the same line:

```lean
have x := by aesop?
```

The `Try this:` suggestion in the infoview is not correctly formatted, but
there's nothing we can do about this at the moment.
-/
def addTryThisTacticSeqSuggestion (ref : Syntax)
    (suggestion : TSyntax ``Lean.Parser.Tactic.tacticSeq)
    (origSpan? : Option Syntax := none) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Aesop.addTryThisTacticSeqSuggestion.dedent
code: /--
Register a "Try this" suggestion for a tactic sequence.

It works when the tactic to replace appears on its own line:

```lean
by
  aesop?
```

It doesn't work (i.e., the suggestion will appear but in the wrong place) when
the tactic to replace is preceded by other text on the same line:

```lean
have x := by aesop?
```

The `Try this:` suggestion in the infoview is not correctly formatted, but
there's nothing we can do about this at the moment.
-/
def addTryThisTacticSeqSuggestion (ref : Syntax)
    (suggestion : TSyntax ``Lean.Parser.Tactic.tacticSeq)
    (origSpan? : Option Syntax := none) : MetaM Unit 
goal: String

full_name: Aesop.withMaxHeartbeats
code: /--
Runs a computation for at most the given number of heartbeats times 1000,
ignoring the global heartbeat limit. Note that heartbeats spent on the
computation still count towards the global heartbeat count.
-/
def withMaxHeartbeats [Monad m] [MonadLiftT BaseIO m]
    [MonadWithReaderOf Core.Context m] (n : Nat) (x : m α) : m α 
goal: m α

full_name: Aesop.elabPattern
code: def elabPattern (stx : Syntax) : TermElabM Expr 
goal: Lean.Elab.TermElabM Lean.Expr

full_name: Aesop.elabPattern.adjustCtx
code: def elabPattern (stx : Syntax) : TermElabM Expr 
goal: Lean.Elab.Term.Context

full_name: Aesop.initFn._@..lake.packages.aesop.Aesop.Util.Basic._hyg.3590
code: register_option aesop.smallErrorMessages : Bool := {
    defValue := false
    group := "aesop"
    descr := "(aesop) Print smaller error messages. Used for testing."
  }
goal: IO (Lean.Option Bool)

full_name: Aesop.aesop.smallErrorMessages
code: register_option aesop.smallErrorMessages : Bool := {
    defValue := false
    group := "aesop"
    descr := "(aesop) Print smaller error messages. Used for testing."
  }
goal: Lean.Option Bool

full_name: Aesop.tacticsToMessageData
code: def tacticsToMessageData (ts : Array Syntax.Tactic) : MessageData 
goal: Lean.MessageData

full_name: Aesop.getUnusedNames.go
code: /--
Note: the returned local context contains invalid `LocalDecl`s.
-/
def getUnusedNames (lctx : LocalContext) (suggestions : Array Name) : Array Name × LocalContext 
goal: Array Lean.Name × Lean.LocalContext

full_name: Aesop.getUnusedNames
code: /--
Note: the returned local context contains invalid `LocalDecl`s.
-/
def getUnusedNames (lctx : LocalContext) (suggestions : Array Name) : Array Name × LocalContext 
goal: Array Lean.Name × Lean.LocalContext

full_name: Aesop.getUnusedNames.dummyLDecl
code: /--
Note: the returned local context contains invalid `LocalDecl`s.
-/
def getUnusedNames (lctx : LocalContext) (suggestions : Array Name) : Array Name × LocalContext 
goal: Lean.LocalDecl

full_name: Aesop.Name.ofComponents
code: def Name.ofComponents (cs : List Name) : Name 
goal: Lean.Name

full_name: Aesop.withExceptionTransform
code: @[macro_inline]
def withExceptionTransform [Monad m] [MonadError m]
    (f : MessageData → MessageData) (x : m α) : m α 
goal: m α

full_name: Aesop.withExceptionPrefix
code: @[macro_inline]
def withExceptionPrefix [Monad m] [MonadError m] (pre : MessageData) :
    m α → m α 
goal: m α → m α