ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/batteries/Batteries/Data/String/Basic.lean

full_name: «instCoeStringSubstring_.lake»
code: instance : Coe String Substring 
goal: Coe String Substring

full_name: String.Pos.ne_zero_of_lt
code: protected theorem Pos.ne_zero_of_lt : {a b : Pos} → a < b → b ≠ 0
  
goal: a < b → b ≠ 0

full_name: Substring.commonPrefix
code: /--
Returns the longest common prefix of two substrings.
The returned substring will use the same underlying string as `s`.
-/
def commonPrefix (s t : Substring) : Substring 
goal: Substring

full_name: Substring.commonPrefix.loop
code: /--
Returns the longest common prefix of two substrings.
The returned substring will use the same underlying string as `s`.
-/
def commonPrefix (s t : Substring) : Substring 
goal: String.Pos

full_name: Substring.commonSuffix
code: /--
Returns the longest common suffix of two substrings.
The returned substring will use the same underlying string as `s`.
-/
def commonSuffix (s t : Substring) : Substring 
goal: Substring

full_name: Substring.commonSuffix.loop
code: /--
Returns the longest common suffix of two substrings.
The returned substring will use the same underlying string as `s`.
-/
def commonSuffix (s t : Substring) : Substring 
goal: String.Pos

full_name: Substring.dropPrefix?
code: /--
If `pre` is a prefix of `s`, i.e. `s = pre ++ t`, returns the remainder `t`.
-/
def dropPrefix? (s : Substring) (pre : Substring) : Option Substring 
goal: Option Substring

full_name: Substring.dropSuffix?
code: /--
If `suff` is a suffix of `s`, i.e. `s = t ++ suff`, returns the remainder `t`.
-/
def dropSuffix? (s : Substring) (suff : Substring) : Option Substring 
goal: Option Substring

full_name: String.dropPrefix?
code: /--
If `pre` is a prefix of `s`, i.e. `s = pre ++ t`, returns the remainder `t`.
-/
def dropPrefix? (s : String) (pre : Substring) : Option Substring 
goal: Option Substring

full_name: String.dropSuffix?
code: /--
If `suff` is a suffix of `s`, i.e. `s = t ++ suff`, returns the remainder `t`.
-/
def dropSuffix? (s : String) (suff : Substring) : Option Substring 
goal: Option Substring

full_name: String.stripPrefix
code: /-- `s.stripPrefix pre` will remove `pre` from the beginning of `s` if it occurs there,
or otherwise return `s`. -/
def stripPrefix (s : String) (pre : Substring) : String 
goal: String

full_name: String.stripSuffix
code: /-- `s.stripSuffix suff` will remove `suff` from the end of `s` if it occurs there,
or otherwise return `s`. -/
def stripSuffix (s : String) (suff : Substring) : String 
goal: String

full_name: String.count
code: /-- Count the occurrences of a character in a string. -/
def count (s : String) (c : Char) : Nat 
goal: Nat
File: .lake/packages/batteries/Batteries/Data/Char.lean

full_name: Char.ext
code: @[ext] theorem Char.ext : {a b : Char} → a.val = b.val → a = b
  
goal: a.val = b.val → a = b

full_name: Char.ext_iff
code: theorem Char.ext_iff {x y : Char} : x = y ↔ x.val = y.val 
goal: x = y ↔ x.val = y.val

full_name: Char.le_antisymm_iff
code: theorem Char.le_antisymm_iff {x y : Char} : x = y ↔ x ≤ y ∧ y ≤ x 
goal: x = y ↔ x ≤ y ∧ y ≤ x

full_name: Char.le_antisymm
code: theorem Char.le_antisymm {x y : Char} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
goal: x = y

full_name: «instLawfulOrdChar_.lake»
code: instance : Batteries.LawfulOrd Char 
goal: Batteries.LawfulOrd Char
File: .lake/packages/batteries/Batteries/Data/Array/Lemmas.lean

full_name: Array.forIn_eq_data_forIn.loop
code: theorem forIn_eq_data_forIn [Monad m]
    (as : Array α) (b : β) (f : α → β → m (ForInStep β)) :
    forIn as b f = forIn as.data b f 
goal: j + i = as.size → Array.forIn.loop as f i h b = forIn (List.drop j as.data) b f

full_name: Array.forIn_eq_data_forIn
code: theorem forIn_eq_data_forIn [Monad m]
    (as : Array α) (b : β) (f : α → β → m (ForInStep β)) :
    forIn as b f = forIn as.data b f 
goal: forIn as b f = forIn as.data b f

full_name: Array.zipWith_eq_zipWith_data.loop
code: theorem zipWith_eq_zipWith_data (f : α → β → γ) (as : Array α) (bs : Array β) :
    (as.zipWith bs f).data = as.data.zipWith f bs.data 
goal: i ≤ as.size →
  i ≤ bs.size →
    (Array.zipWithAux f as bs i cs).data = cs.data ++ List.zipWith f (List.drop i as.data) (List.drop i bs.data)

full_name: Array.zipWith_eq_zipWith_data
code: theorem zipWith_eq_zipWith_data (f : α → β → γ) (as : Array α) (bs : Array β) :
    (as.zipWith bs f).data = as.data.zipWith f bs.data 
goal: (as.zipWith bs f).data = List.zipWith f as.data bs.data

full_name: Array.size_zipWith
code: theorem size_zipWith (as : Array α) (bs : Array β) (f : α → β → γ) :
    (as.zipWith bs f).size = min as.size bs.size 
goal: (as.zipWith bs f).size = min as.size bs.size

full_name: Array.zip_eq_zip_data
code: theorem zip_eq_zip_data (as : Array α) (bs : Array β) :
    (as.zip bs).data = as.data.zip bs.data 
goal: (as.zip bs).data = as.data.zip bs.data

full_name: Array.size_zip
code: theorem size_zip (as : Array α) (bs : Array β) :
    (as.zip bs).size = min as.size bs.size 
goal: (as.zip bs).size = min as.size bs.size

full_name: Array.size_filter_le
code: theorem size_filter_le (p : α → Bool) (l : Array α) :
    (l.filter p).size ≤ l.size 
goal: (Array.filter p l 0).size ≤ l.size

full_name: Array.join_data
code: @[simp] theorem join_data {l : Array (Array α)} : l.join.data = (l.data.map data).join 
goal: l.join.data = (List.map Array.data l.data).join

full_name: Array.mem_join
code: theorem mem_join : ∀ {L : Array (Array α)}, a ∈ L.join ↔ ∃ l, l ∈ L ∧ a ∈ l 
goal: a ∈ L.join ↔ ∃ l, l ∈ L ∧ a ∈ l

full_name: Array.size_shrink_loop
code: theorem size_shrink_loop (a : Array α) (n) : (shrink.loop n a).size = a.size - n 
goal: (Array.shrink.loop n a).size = a.size - n

full_name: Array.size_shrink
code: theorem size_shrink (a : Array α) (n) : (a.shrink n).size = min a.size n 
goal: (a.shrink n).size = min a.size n

full_name: Array.mapM_empty
code: theorem mapM_empty [Monad m] (f : α → m β) : mapM f #[] = pure #[] 
goal: Array.mapM f #[] = pure #[]

full_name: Array.map_empty
code: @[simp] theorem map_empty (f : α → β) : map f #[] = #[] 
goal: Array.map f #[] = #[]

full_name: Array.mem_singleton
code: theorem mem_singleton : a ∈ #[b] ↔ a = b 
goal: ∀ {α : Type u_1} {a b : α}, a ∈ #[b] ↔ a = b
File: .lake/packages/proofwidgets/ProofWidgets/Component/Panel/GoalTypePanel.lean

full_name: ProofWidgets.GoalTypePanel
code: /-- Display the goal type using known `Expr` presenters. -/
@[widget_module]
def GoalTypePanel : Component PanelWidgetProps 
goal: ProofWidgets.Component ProofWidgets.PanelWidgetProps
File: .lake/packages/proofwidgets/ProofWidgets/Demos/Plot.lean

full_name: fn
code: def fn (t : Float) (x : Float): Float 
goal: Float

full_name: Plot
code: def Plot (fn : Float → Float) (steps := 100) : Html 
goal: ProofWidgets.Html

full_name: mkFrames
code: def mkFrames (fn : Float → Float → Float) (steps := 100) : Array Html
goal: Array ProofWidgets.Html

full_name: AnimatedHtmlProps
code: structure AnimatedHtmlProps where
  frames : Array Html
  framesPerSecond? : Option Nat := none
  deriving Server.RpcEncodable
goal: Type

full_name: AnimatedHtmlProps.frames
code: structure AnimatedHtmlProps where
  frames : Array Html
  framesPerSecond? : Option Nat := none
  deriving Server.RpcEncodable
goal: Array ProofWidgets.Html

full_name: AnimatedHtmlProps.framesPerSecond?
code: structure AnimatedHtmlProps where
  frames : Array Html
  framesPerSecond? : Option Nat := none
  deriving Server.RpcEncodable
goal: Option Nat

full_name: AnimatedHtmlProps.instRpcEncodable
code: Server.RpcEncodable
goal: Lean.Server.RpcEncodable AnimatedHtmlProps

full_name: AnimatedHtmlProps.instFromJsonRpcEncodablePacket
code: Server.RpcEncodable
goal: Lean.FromJson AnimatedHtmlProps.RpcEncodablePacket✝

full_name: AnimatedHtmlProps.instToJsonRpcEncodablePacket
code: Server.RpcEncodable
goal: Lean.ToJson AnimatedHtmlProps.RpcEncodablePacket✝

full_name: AnimatedHtmlProps.RpcEncodablePacket._@..lake.packages.proofwidgets.ProofWidgets.Demos.Plot._hyg.319
code: Server.RpcEncodable
goal: Type

full_name: AnimatedHtmlProps.instRpcEncodable.dec._@..lake.packages.proofwidgets.ProofWidgets.Demos.Plot._hyg.319
code: Server.RpcEncodable
goal: Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) AnimatedHtmlProps

full_name: AnimatedHtmlProps.instRpcEncodable.enc._@..lake.packages.proofwidgets.ProofWidgets.Demos.Plot._hyg.319
code: Server.RpcEncodable
goal: AnimatedHtmlProps → StateM Lean.Server.RpcObjectStore Lean.Json

full_name: AnimatedHtml
code: @[widget_module]
def AnimatedHtml : Component AnimatedHtmlProps 
goal: ProofWidgets.Component AnimatedHtmlProps
File: .lake/packages/proofwidgets/ProofWidgets/Demos/InteractiveSvg.lean

full_name: State
code: abbrev State 
goal: Type

full_name: isvg
code: def isvg : InteractiveSvg State 
goal: ProofWidgets.Svg.InteractiveSvg State

full_name: updateSvg
code: @[server_rpc_method]
def updateSvg (params : UpdateParams State) : RequestM (RequestTask (UpdateResult State)) 
goal: Lean.Server.RequestM (Lean.Server.RequestTask (ProofWidgets.Svg.UpdateResult State))

full_name: SvgWidget
code: @[widget_module]
def SvgWidget : Component (UpdateResult State) 
goal: ProofWidgets.Component (ProofWidgets.Svg.UpdateResult State)

full_name: init
code: def init : UpdateResult State 
goal: ProofWidgets.Svg.UpdateResult State
File: .lake/packages/proofwidgets/ProofWidgets/Demos/Venn.lean

full_name: Set
code: def Set (α : Type u) 
goal: Type u

full_name: Set.Mem
code: /-- Membership in a set -/
protected def Mem (a : α) (s : Set α) : Prop 
goal: Prop

full_name: Set.instMembership
code: instance : Membership α (Set α) 
goal: Membership α (Set α)

full_name: Set.ext
code: theorem ext {a b : Set α} (h : ∀ (x : α), x ∈ a ↔ x ∈ b) : a = b 
goal: a = b

full_name: Set.Subset
code: protected def Subset (s₁ s₂ : Set α) 
goal: Prop

full_name: Set.instLE
code: /-- Porting note: we introduce `≤` before `⊆` to help the unifier when applying lattice theorems
to subset hypotheses. -/
instance : LE (Set α) 
goal: LE (Set α)

full_name: Set.instHasSubset
code: instance : HasSubset (Set α) 
goal: HasSubset (Set α)

full_name: isSubsetPred?
code: /-- If `e == S ⊆ T` return `some (S, T)`, otherwise `none`. -/
def isSubsetPred? (e : Expr) : Option (Expr × Expr) 
goal: Option (Lean.Expr × Lean.Expr)

full_name: ExprEmbeds
code: /-- Expressions to display as labels in a diagram. -/
abbrev ExprEmbeds 
goal: Type

full_name: mkSetDiag
code: def mkSetDiag (sub : String) (embeds : ExprEmbeds) : MetaM Html 
goal: Lean.MetaM ProofWidgets.Html

full_name: isSetGoal?
code: def isSetGoal? (hyps : Array LocalDecl) : MetaM (Option Html) 
goal: Lean.MetaM (Option ProofWidgets.Html)

full_name: findGoalForLocation
code: def findGoalForLocation (goals : Array Widget.InteractiveGoal) (loc : SubExpr.GoalsLocation) :
    Option Widget.InteractiveGoal 
goal: Option Lean.Widget.InteractiveGoal

full_name: VennDisplay.rpc
code: @[server_rpc_method]
def VennDisplay.rpc (props : PanelWidgetProps) : RequestM (RequestTask Html) 
goal: Lean.Server.RequestM (Lean.Server.RequestTask ProofWidgets.Html)

full_name: VennDisplay
code: @[widget_module]
def VennDisplay : Component PanelWidgetProps 
goal: ProofWidgets.Component ProofWidgets.PanelWidgetProps
File: .lake/packages/proofwidgets/ProofWidgets/Demos/ExprPresentation.lean

full_name: presenter
code: @[expr_presenter]
def presenter : ExprPresenter 
goal: ProofWidgets.ExprPresenter
File: .lake/packages/proofwidgets/ProofWidgets/Demos/Dynkin.lean

full_name: List.product
code: def List.product : List α → List β → List (α × β)
  
goal: List α → List β → List (α × β)

full_name: Matrix
code: def Matrix (n m α : Type) 
goal: Type

full_name: Matrix.nat_index
code: def nat_index (i j : Nat) : Int 
goal: Int

full_name: Matrix.get_node_pos_E
code: /-- TODO Delete me once `get_node_pos` smart enough to infer layout from values in `A`. -/
def get_node_pos_E : Nat → Nat × Nat
  
goal: Nat → Nat × Nat

full_name: Matrix.get_node_pos
code: /-- TODO Use `A` to infer sensible layout. -/
def get_node_pos (n : Nat) : Nat → Nat × Nat 
goal: Nat → Nat × Nat

full_name: Matrix.get_node_cx
code: def get_node_cx (n i : Nat) : Int 
goal: Int

full_name: Matrix.get_node_cy
code: def get_node_cy (n i : Nat) : Int 
goal: Int

full_name: Matrix.get_node_html
code: def get_node_html (n i : Nat) : Html 
goal: ProofWidgets.Html

full_name: Matrix.get_edge_html
code: /-- TODO
 * Error if `j ≤ i`
 * Error if `(A i j, A j i) ∉ [((0 : Int), (0 : Int)), (-1, -1), (-1, -2), (-2, -1), (-1, -3), (-3, -1)]`
 * Render `(A i j) * (A j i)` edges
 * Render arrow on double or triple edge with direction decided by `A i j < A j i` -/
def get_edge_html : Nat × Nat → List Html
  
goal: Nat × Nat → List ProofWidgets.Html

full_name: Matrix.get_nodes_html
code: def get_nodes_html (n : Nat) : List Html 
goal: List ProofWidgets.Html

full_name: Matrix.get_edges_html
code: def get_edges_html : List Html 
goal: List ProofWidgets.Html

full_name: Matrix.toHtml
code: def toHtml (M : Matrix (Fin n) (Fin n) Int) : Html 
goal: ProofWidgets.Html

full_name: cartanMatrix.E₈
code: def cartanMatrix.E₈ : Matrix (Fin 8) (Fin 8) Int 
goal: Matrix (Fin 8) (Fin 8) Int
File: .lake/packages/proofwidgets/ProofWidgets/Demos/Jsx.lean

full_name: htmlLetters
code: def htmlLetters : Array ProofWidgets.Html 
goal: Array ProofWidgets.Html

full_name: x
code: def x 
goal: ProofWidgets.Html
File: .lake/packages/proofwidgets/ProofWidgets/Demos/Macro.lean

full_name: Lean.SourceInfo.mkCanonical
code: def Lean.SourceInfo.mkCanonical : SourceInfo → SourceInfo
  
goal: Lean.SourceInfo → Lean.SourceInfo

full_name: Lean.Syntax.mkInfoCanonical
code: def Lean.Syntax.mkInfoCanonical : Syntax → Syntax
  
goal: Lean.Syntax → Lean.Syntax

full_name: Lean.TSyntax.mkInfoCanonical
code: def Lean.TSyntax.mkInfoCanonical : TSyntax k → TSyntax k 
goal: Lean.TSyntax k → Lean.TSyntax k

full_name: «command#browse_»
code: macro "#browse " src:term : command =>
  Lean.TSyntax.mkInfoCanonical <$>
    `(#html <iframe src={$src} width="100%" height="600px" />)
goal: Lean.ParserDescr

full_name: «_aux_.lake_packages_proofwidgets_ProofWidgets_Demos_Macro___macroRules_command#browse__1»
code: macro "#browse " src:term : command =>
  Lean.TSyntax.mkInfoCanonical <$>
    `(#html <iframe src={$src} width="100%" height="600px" />)
goal: Lean.Macro
File: .lake/packages/proofwidgets/ProofWidgets/Compat.lean

full_name: ProofWidgets.LazyEncodable
code: abbrev LazyEncodable α 
goal: Type

full_name: ProofWidgets.ExprWithCtx.linsts
code: structure ExprWithCtx where
  ci : Elab.ContextInfo
  lctx : LocalContext
  linsts : LocalInstances
  expr : Expr
  deriving TypeName
goal: Lean.LocalInstances

full_name: ProofWidgets.ExprWithCtx
code: structure ExprWithCtx where
  ci : Elab.ContextInfo
  lctx : LocalContext
  linsts : LocalInstances
  expr : Expr
  deriving TypeName
goal: Type

full_name: ProofWidgets.ExprWithCtx.lctx
code: structure ExprWithCtx where
  ci : Elab.ContextInfo
  lctx : LocalContext
  linsts : LocalInstances
  expr : Expr
  deriving TypeName
goal: Lean.LocalContext

full_name: ProofWidgets.ExprWithCtx.ci
code: structure ExprWithCtx where
  ci : Elab.ContextInfo
  lctx : LocalContext
  linsts : LocalInstances
  expr : Expr
  deriving TypeName
goal: Lean.Elab.ContextInfo

full_name: ProofWidgets.ExprWithCtx.expr
code: structure ExprWithCtx where
  ci : Elab.ContextInfo
  lctx : LocalContext
  linsts : LocalInstances
  expr : Expr
  deriving TypeName
goal: Lean.Expr

full_name: ProofWidgets.instImpl._@..lake.packages.proofwidgets.ProofWidgets.Compat._hyg.47
code: TypeName
goal: TypeName ProofWidgets.ExprWithCtx

full_name: ProofWidgets.instTypeNameExprWithCtx
code: TypeName
goal: TypeName ProofWidgets.ExprWithCtx

full_name: ProofWidgets.inst._@..lake.packages.proofwidgets.ProofWidgets.Compat._hyg.47
code: TypeName
goal: TypeName ProofWidgets.ExprWithCtx

full_name: ProofWidgets.ExprWithCtx.runMetaM
code: def ExprWithCtx.runMetaM (e : ExprWithCtx) (x : Expr → MetaM α) : IO α 
goal: IO α

full_name: ProofWidgets.ExprWithCtx.save
code: def ExprWithCtx.save (e : Expr) : MetaM ExprWithCtx 
goal: Lean.MetaM ProofWidgets.ExprWithCtx
File: .lake/packages/proofwidgets/ProofWidgets/Demos/Rubiks.lean

full_name: RubiksProps.seq
code: structure RubiksProps where
  seq : Array String := #[]
  deriving ToJson, FromJson, Inhabited
goal: Array String

full_name: RubiksProps
code: structure RubiksProps where
  seq : Array String := #[]
  deriving ToJson, FromJson, Inhabited
goal: Type

full_name: instInhabitedRubiksProps
code: structure RubiksProps where
  seq : Array String := #[]
  deriving ToJson, FromJson, Inhabited
goal: Inhabited RubiksProps

full_name: instToJsonRubiksProps
code: ToJson
goal: Lean.ToJson RubiksProps

full_name: instFromJsonRubiksProps
code: FromJson
goal: Lean.FromJson RubiksProps

full_name: Rubiks
code: @[widget_module]
def Rubiks : Component RubiksProps 
goal: ProofWidgets.Component RubiksProps

full_name: eg
code: def eg 
goal: Array String
File: .lake/packages/proofwidgets/ProofWidgets/Util.lean

full_name: ProofWidgets.Util.joinArrays
code: /-- Sends `#[a, b, c]` to `` `(term| $a ++ $b ++ $c)``-/
def joinArrays {m} [Monad m] [MonadRef m] [MonadQuotation m] (arr : Array Term) : m Term 
goal: m Lean.Term

full_name: ProofWidgets.Util.foldInlsM
code: /-- Collapse adjacent `inl (_ : α)`s into a `β` using `f`.
For example, `#[.inl a₁, .inl a₂, .inr b, .inl a₃] ↦ #[← f #[a₁, a₂], b, ← f #[a₃]]`. -/
def foldInlsM {m} [Monad m] (arr : Array (α ⊕ β)) (f : Array α → m β) : m (Array β) 
goal: m (Array β)

full_name: Lean.PrettyPrinter.Delaborator.delabListLiteral
code: /-- Delaborate the elements of a list literal separately, calling `elem` on each. -/
partial def delabListLiteral {α} (elem : DelabM α) : DelabM (Array α) 
goal: Lean.PrettyPrinter.Delaborator.DelabM (Array α)

full_name: Lean.PrettyPrinter.Delaborator.delabListLiteral.go
code: /-- Delaborate the elements of a list literal separately, calling `elem` on each. -/
partial def delabListLiteral {α} (elem : DelabM α) : DelabM (Array α) 
goal: Lean.PrettyPrinter.Delaborator.DelabM (Array α)

full_name: Lean.PrettyPrinter.Delaborator.delabArrayLiteral
code: /-- Delaborate the elements of an array literal separately, calling `elem` on each. -/
partial def delabArrayLiteral {α} (elem : DelabM α) : DelabM (Array α) 
goal: Lean.PrettyPrinter.Delaborator.DelabM (Array α)

full_name: Lean.PrettyPrinter.Delaborator.annotateTermLikeInfo
code: /-- A copy of `Delaborator.annotateTermInfo` for other syntactic categories. -/
def annotateTermLikeInfo (stx : TSyntax n) : DelabM (TSyntax n) 
goal: Lean.PrettyPrinter.Delaborator.DelabM (Lean.TSyntax n)

full_name: Lean.PrettyPrinter.Delaborator.withAnnotateTermLikeInfo
code: /-- A copy of `Delaborator.withAnnotateTermInfo` for other syntactic categories. -/
def withAnnotateTermLikeInfo (d : DelabM (TSyntax n)) : DelabM (TSyntax n) 
goal: Lean.PrettyPrinter.Delaborator.DelabM (Lean.TSyntax n)
File: .lake/packages/proofwidgets/ProofWidgets/Demos/Svg.lean

full_name: _private.«.lake».packages.proofwidgets.ProofWidgets.Demos.Svg.0.frame
code: private def frame : Frame 
goal: ProofWidgets.Svg.Frame

full_name: _private.«.lake».packages.proofwidgets.ProofWidgets.Demos.Svg.0.svg
code: private def svg : Svg frame 
goal: ProofWidgets.Svg frame
File: .lake/packages/importGraph/ImportGraph/RequiredModules.lean

full_name: Lean.Environment.getModuleFor?
code: /-- Return the name of the module in which a declaration was defined. -/
def Environment.getModuleFor? (env : Environment) (declName : Name) : Option Name 
goal: Option Lean.Name

full_name: Lean.Name.requiredModules
code: /--
Return the names of the modules in which constants used in the specified declaration were defined.

Note that this will *not* account for tactics and syntax used in the declaration,
so the results may not suffice as imports.
-/
def Name.requiredModules (n : Name) : CoreM NameSet 
goal: Lean.CoreM Lean.NameSet

full_name: Lean.Environment.requiredModules
code: /--
Return the names of the modules in which constants used in the current file were defined.

Note that this will *not* account for tactics and syntax used in the file,
so the results may not suffice as imports.
-/
def Environment.requiredModules (env : Environment) : NameSet 
goal: Lean.NameSet
File: .lake/packages/Qq/Qq/SortLocalDecls.lean

full_name: Qq.SortLocalDecls.Context.localDecls
code: structure Context where
  localDecls : NameMap LocalDecl := {}
goal: Lean.NameMap Lean.LocalDecl

full_name: Qq.SortLocalDecls.Context
code: structure Context where
  localDecls : NameMap LocalDecl := {}
goal: Type

full_name: Qq.SortLocalDecls.State
code: structure State where
  visited : NameSet := {}
  result  : Array LocalDecl := #[]
goal: Type

full_name: Qq.SortLocalDecls.State.visited
code: structure State where
  visited : NameSet := {}
  result  : Array LocalDecl := #[]
goal: Lean.NameSet

full_name: Qq.SortLocalDecls.State.result
code: structure State where
  visited : NameSet := {}
  result  : Array LocalDecl := #[]
goal: Array Lean.LocalDecl

full_name: Qq.SortLocalDecls.M
code: abbrev M 
goal: Type

full_name: Qq.sortLocalDecls
code: def sortLocalDecls (localDecls : Array LocalDecl) : MetaM (Array LocalDecl) 
goal: Lean.MetaM (Array Lean.LocalDecl)
File: .lake/packages/Qq/Qq/ForLean/Do.lean

full_name: Lean.Elab.Term.mkIdBindFor
code: def mkIdBindFor (type : Expr) : TermElabM ExtractMonadResult 
goal: Lean.Elab.TermElabM Lean.Elab.Term.ExtractMonadResult

full_name: Lean.Elab.Term.extractBind.extract?
code: partial def extractBind (expectedType? : Option Expr) : TermElabM ExtractMonadResult 
goal: Lean.MetaM (Option Lean.Elab.Term.ExtractMonadResult)

full_name: Lean.Elab.Term.extractBind
code: partial def extractBind (expectedType? : Option Expr) : TermElabM ExtractMonadResult 
goal: Lean.Elab.TermElabM Lean.Elab.Term.ExtractMonadResult
File: .lake/packages/Qq/Qq/ForLean/ToExpr.lean

full_name: «instToExprInt_.lake»
code: instance : ToExpr Int 
goal: Lean.ToExpr Int

full_name: «instToExprMVarId_.lake»
code: instance : ToExpr MVarId 
goal: Lean.ToExpr Lean.MVarId

full_name: «instToExprLevelMVarId_.lake»
code: instance : ToExpr LevelMVarId 
goal: Lean.ToExpr Lean.LevelMVarId

full_name: «instToExprFVarId_.lake»
code: instance : ToExpr FVarId 
goal: Lean.ToExpr Lean.FVarId

full_name: _private.«.lake».packages.Qq.Qq.ForLean.ToExpr.0.toExprLevel
code: private def toExprLevel : Level → Expr
  
goal: Lean.Level → Lean.Expr

full_name: «instToExprLevel_.lake»
code: instance : ToExpr Level 
goal: Lean.ToExpr Lean.Level

full_name: «instToExprLiteral_.lake»
code: instance : ToExpr Literal 
goal: Lean.ToExpr Lean.Literal

full_name: «instToExprBinderInfo_.lake»
code: instance : ToExpr BinderInfo 
goal: Lean.ToExpr Lean.BinderInfo

full_name: «instToExprMData_.lake»
code: instance : ToExpr MData 
goal: Lean.ToExpr Lean.MData

full_name: _private.«.lake».packages.Qq.Qq.ForLean.ToExpr.0.toExprExpr
code: private def toExprExpr : Expr → Expr
  
goal: Lean.Expr → Lean.Expr

full_name: «instToExprExpr_.lake»
code: instance : ToExpr Expr 
goal: Lean.ToExpr Lean.Expr