ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/Qq/Qq/Delab.lean

full_name: Qq.Impl.initFn._@..lake.packages.Qq.Qq.Delab._hyg.9
code: register_option pp.qq : Bool := {
  defValue := true
  group    := "pp"
  descr    := "(pretty printer) print quotations as q(...) and Q(...)"
}
goal: IO (Lean.Option Bool)

full_name: Qq.Impl.pp.qq
code: register_option pp.qq : Bool := {
  defValue := true
  group    := "pp"
  descr    := "(pretty printer) print quotations as q(...) and Q(...)"
}
goal: Lean.Option Bool

full_name: _private.«.lake».packages.Qq.Qq.Delab.0.Qq.Impl.failureOnError
code: private def failureOnError (x : MetaM α) : DelabM α 
goal: Lean.PrettyPrinter.Delaborator.DelabM α

full_name: _private.«.lake».packages.Qq.Qq.Delab.0.Qq.Impl.unquote
code: private def unquote (e : Expr) : UnquoteM (Expr × LocalContext) 
goal: Qq.Impl.UnquoteM (Lean.Expr × Lean.LocalContext)

full_name: Qq.Impl.checkQqDelabOptions
code: def checkQqDelabOptions : DelabM Unit 
goal: Lean.PrettyPrinter.Delaborator.DelabM Unit

full_name: Qq.Impl.«instMonadLiftUnquoteMStateTUnquoteStateDelabM_.lake»
code: instance : MonadLift UnquoteM (StateT UnquoteState DelabM) 
goal: MonadLift Qq.Impl.UnquoteM (StateT Qq.Impl.UnquoteState Lean.PrettyPrinter.Delaborator.DelabM)

full_name: Qq.Impl.delabQuoted
code: def delabQuoted : StateT UnquoteState DelabM Term 
goal: StateT Qq.Impl.UnquoteState Lean.PrettyPrinter.Delaborator.DelabM Lean.Term

full_name: Qq.Impl.withDelabQuoted
code: def withDelabQuoted (k : StateT UnquoteState DelabM Term) : Delab 
goal: Lean.PrettyPrinter.Delaborator.Delab

full_name: Qq.Impl.delabQuotedLevel
code: def delabQuotedLevel : DelabM Syntax.Level 
goal: Lean.PrettyPrinter.Delaborator.DelabM Lean.Syntax.Level

full_name: Qq.Impl.delabQ
code: @[delab app.Qq.Quoted]
def delabQ : Delab 
goal: Lean.PrettyPrinter.Delaborator.Delab

full_name: Qq.Impl.delabq
code: @[delab app.Qq.Quoted.unsafeMk]
def delabq : Delab 
goal: Lean.PrettyPrinter.Delaborator.Delab

full_name: Qq.Impl.delabQuotedDefEq
code: @[delab app.Qq.QuotedDefEq]
def delabQuotedDefEq : Delab 
goal: Lean.PrettyPrinter.Delaborator.Delab

full_name: Qq.Impl.delabQuotedLevelDefEq
code: @[delab app.Qq.QuotedLevelDefEq]
def delabQuotedLevelDefEq : Delab 
goal: Lean.PrettyPrinter.Delaborator.Delab
File: .lake/packages/lean4/src/lean/Init/Control/Id.lean

full_name: Id
code: def Id (type : Type u) : Type u 
goal: Type u

full_name: Id.instMonad
code: @[always_inline]
instance : Monad Id 
goal: Monad Id

full_name: Id.hasBind
code: def hasBind : Bind Id 
goal: Bind Id

full_name: Id.run
code: @[always_inline, inline]
protected def run (x : Id α) : α 
goal: α

full_name: Id.instOfNat
code: instance [OfNat α n] : OfNat (Id α) n 
goal: OfNat (Id α) n
File: .lake/packages/Qq/Qq/ForLean/ReduceEval.lean

full_name: Lean.Meta.throwFailedToEval
code: def throwFailedToEval (e : Expr) : MetaM α 
goal: Lean.MetaM α

full_name: _private.«.lake».packages.Qq.Qq.ForLean.ReduceEval.0.Lean.Meta.evalList
code: private partial def evalList [ReduceEval α] (e : Expr) : MetaM (List α) 
goal: Lean.MetaM (List α)

full_name: Lean.Meta.«instReduceEvalList_.lake»
code: instance [ReduceEval α] : ReduceEval (List α) 
goal: Lean.Meta.ReduceEval (List α)

full_name: Lean.Meta.«instReduceEvalFinHAddNatOfNat_.lake»
code: instance : ReduceEval (Fin (n+1)) 
goal: Lean.Meta.ReduceEval (Fin (n + 1))

full_name: Lean.Meta.«instReduceEvalUInt64_.lake»
code: instance : ReduceEval UInt64 
goal: Lean.Meta.ReduceEval UInt64

full_name: Lean.Meta.«instReduceEvalUSize_.lake»
code: instance : ReduceEval USize 
goal: Lean.Meta.ReduceEval USize

full_name: Lean.Meta.«instReduceEvalBool_.lake»
code: instance : ReduceEval Bool 
goal: Lean.Meta.ReduceEval Bool

full_name: Lean.Meta.«instReduceEvalBinderInfo_.lake»
code: instance : ReduceEval BinderInfo 
goal: Lean.Meta.ReduceEval Lean.BinderInfo

full_name: Lean.Meta.«instReduceEvalLiteral_.lake»
code: instance : ReduceEval Literal 
goal: Lean.Meta.ReduceEval Lean.Literal

full_name: Lean.Meta.«instReduceEvalMVarId_.lake»
code: instance : ReduceEval MVarId 
goal: Lean.Meta.ReduceEval Lean.MVarId

full_name: Lean.Meta.«instReduceEvalLevelMVarId_.lake»
code: instance : ReduceEval LevelMVarId 
goal: Lean.Meta.ReduceEval Lean.LevelMVarId

full_name: Lean.Meta.«instReduceEvalFVarId_.lake»
code: instance : ReduceEval FVarId 
goal: Lean.Meta.ReduceEval Lean.FVarId
File: .lake/packages/lean4/src/lean/Init/Control/Reader.lean

full_name: ReaderT.orElse
code: @[always_inline, inline]
protected def orElse [Alternative m] (x₁ : ReaderT ρ m α) (x₂ : Unit → ReaderT ρ m α) : ReaderT ρ m α 
goal: ReaderT ρ m α

full_name: ReaderT.failure
code: @[always_inline, inline]
protected def failure [Alternative m] : ReaderT ρ m α 
goal: ReaderT ρ m α

full_name: ReaderT.«instAlternativeOfMonad_.lake»
code: instance [Alternative m] [Monad m] : Alternative (ReaderT ρ m) 
goal: Alternative (ReaderT ρ m)

full_name: «instMonadControlReaderT_.lake»
code: instance : MonadControl m (ReaderT ρ m) 
goal: MonadControl m (ReaderT ρ m)

full_name: ReaderT.tryFinally
code: @[always_inline]
instance ReaderT.tryFinally [MonadFinally m] : MonadFinally (ReaderT ρ m) 
goal: MonadFinally (ReaderT ρ m)

full_name: ReaderM
code: @[reducible] def ReaderM (ρ : Type u) 
goal: Type u
File: .lake/packages/lean4/src/lean/Init/Control/EState.lean

full_name: EStateM.«instToStringResult_.lake»
code: instance [ToString ε] [ToString α] : ToString (Result ε σ α) 
goal: ToString (EStateM.Result ε σ α)

full_name: EStateM.«instReprResult_.lake»
code: instance [Repr ε] [Repr α] : Repr (Result ε σ α) 
goal: Repr (EStateM.Result ε σ α)

full_name: EStateM.orElse'
code: /-- Alternative orElse operator that allows to select which exception should be used.
    The default is to use the first exception since the standard `orElse` uses the second. -/
@[always_inline, inline]
protected def orElse' {δ} [Backtrackable δ σ] (x₁ x₂ : EStateM ε σ α) (useFirstEx := true) : EStateM ε σ α 
goal: EStateM ε σ α

full_name: EStateM.«instMonadFinally_.lake»
code: @[always_inline]
instance : MonadFinally (EStateM ε σ) 
goal: MonadFinally (EStateM ε σ)

full_name: EStateM.fromStateM
code: @[always_inline, inline] def fromStateM {ε σ α : Type} (x : StateM σ α) : EStateM ε σ α 
goal: EStateM ε σ α
File: .lake/packages/lean4/src/lean/Init/Control/Option.lean

full_name: «instToBoolOption_.lake»
code: instance : ToBool (Option α) 
goal: ToBool (Option α)

full_name: OptionT
code: def OptionT (m : Type u → Type v) (α : Type u) : Type v 
goal: Type v

full_name: OptionT.run
code: @[always_inline, inline]
def OptionT.run {m : Type u → Type v} {α : Type u} (x : OptionT m α) : m (Option α) 
goal: m (Option α)

full_name: OptionT.mk
code: protected def mk (x : m (Option α)) : OptionT m α 
goal: OptionT m α

full_name: OptionT.bind
code: @[always_inline, inline]
protected def bind (x : OptionT m α) (f : α → OptionT m β) : OptionT m β 
goal: OptionT m β

full_name: OptionT.pure
code: @[always_inline, inline]
protected def pure (a : α) : OptionT m α 
goal: OptionT m α

full_name: OptionT.instMonad
code: @[always_inline]
instance : Monad (OptionT m) 
goal: Monad (OptionT m)

full_name: OptionT.orElse
code: @[always_inline, inline] protected def orElse (x : OptionT m α) (y : Unit → OptionT m α) : OptionT m α 
goal: OptionT m α

full_name: OptionT.fail
code: @[always_inline, inline] protected def fail : OptionT m α 
goal: OptionT m α

full_name: OptionT.instAlternative
code: instance : Alternative (OptionT m) 
goal: Alternative (OptionT m)

full_name: OptionT.lift
code: @[always_inline, inline] protected def lift (x : m α) : OptionT m α 
goal: OptionT m α

full_name: OptionT.instMonadLift
code: instance : MonadLift m (OptionT m) 
goal: MonadLift m (OptionT m)

full_name: OptionT.instMonadFunctor
code: instance : MonadFunctor m (OptionT m) 
goal: MonadFunctor m (OptionT m)

full_name: OptionT.tryCatch
code: @[always_inline, inline] protected def tryCatch (x : OptionT m α) (handle : Unit → OptionT m α) : OptionT m α 
goal: OptionT m α

full_name: OptionT.instMonadExceptOfUnit
code: instance : MonadExceptOf Unit (OptionT m) 
goal: MonadExceptOf Unit (OptionT m)

full_name: OptionT.instMonadExceptOf
code: instance (ε : Type u) [MonadExceptOf ε m] : MonadExceptOf ε (OptionT m) 
goal: MonadExceptOf ε (OptionT m)

full_name: instMonadControlOptionTOfMonad
code: instance [Monad m] : MonadControl m (OptionT m) 
goal: MonadControl m (OptionT m)
File: .lake/packages/lean4/src/lean/Init/Control/StateRef.lean

full_name: StateRefT'
code: def StateRefT' (ω : Type) (σ : Type) (m : Type → Type) (α : Type) : Type 
goal: Type

full_name: StateRefT'.run
code: @[always_inline, inline]
def StateRefT'.run {ω σ : Type} {m : Type → Type} [Monad m] [MonadLiftT (ST ω) m] {α : Type} (x : StateRefT' ω σ m α) (s : σ) : m (α × σ) 
goal: m (α × σ)

full_name: StateRefT'.run'
code: @[always_inline, inline]
def StateRefT'.run' {ω σ : Type} {m : Type → Type} [Monad m] [MonadLiftT (ST ω) m] {α : Type} (x : StateRefT' ω σ m α) (s : σ) : m α 
goal: m α

full_name: StateRefT'.lift
code: @[always_inline, inline]
protected def lift (x : m α) : StateRefT' ω σ m α 
goal: StateRefT' ω σ m α

full_name: StateRefT'.instMonad
code: instance [Monad m] : Monad (StateRefT' ω σ m) 
goal: Monad (StateRefT' ω σ m)

full_name: StateRefT'.instMonadLift
code: instance : MonadLift m (StateRefT' ω σ m) 
goal: MonadLift m (StateRefT' ω σ m)

full_name: StateRefT'.instMonadFunctor
code: instance (σ m) : MonadFunctor m (StateRefT' ω σ m) 
goal: MonadFunctor m (StateRefT' ω σ m)

full_name: StateRefT'.instAlternativeOfMonad
code: instance [Alternative m] [Monad m] : Alternative (StateRefT' ω σ m) 
goal: Alternative (StateRefT' ω σ m)

full_name: StateRefT'.get
code: @[inline]
protected def get [MonadLiftT (ST ω) m] : StateRefT' ω σ m σ 
goal: StateRefT' ω σ m σ

full_name: StateRefT'.set
code: @[inline]
protected def set [MonadLiftT (ST ω) m] (s : σ) : StateRefT' ω σ m PUnit 
goal: StateRefT' ω σ m PUnit

full_name: StateRefT'.modifyGet
code: @[inline]
protected def modifyGet [MonadLiftT (ST ω) m] (f : σ → α × σ) : StateRefT' ω σ m α 
goal: StateRefT' ω σ m α

full_name: StateRefT'.instMonadStateOfOfMonadLiftTST
code: instance [MonadLiftT (ST ω) m] : MonadStateOf σ (StateRefT' ω σ m) 
goal: MonadStateOf σ (StateRefT' ω σ m)

full_name: StateRefT'.instMonadExceptOf
code: @[always_inline]
instance (ε) [MonadExceptOf ε m] : MonadExceptOf ε (StateRefT' ω σ m) 
goal: MonadExceptOf ε (StateRefT' ω σ m)

full_name: instMonadControlStateRefT'
code: instance (ω σ : Type) (m : Type → Type) : MonadControl m (StateRefT' ω σ m) 
goal: MonadControl m (StateRefT' ω σ m)

full_name: instMonadFinallyStateRefT'OfMonad
code: instance {m : Type → Type} {ω σ : Type} [MonadFinally m] [Monad m] : MonadFinally (StateRefT' ω σ m) 
goal: MonadFinally (StateRefT' ω σ m)
File: .lake/packages/lean4/src/lean/Init/Hints.lean

full_name: hint._@..lake.packages.lean4.src.lean.Init.Hints._hyg.3
code: unif_hint (p : Prop) where
  |- Not p =?= p → False
goal: Prop
File: .lake/packages/lean4/src/lean/Init/Omega/Logic.lean

full_name: Lean.Omega.and_not_not_of_not_or
code: theorem and_not_not_of_not_or (h : ¬ (p ∨ q)) : ¬ p ∧ ¬ q 
goal: ¬p ∧ ¬q

full_name: Lean.Omega.Decidable.or_not_not_of_not_and
code: theorem Decidable.or_not_not_of_not_and [Decidable p] [Decidable q]
    (h : ¬ (p ∧ q)) : ¬ p ∨ ¬ q 
goal: ¬p ∨ ¬q

full_name: Lean.Omega.Decidable.and_or_not_and_not_of_iff
code: theorem Decidable.and_or_not_and_not_of_iff {p q : Prop} [Decidable q] (h : p ↔ q) :
    (p ∧ q) ∨ (¬p ∧ ¬q) 
goal: p ∧ q ∨ ¬p ∧ ¬q

full_name: Lean.Omega.Decidable.not_iff_iff_and_not_or_not_and
code: theorem Decidable.not_iff_iff_and_not_or_not_and [Decidable a] [Decidable b] :
    (¬ (a ↔ b)) ↔ (a ∧ ¬ b) ∨ ((¬ a) ∧ b) 
goal: ¬(a ↔ b) ↔ a ∧ ¬b ∨ ¬a ∧ b

full_name: Lean.Omega.Decidable.and_not_or_not_and_of_not_iff
code: theorem Decidable.and_not_or_not_and_of_not_iff [Decidable a] [Decidable b]
    (h : ¬ (a ↔ b)) : a ∧ ¬b ∨ ¬a ∧ b 
goal: a ∧ ¬b ∨ ¬a ∧ b

full_name: Lean.Omega.Decidable.and_not_of_not_imp
code: theorem Decidable.and_not_of_not_imp [Decidable a] (h : ¬(a → b)) : a ∧ ¬b 
goal: a ∧ ¬b

full_name: Lean.Omega.ite_disjunction
code: theorem ite_disjunction {α : Type u} {P : Prop} [Decidable P] {a b : α} :
    (P ∧ (if P then a else b) = a) ∨ (¬ P ∧ (if P then a else b) = b) 
goal: P ∧ (if P then a else b) = a ∨ ¬P ∧ (if P then a else b) = b
File: .lake/packages/lean4/src/lean/Init/System/Platform.lean

full_name: System.Platform.getIsWindows
code: @[extern "lean_system_platform_windows"] opaque getIsWindows : Unit → Bool
goal: Unit → Bool

full_name: System.Platform.getIsOSX
code: @[extern "lean_system_platform_osx"] opaque getIsOSX : Unit → Bool
goal: Unit → Bool

full_name: System.Platform.getIsEmscripten
code: @[extern "lean_system_platform_emscripten"] opaque getIsEmscripten : Unit → Bool
goal: Unit → Bool

full_name: System.Platform.isWindows
code: def isWindows : Bool 
goal: Bool

full_name: System.Platform.isOSX
code: def isOSX : Bool 
goal: Bool

full_name: System.Platform.isEmscripten
code: def isEmscripten : Bool 
goal: Bool

full_name: System.Platform.getTarget
code: @[extern "lean_system_platform_target"] opaque getTarget : Unit → String
goal: Unit → String

full_name: System.Platform.target
code: /-- The LLVM target triple of the current platform. Empty if missing at Lean compile time. -/
def target : String 
goal: String
File: .lake/packages/lean4/src/lean/Init/System/Promise.lean

full_name: _private.«.lake».packages.lean4.src.lean.Init.System.Promise.0.IO.PromisePointed
code: private opaque PromisePointed : NonemptyType.{0}
goal: NonemptyType

full_name: _private.«.lake».packages.lean4.src.lean.Init.System.Promise.0.IO.PromiseImpl
code: private structure PromiseImpl (α : Type) : Type where
  prom : PromisePointed.type
  h    : Nonempty α
goal: Type

full_name: _private.«.lake».packages.lean4.src.lean.Init.System.Promise.0.IO.PromiseImpl.prom
code: private structure PromiseImpl (α : Type) : Type where
  prom : PromisePointed.type
  h    : Nonempty α
goal: IO.PromisePointed.type

full_name: _private.«.lake».packages.lean4.src.lean.Init.System.Promise.0.IO.PromiseImpl.h
code: private structure PromiseImpl (α : Type) : Type where
  prom : PromisePointed.type
  h    : Nonempty α
goal: Nonempty α

full_name: IO.Promise
code: /--
`Promise α` allows you to create a `Task α` whose value is provided later by calling `resolve`.

Typical usage is as follows:
1. `let promise ← Promise.new` creates a promise
2. `promise.result : Task α` can now be passed around
3. `promise.result.get` blocks until the promise is resolved
4. `promise.resolve a` resolves the promise
5. `promise.result.get` now returns `a`

Every promise must eventually be resolved.
Otherwise the memory used for the promise will be leaked,
and any tasks depending on the promise's result will wait forever.
-/
def Promise (α : Type) : Type 
goal: Type

full_name: IO.instNonemptyPromise
code: instance [s : Nonempty α] : Nonempty (Promise α) 
goal: Nonempty (IO.Promise α)

full_name: IO.Promise.new
code: /-- Creates a new `Promise`. -/
@[extern "lean_io_promise_new"]
opaque Promise.new [Nonempty α] : BaseIO (Promise α)
goal: BaseIO (IO.Promise α)

full_name: IO.Promise.resolve
code: /--
Resolves a `Promise`.

Only the first call to this function has an effect.
-/
@[extern "lean_io_promise_resolve"]
opaque Promise.resolve (value : α) (promise : @& Promise α) : BaseIO Unit
goal: BaseIO Unit

full_name: IO.Promise.result
code: /--
The result task of a `Promise`.

The task blocks until `Promise.resolve` is called.
-/
@[extern "lean_io_promise_result"]
opaque Promise.result (promise : Promise α) : Task α 
goal: Task α
File: .lake/packages/lean4/src/lean/Init/Grind/Lemmas.lean

full_name: Lean.Grind.intro_with_eq
code: theorem intro_with_eq (p p' q : Prop) (he : p = p') (h : p' → q) : p → q 
goal: p → q
File: .lake/packages/lean4/src/lean/Init/System/Uri.lean

full_name: System.Uri.UriEscape.zero
code: @[inline] def zero : UInt8 
goal: UInt8

full_name: System.Uri.UriEscape.nine
code: @[inline] def nine : UInt8 
goal: UInt8

full_name: System.Uri.UriEscape.lettera
code: @[inline] def lettera : UInt8 
goal: UInt8

full_name: System.Uri.UriEscape.letterf
code: @[inline] def letterf : UInt8 
goal: UInt8

full_name: System.Uri.UriEscape.letterA
code: @[inline] def letterA : UInt8 
goal: UInt8

full_name: System.Uri.UriEscape.letterF
code: @[inline] def letterF : UInt8 
goal: UInt8

full_name: System.Uri.UriEscape.decodeUri
code: /-- Decode %HH escapings in the given string. Note that sometimes a consecutive
sequence of multiple escapings can represent a utf-8 encoded sequence for
a single unicode code point and these will also be decoded correctly. -/
def decodeUri (uri : String) : String 
goal: String

full_name: System.Uri.UriEscape.decodeUri.hexDigitToUInt8?
code: /-- Decode %HH escapings in the given string. Note that sometimes a consecutive
sequence of multiple escapings can represent a utf-8 encoded sequence for
a single unicode code point and these will also be decoded correctly. -/
def decodeUri (uri : String) : String 
goal: Option UInt8

full_name: System.Uri.UriEscape.rfc3986ReservedChars
code: def rfc3986ReservedChars : List Char 
goal: List Char

full_name: System.Uri.UriEscape.uriEscapeAsciiChar.uInt8ToHex
code: def uriEscapeAsciiChar (c : Char) : String 
goal: String

full_name: System.Uri.UriEscape.uriEscapeAsciiChar
code: def uriEscapeAsciiChar (c : Char) : String 
goal: String

full_name: System.Uri.escapeUri
code: /-- Replaces special characters in the given Uri with %HH Uri escapings. -/
def escapeUri (uri: String) : String 
goal: String

full_name: System.Uri.unescapeUri
code: /-- Replaces all %HH Uri escapings in the given string with their
corresponding unicode code points.  Note that sometimes a consecutive
sequence of multiple escapings can represent a utf-8 encoded sequence for
a single unicode code point and these will also be decoded correctly. -/
def unescapeUri (s: String) : String 
goal: String

full_name: System.Uri.pathToUri
code: /-- Convert the given FilePath to a "file:///encodedpath" Uri. -/
def pathToUri (fname : System.FilePath) : String 
goal: String

full_name: System.Uri.fileUriToPath?
code: /-- Convert the given uri to a FilePath stripping the 'file://' prefix,
ignoring the optional host name. -/
def fileUriToPath? (uri : String) : Option System.FilePath 
goal: Option System.FilePath
File: .lake/packages/lean4/src/lean/Init/Grind/Tactics.lean

full_name: Lean.Grind.instBEqConfig
code: /--
The configuration for `grind`.
Passed to `grind` using, for example, the `grind (config := { eager := true })` syntax.
-/
structure Config where
  /--
  When `eager` is true (default: `false`), `grind` eagerly splits `if-then-else` and `match`
  expressions.
  -/
  eager : Bool := false
  deriving Inhabited, BEq
goal: BEq Lean.Grind.Config

full_name: Lean.Grind.Config
code: /--
The configuration for `grind`.
Passed to `grind` using, for example, the `grind (config := { eager := true })` syntax.
-/
structure Config where
  /--
  When `eager` is true (default: `false`), `grind` eagerly splits `if-then-else` and `match`
  expressions.
  -/
  eager : Bool := false
  deriving Inhabited, BEq
goal: Type

full_name: Lean.Grind.Config.eager
code: /--
The configuration for `grind`.
Passed to `grind` using, for example, the `grind (config := { eager := true })` syntax.
-/
structure Config where
  /--
  When `eager` is true (default: `false`), `grind` eagerly splits `if-then-else` and `match`
  expressions.
  -/
  eager : Bool := false
  deriving Inhabited, BEq
goal: Bool

full_name: Lean.Grind.instInhabitedConfig
code: /--
The configuration for `grind`.
Passed to `grind` using, for example, the `grind (config := { eager := true })` syntax.
-/
structure Config where
  /--
  When `eager` is true (default: `false`), `grind` eagerly splits `if-then-else` and `match`
  expressions.
  -/
  eager : Bool := false
  deriving Inhabited, BEq
goal: Inhabited Lean.Grind.Config
File: .lake/packages/lean4/src/lean/Init/Grind/Norm.lean

full_name: Lean.Grind.iff_eq
code: @[grind_norm] theorem iff_eq (p q : Prop) : (p ↔ q) = (p = q) 
goal: (p ↔ q) = (p = q)

full_name: Lean.Grind.eq_true_eq
code: @[grind_norm] theorem eq_true_eq (p : Prop) : (p = True) = p 
goal: (p = True) = p

full_name: Lean.Grind.eq_false_eq
code: @[grind_norm] theorem eq_false_eq (p : Prop) : (p = False) = ¬p 
goal: (p = False) = ¬p

full_name: Lean.Grind.not_eq_prop
code: @[grind_norm] theorem not_eq_prop (p q : Prop) : (¬(p = q)) = (p = ¬q) 
goal: (¬p = q) = (p = ¬q)

full_name: Lean.Grind.imp_eq
code: @[grind_norm] theorem imp_eq (p q : Prop) : (p → q) = (¬ p ∨ q) 
goal: (p → q) = (¬p ∨ q)

full_name: Lean.Grind.not_and
code: @[grind_norm↓] theorem not_and (p q : Prop) : (¬(p ∧ q)) = (¬p ∨ ¬q) 
goal: (¬(p ∧ q)) = (¬p ∨ ¬q)

full_name: Lean.Grind.not_ite
code: @[grind_norm↓] theorem not_ite {_ : Decidable p} (q r : Prop) : (¬ite p q r) = ite p (¬q) (¬r) 
goal: ∀ {x : Decidable p} (q r : Prop), (¬if p then q else r) = if p then ¬q else ¬r

full_name: Lean.Grind.not_forall
code: @[grind_norm↓] theorem not_forall (p : α → Prop) : (¬∀ x, p x) = ∃ x, ¬p x 
goal: (¬∀ (x : α), p x) = ∃ x, ¬p x

full_name: Lean.Grind.not_exists
code: @[grind_norm↓] theorem not_exists (p : α → Prop) : (¬∃ x, p x) = ∀ x, ¬p x 
goal: (¬∃ x, p x) = ∀ (x : α), ¬p x

full_name: Lean.Grind.cond_eq_ite
code: @[grind_norm] theorem cond_eq_ite (c : Bool) (a b : α) : cond c a b = ite c a b 
goal: (bif c then a else b) = if c = true then a else b

full_name: Lean.Grind.Nat.lt_eq
code: @[grind_norm] theorem Nat.lt_eq (a b : Nat) : (a < b) = (a + 1 ≤ b) 
goal: (a < b) = (a + 1 ≤ b)

full_name: Lean.Grind.Int.lt_eq
code: @[grind_norm] theorem Int.lt_eq (a b : Int) : (a < b) = (a + 1 ≤ b) 
goal: (a < b) = (a + 1 ≤ b)
File: .lake/packages/lean4/src/lean/Init/SizeOfLemmas.lean

full_name: Fin.sizeOf
code: @[simp] protected theorem Fin.sizeOf (a : Fin n) : sizeOf a = a.val + 1 
goal: sizeOf a = ↑a + 1

full_name: UInt8.sizeOf
code: @[simp] protected theorem UInt8.sizeOf (a : UInt8) : sizeOf a = a.toNat + 2 
goal: sizeOf a = a.toNat + 2

full_name: UInt16.sizeOf
code: @[simp] protected theorem UInt16.sizeOf (a : UInt16) : sizeOf a = a.toNat + 2 
goal: sizeOf a = a.toNat + 2

full_name: UInt32.sizeOf
code: @[simp] protected theorem UInt32.sizeOf (a : UInt32) : sizeOf a = a.toNat + 2 
goal: sizeOf a = a.toNat + 2

full_name: UInt64.sizeOf
code: @[simp] protected theorem UInt64.sizeOf (a : UInt64) : sizeOf a = a.toNat + 2 
goal: sizeOf a = a.toNat + 2

full_name: USize.sizeOf
code: @[simp] protected theorem USize.sizeOf (a : USize) : sizeOf a = a.toNat + 2 
goal: sizeOf a = a.toNat + 2

full_name: Char.sizeOf
code: @[simp] protected theorem Char.sizeOf (a : Char) : sizeOf a = a.toNat + 3 
goal: sizeOf a = a.toNat + 3

full_name: Subtype.sizeOf
code: @[simp] protected theorem Subtype.sizeOf {α : Sort u_1} {p : α → Prop} (s : Subtype p) : sizeOf s = sizeOf s.val + 1 
goal: sizeOf s = sizeOf s.val + 1
File: .lake/packages/lean4/src/lean/Init/MacroTrace.lean

full_name: Lean.«termMacro.trace[_]_»
code: macro "Macro.trace[" id:ident "]" s:interpolatedStr(term) : term =>
  `(Macro.trace $(quote id.getId.eraseMacroScopes) (s! $s))
goal: Lean.ParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_MacroTrace___macroRules_Lean_termMacro.trace[_]__1»
code: macro "Macro.trace[" id:ident "]" s:interpolatedStr(term) : term =>
  `(Macro.trace $(quote id.getId.eraseMacroScopes) (s! $s))
goal: Lean.Macro
File: .lake/packages/lean4/src/lean/Init/Data/Sum.lean

full_name: Sum.«instBEq_.lake»
code: BEq
goal: {α : Type u_1} → {β : Type u_2} → [inst : BEq α] → [inst : BEq β] → BEq (α ⊕ β)

full_name: Sum.getLeft?
code: /-- Check if a sum is `inl` and if so, retrieve its contents. -/
def getLeft? : α ⊕ β → Option α
  
goal: α ⊕ β → Option α

full_name: Sum.getRight?
code: /-- Check if a sum is `inr` and if so, retrieve its contents. -/
def getRight? : α ⊕ β → Option β
  
goal: α ⊕ β → Option β