ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/IndependentOf.lean

full_name: Lean.MVarId.isIndependentOf
code: /--
Check if a goal is "independent" of a list of other goals.
We say a goal is independent of other goals if assigning a value to it
can not change the assignability of the other goals.

Examples:
* `?m_1 : Type` is not independent of `?m_2 : ?m_1`,
  because we could assign `true : Bool` to `?m_2`,
  but if we first assign `Nat` to `?m_1` then that is no longer possible.
* `?m_1 : Nat` is not independent of `?m_2 : Fin ?m_1`,
  because we could assign `37 : Fin 42` to `?m_2`,
  but if we first assign `2` to `?m_1` then that is no longer possible.
* `?m_1 : ?m_2` is not independent of `?m_2 : Type`, because we could assign `Bool` to ?m_2`,
  but if we first assign `0 : Nat` to `?m_1` then that is no longer possible.
* Given `P : Prop` and `f : P → Type`, `?m_1 : P` is independent of `?m_2 : f ?m_1`
  by proof irrelevance.
* Similarly given `f : Fin 0 → Type`, `?m_1 : Fin 0` is independent of `?m_2 : f ?m_1`,
  because `Fin 0` is a subsingleton.
* Finally `?m_1 : Nat` is independent of `?m_2 : α`,
  as long as `?m_1` does not appear in `Meta.getMVars α`
  (note that `Meta.getMVars` follows delayed assignments).

This function only calculates a conservative approximation of this condition.
That is, it may return `false` when it should return `true`.
(In particular it returns false whenever the type of `g` contains a metavariable,
regardless of whether this is related to the metavariables in `L`.)
-/
def isIndependentOf (L : List MVarId) (g : MVarId) : MetaM Bool 
goal: Lean.MetaM Bool
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.lean

full_name: String.fromExpr?
code: def fromExpr? (e : Expr) : SimpM (Option String) 
goal: Lean.Meta.SimpM (Option String)

full_name: String.reduceAppend
code: builtin_dsimproc [simp, seval] reduceAppend ((_ ++ _ : String)) := fun e => do
  unless e.isAppOfArity ``HAppend.hAppend 6 do return .continue
  let some a ← fromExpr? e.appFn!.appArg! | return .continue
  let some b ← fromExpr? e.appArg! | return .continue
  return .done <| toExpr (a ++ b)
goal: Lean.Meta.Simp.DSimproc

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0.String.reduceListChar
code: private partial def reduceListChar (e : Expr) (s : String) : SimpM DStep 
goal: Lean.Meta.SimpM Lean.Meta.Simp.DStep

full_name: String.reduceMk
code: builtin_dsimproc [simp, seval] reduceMk (String.mk _) := fun e => do
  unless e.isAppOfArity ``String.mk 1 do return .continue
  reduceListChar e.appArg! ""
goal: Lean.Meta.Simp.DSimproc

full_name: String.reduceBinPred
code: @[inline] def reduceBinPred (declName : Name) (arity : Nat) (op : String → String → Bool) (e : Expr) : SimpM Step 
goal: Lean.Meta.SimpM Lean.Meta.Simp.Step

full_name: String.reduceBoolPred
code: @[inline] def reduceBoolPred (declName : Name) (arity : Nat) (op : String → String → Bool) (e : Expr) : SimpM DStep 
goal: Lean.Meta.SimpM Lean.Meta.Simp.DStep

full_name: String.reduceLT
code: builtin_simproc [simp, seval] reduceLT  (( _ : String) < _)  := reduceBinPred ``LT.lt 4 (. < .)
goal: Lean.Meta.Simp.Simproc

full_name: String.reduceLE
code: builtin_simproc [simp, seval] reduceLE  (( _ : String) ≤ _)  := reduceBinPred ``LE.le 4 (. ≤ .)
goal: Lean.Meta.Simp.Simproc

full_name: String.reduceGT
code: builtin_simproc [simp, seval] reduceGT  (( _ : String) > _)  := reduceBinPred ``GT.gt 4 (. > .)
goal: Lean.Meta.Simp.Simproc

full_name: String.reduceGE
code: builtin_simproc [simp, seval] reduceGE  (( _ : String) ≥ _)  := reduceBinPred ``GE.ge 4 (. ≥ .)
goal: Lean.Meta.Simp.Simproc

full_name: String.reduceEq
code: builtin_simproc [simp, seval] reduceEq  (( _ : String) = _)  := reduceBinPred ``Eq 3 (. = .)
goal: Lean.Meta.Simp.Simproc

full_name: String.reduceNe
code: builtin_simproc [simp, seval] reduceNe  (( _ : String) ≠ _)  := reduceBinPred ``Ne 3 (. ≠ .)
goal: Lean.Meta.Simp.Simproc

full_name: String.reduceBEq
code: builtin_dsimproc [simp, seval] reduceBEq  (( _ : String) == _)  := reduceBoolPred ``BEq.beq 4 (. == .)
goal: Lean.Meta.Simp.DSimproc

full_name: String.reduceBNe
code: builtin_dsimproc [simp, seval] reduceBNe  (( _ : String) != _)  := reduceBoolPred ``bne 4 (. != .)
goal: Lean.Meta.Simp.DSimproc
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Simp/Attr.lean

full_name: Lean.Meta.mkSimpAttr
code: def mkSimpAttr (attrName : Name) (attrDescr : String) (ext : SimpExtension)
    (ref : Name := by exact decl_name%) : IO Unit 
goal: IO Unit

full_name: Lean.Meta.registerSimpAttr
code: def registerSimpAttr (attrName : Name) (attrDescr : String)
    (ref : Name := by exact decl_name%) : IO SimpExtension 
goal: IO Lean.Meta.SimpExtension

full_name: Lean.Meta.simpExtension
code: builtin_initialize simpExtension : SimpExtension ← registerSimpAttr `simp "simplification theorem"
goal: Lean.Meta.SimpExtension

full_name: Lean.Meta.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp.Attr._hyg.689
code: builtin_initialize simpExtension : SimpExtension ← registerSimpAttr `simp "simplification theorem"
goal: IO Lean.Meta.SimpExtension

full_name: Lean.Meta.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp.Attr._hyg.717
code: builtin_initialize sevalSimpExtension : SimpExtension ← registerSimpAttr `seval "symbolic evaluator theorem"
goal: IO Lean.Meta.SimpExtension

full_name: Lean.Meta.sevalSimpExtension
code: builtin_initialize sevalSimpExtension : SimpExtension ← registerSimpAttr `seval "symbolic evaluator theorem"
goal: Lean.Meta.SimpExtension

full_name: Lean.Meta.getSimpTheorems
code: def getSimpTheorems : CoreM SimpTheorems 
goal: Lean.CoreM Lean.Meta.SimpTheorems

full_name: Lean.Meta.getSEvalTheorems
code: def getSEvalTheorems : CoreM SimpTheorems 
goal: Lean.CoreM Lean.Meta.SimpTheorems

full_name: Lean.Meta.Simp.Context.mkDefault
code: def Simp.Context.mkDefault : MetaM Context 
goal: Lean.MetaM Lean.Meta.Simp.Context
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.lean

full_name: Lean.Meta.Simp.evalPropStep
code: /--
Let `result` be the result of evaluating proposition `p`, return a `.done` step where
the resulting expression is `True`(`False`) if `result is `true`(`false`), and the
proof is uses `Decidable p` and the auxiliary theorems `eq_true_of_decide`/`eq_false_of_decide`.
-/
def evalPropStep (p : Expr) (result : Bool) : SimpM Step 
goal: Lean.Meta.SimpM Lean.Meta.Simp.Step
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Simp/RegisterCommand.lean

full_name: Lean.Meta.Simp.«_aux_.lake_packages_lean4_src_lean_Lean_Meta_Tactic_Simp_RegisterCommand___macroRules_Lean_Meta_Simp__root__Lean_Parser_Command_registerSimpAttr_1»
code: macro (name := _root_.Lean.Parser.Command.registerSimpAttr) doc:(docComment)?
  "register_simp_attr" id:ident : command => do
  let str := id.getId.toString
  let idParser := mkIdentFrom id (`Parser.Attr ++ id.getId)
  let descr := quote ((doc.map (·.getDocString) |>.getD s!"simp set for {id.getId.toString}").removeLeadingSpaces)
  let procId := mkIdentFrom id (simpAttrNameToSimprocAttrName id.getId)
  let procStr := procId.getId.toString
  let procIdParser := mkIdentFrom procId (`Parser.Attr ++ procId.getId)
  let procDescr := quote s!"simproc set for {procId.getId.toString}"
  -- TODO: better docDomment for simprocs
  `($[$doc:docComment]? initialize ext : SimpExtension ← registerSimpAttr $(quote id.getId) $descr $(quote id.getId)
    $[$doc:docComment]? syntax (name := $idParser:ident) $(quote str):str (Parser.Tactic.simpPre <|> Parser.Tactic.simpPost)? (prio)? : attr
    /-- Simplification procedure -/
    initialize extProc : SimprocExtension ← registerSimprocAttr $(quote procId.getId) $procDescr none $(quote procId.getId)
    /-- Simplification procedure -/
    syntax (name := $procIdParser:ident) $(quote procStr):str (Parser.Tactic.simpPre <|> Parser.Tactic.simpPost)? : attr)
goal: Lean.Macro

full_name: Lean.Parser.Command.registerSimpAttr
code: macro (name := _root_.Lean.Parser.Command.registerSimpAttr) doc:(docComment)?
  "register_simp_attr" id:ident : command => do
  let str := id.getId.toString
  let idParser := mkIdentFrom id (`Parser.Attr ++ id.getId)
  let descr := quote ((doc.map (·.getDocString) |>.getD s!"simp set for {id.getId.toString}").removeLeadingSpaces)
  let procId := mkIdentFrom id (simpAttrNameToSimprocAttrName id.getId)
  let procStr := procId.getId.toString
  let procIdParser := mkIdentFrom procId (`Parser.Attr ++ procId.getId)
  let procDescr := quote s!"simproc set for {procId.getId.toString}"
  -- TODO: better docDomment for simprocs
  `($[$doc:docComment]? initialize ext : SimpExtension ← registerSimpAttr $(quote id.getId) $descr $(quote id.getId)
    $[$doc:docComment]? syntax (name := $idParser:ident) $(quote str):str (Parser.Tactic.simpPre <|> Parser.Tactic.simpPost)? (prio)? : attr
    /-- Simplification procedure -/
    initialize extProc : SimprocExtension ← registerSimprocAttr $(quote procId.getId) $procDescr none $(quote procId.getId)
    /-- Simplification procedure -/
    syntax (name := $procIdParser:ident) $(quote procStr):str (Parser.Tactic.simpPre <|> Parser.Tactic.simpPost)? : attr)
goal: Lean.ParserDescr
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Simp/Diagnostics.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Simp.Diagnostics.0.Lean.Meta.Simp.originToKey
code: private def originToKey (thmId : Origin) : MetaM MessageData 
goal: Lean.MetaM Lean.MessageData

full_name: Lean.Meta.Simp.mkSimpDiagSummary
code: def mkSimpDiagSummary (counters : PHashMap Origin Nat) (usedCounters? : Option (PHashMap Origin Nat) := none) : MetaM DiagSummary 
goal: Lean.MetaM Lean.Meta.DiagSummary

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Simp.Diagnostics.0.Lean.Meta.Simp.mkTheoremsWithBadKeySummary
code: private def mkTheoremsWithBadKeySummary (thms : PArray SimpTheorem) : MetaM DiagSummary 
goal: Lean.MetaM Lean.Meta.DiagSummary

full_name: Lean.Meta.Simp.reportDiag
code: def reportDiag (diag : Simp.Diagnostics) : MetaM Unit 
goal: Lean.MetaM Unit
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/LinearArith/Basic.lean

full_name: Lean.Meta.Linear.isLinearTerm
code: /-- Quick filter for linear terms. -/
def isLinearTerm (e : Expr) : Bool 
goal: Bool

full_name: Lean.Meta.Linear.isLinearCnstr
code: /-- Quick filter for linear constraints. -/
partial def isLinearCnstr (e : Expr) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/LinearArith/Simp.lean

full_name: Lean.Meta.Linear.parentIsTarget
code: def parentIsTarget (parent? : Option Expr) : Bool 
goal: Bool

full_name: Lean.Meta.Linear.simp?
code: def simp? (e : Expr) (parent? : Option Expr) : MetaM (Option (Expr × Expr)) 
goal: Lean.MetaM (Option (Lean.Expr × Lean.Expr))
File: .lake/packages/lean4/src/lean/Lean/Meta/CheckTactic.lean

full_name: Lean.Meta.CheckTactic.mkCheckGoalType
code: def mkCheckGoalType (val type : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Lean.Meta.CheckTactic.matchCheckGoalType
code: def matchCheckGoalType (stx : Syntax) (goalType : Expr) : MetaM (Expr × Expr × Level) 
goal: Lean.MetaM (Lean.Expr × Lean.Expr × Lean.Level)
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/LinearArith/Nat/Solver.lean

full_name: Lean.Meta.Linear.Nat.Collect.LinearArith
code: inductive LinearArith
goal: Type

full_name: Lean.Meta.Linear.Nat.Collect.Cnstr.cnstr
code: structure Cnstr where
  cnstr : LinearArith
  proof : Expr
goal: Lean.Meta.Linear.Nat.Collect.LinearArith

full_name: Lean.Meta.Linear.Nat.Collect.Cnstr
code: structure Cnstr where
  cnstr : LinearArith
  proof : Expr
goal: Type

full_name: Lean.Meta.Linear.Nat.Collect.Cnstr.proof
code: structure Cnstr where
  cnstr : LinearArith
  proof : Expr
goal: Lean.Expr

full_name: Lean.Meta.Linear.Nat.Collect.State
code: structure State where
  cnstrs : Array Cnstr
goal: Type

full_name: Lean.Meta.Linear.Nat.Collect.State.cnstrs
code: structure State where
  cnstrs : Array Cnstr
goal: Array Lean.Meta.Linear.Nat.Collect.Cnstr

full_name: Lean.Meta.Linear.Nat.Collect.M
code: abbrev M 
goal: Type
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/LinearArith/Nat/Simp.lean

full_name: Lean.Meta.Linear.Nat.simpCnstrPos?
code: def simpCnstrPos? (e : Expr) : MetaM (Option (Expr × Expr)) 
goal: Lean.MetaM (Option (Lean.Expr × Lean.Expr))

full_name: Lean.Meta.Linear.Nat.simpCnstr?
code: def simpCnstr? (e : Expr) : MetaM (Option (Expr × Expr)) 
goal: Lean.MetaM (Option (Lean.Expr × Lean.Expr))

full_name: Lean.Meta.Linear.Nat.simpExpr?
code: def simpExpr? (e : Expr) : MetaM (Option (Expr × Expr)) 
goal: Lean.MetaM (Option (Lean.Expr × Lean.Expr))
File: .lake/packages/lean4/src/lean/Lean/Meta/NatInstTesters.lean

full_name: Lean.Meta.isInstOfNatNat
code: def isInstOfNatNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstAddNat
code: def isInstAddNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstSubNat
code: def isInstSubNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstMulNat
code: def isInstMulNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstDivNat
code: def isInstDivNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstModNat
code: def isInstModNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstNatPowNat
code: def isInstNatPowNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstPowNat
code: def isInstPowNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstHAddNat
code: def isInstHAddNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstHSubNat
code: def isInstHSubNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstHMulNat
code: def isInstHMulNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstHDivNat
code: def isInstHDivNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstHModNat
code: def isInstHModNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstHPowNat
code: def isInstHPowNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstLTNat
code: def isInstLTNat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isInstLENat
code: def isInstLENat (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool
File: .lake/packages/lean4/src/lean/Lean/Meta/Eval.lean

full_name: Lean.Meta.evalExprCore
code: unsafe def evalExprCore (α) (value : Expr) (checkType : Expr → MetaM Unit) (safety := DefinitionSafety.safe) : MetaM α 
goal: Lean.MetaM α

full_name: Lean.Meta.evalExpr'
code: unsafe def evalExpr' (α) (typeName : Name) (value : Expr) (safety := DefinitionSafety.safe) : MetaM α 
goal: Lean.MetaM α

full_name: Lean.Meta.evalExpr
code: unsafe def evalExpr (α) (expectedType : Expr) (value : Expr) (safety := DefinitionSafety.safe) : MetaM α 
goal: Lean.MetaM α
File: .lake/packages/lean4/src/lean/Lean/Meta/GlobalInstances.lean

full_name: Lean.Meta.globalInstanceExtension
code: builtin_initialize globalInstanceExtension : SimpleScopedEnvExtension Name (PersistentHashMap Name Unit)  ←
  registerSimpleScopedEnvExtension {
    initial  := {}
    addEntry := fun s n => s.insert n ()
  }
goal: Lean.SimpleScopedEnvExtension Lean.Name (Lean.PersistentHashMap Lean.Name Unit)

full_name: Lean.Meta.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.GlobalInstances._hyg.4
code: builtin_initialize globalInstanceExtension : SimpleScopedEnvExtension Name (PersistentHashMap Name Unit)  ←
  registerSimpleScopedEnvExtension {
    initial  := {}
    addEntry := fun s n => s.insert n ()
  }
goal: IO (Lean.SimpleScopedEnvExtension Lean.Name (Lean.PersistentHashMap Lean.Name Unit))

full_name: Lean.Meta.addGlobalInstance
code: def addGlobalInstance (declName : Name) (attrKind : AttributeKind) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.Meta.isGlobalInstance
code: @[export lean_is_instance]
def isGlobalInstance (env : Environment) (declName : Name) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Meta/Inductive.lean

full_name: Lean.Meta.compatibleCtors
code: /-- Return true if the types of the given constructors are compatible. -/
def compatibleCtors (ctorName₁ ctorName₂ : Name) : MetaM Bool 
goal: Lean.MetaM Bool
File: .lake/packages/lean4/src/lean/Lean/Meta/Reduce.lean

full_name: Lean.Meta.reduce
code: partial def reduce (e : Expr) (explicitOnly skipTypes skipProofs := true) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Lean.Meta.reduce.visit
code: partial def reduce (e : Expr) (explicitOnly skipTypes skipProofs := true) : MetaM Expr 
goal: Lean.MonadCacheT Lean.Expr Lean.Expr Lean.MetaM Lean.Expr

full_name: Lean.Meta.reduceAll
code: def reduceAll (e : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr
File: .lake/packages/lean4/src/lean/Lean/Meta/GeneralizeTelescope.lean

full_name: Lean.Meta.GeneralizeTelescope.Entry.expr
code: structure Entry where
  expr     : Expr
  type     : Expr
  modified : Bool
goal: Lean.Expr

full_name: Lean.Meta.GeneralizeTelescope.Entry
code: structure Entry where
  expr     : Expr
  type     : Expr
  modified : Bool
goal: Type

full_name: Lean.Meta.GeneralizeTelescope.Entry.type
code: structure Entry where
  expr     : Expr
  type     : Expr
  modified : Bool
goal: Lean.Expr

full_name: Lean.Meta.GeneralizeTelescope.Entry.modified
code: structure Entry where
  expr     : Expr
  type     : Expr
  modified : Bool
goal: Bool

full_name: Lean.Meta.GeneralizeTelescope.updateTypes
code: partial def updateTypes (e eNew : Expr) (entries : Array Entry) (i : Nat) : MetaM (Array Entry) 
goal: Lean.MetaM (Array Lean.Meta.GeneralizeTelescope.Entry)

full_name: Lean.Meta.GeneralizeTelescope.generalizeTelescopeAux
code: partial def generalizeTelescopeAux {α} (k : Array Expr → MetaM α)
    (entries : Array Entry) (i : Nat) (fvars : Array Expr) : MetaM α 
goal: Lean.MetaM α

full_name: Lean.Meta.generalizeTelescope
code: /--
  Given expressions `es := #[e_1, e_2, ..., e_n]`, execute `k` with the
  free variables `(x_1 : A_1) (x_2 : A_2 [x_1]) ... (x_n : A_n [x_1, ... x_{n-1}])`.
  Moreover,
  - type of `e_1` is definitionally equal to `A_1`,
  - type of `e_2` is definitionally equal to `A_2[e_1]`.
  - ...
  - type of `e_n` is definitionally equal to `A_n[e_1, ..., e_{n-1}]`.

  This method tries to avoid the creation of new free variables. For example, if `e_i` is a
  free variable `x_i` and it is not a let-declaration variable, and its type does not depend on
  previous `e_j`s, the method will just use `x_i`.

  The telescope `x_1 ... x_n` can be used to create lambda and forall abstractions.
  Moreover, for any type correct lambda abstraction `f` constructed using `mkForall #[x_1, ..., x_n] ...`,
  The application `f e_1 ... e_n` is also type correct.

  The `kabstract` method is used to "locate" and abstract forward dependencies.
  That is, an occurrence of `e_i` in the of `e_j` for `j > i`.

  The method checks whether the abstract types `A_i` are type correct. Here is an example
  where `generalizeTelescope` fails to create the telescope `x_1 ... x_n`.
  Assume the local context contains `(n : Nat := 10) (xs : Vec Nat n) (ys : Vec Nat 10) (h : xs = ys)`.
  Then, assume we invoke `generalizeTelescope` with `es := #[10, xs, ys, h]`
  A type error is detected when processing `h`'s type. At this point, the method had successfully produced
  ```
    (x_1 : Nat) (xs : Vec Nat n) (x_2 : Vec Nat x_1)
  ```
  and the type for the new variable abstracting `h` is `xs = x_2` which is not type correct. -/
def generalizeTelescope {α} (es : Array Expr) (k : Array Expr → MetaM α) : MetaM α 
goal: Lean.MetaM α
File: .lake/packages/lean4/src/lean/Lean/Meta/TransparencyMode.lean

full_name: Lean.Meta.TransparencyMode.hash
code: def hash : TransparencyMode → UInt64
  
goal: Lean.Meta.TransparencyMode → UInt64

full_name: Lean.Meta.TransparencyMode.«instHashable_.lake»
code: instance : Hashable TransparencyMode 
goal: Hashable Lean.Meta.TransparencyMode

full_name: Lean.Meta.TransparencyMode.lt
code: def lt : TransparencyMode → TransparencyMode → Bool
  
goal: Lean.Meta.TransparencyMode → Lean.Meta.TransparencyMode → Bool
File: .lake/packages/lean4/src/lean/Lean/Meta/ACLt.lean

full_name: Lean.Expr.ctorWeight
code: def Expr.ctorWeight : Expr → UInt8
  
goal: Lean.Expr → UInt8

full_name: Lean.Meta.ACLt.ReduceMode
code: inductive ReduceMode where
  | reduce
  | reduceSimpleOnly
  | none
goal: Type

full_name: Lean.Meta.ACLt.ReduceMode.none
code: inductive ReduceMode where
  | reduce
  | reduceSimpleOnly
  | none
goal: Lean.Meta.ACLt.ReduceMode

full_name: Lean.Meta.ACLt.ReduceMode.reduceSimpleOnly
code: inductive ReduceMode where
  | reduce
  | reduceSimpleOnly
  | none
goal: Lean.Meta.ACLt.ReduceMode

full_name: Lean.Meta.ACLt.ReduceMode.reduce
code: inductive ReduceMode where
  | reduce
  | reduceSimpleOnly
  | none
goal: Lean.Meta.ACLt.ReduceMode

full_name: Lean.Meta.acLt
code: @[inherit_doc ACLt.main]
def acLt (a b : Expr) (mode : ACLt.ReduceMode := .none) : MetaM Bool 
goal: Lean.MetaM Bool
File: .lake/packages/lean4/src/lean/Lean/Meta/KAbstract.lean

full_name: Lean.Meta.kabstract.visit
code: /--
Abstract occurrences of `p` in `e`. We detect subterms equivalent to `p` using key-matching.
That is, only perform `isDefEq` tests when the head symbol of substerm is equivalent to head symbol of `p`.

By default, all occurrences are abstracted,
but this behavior can be controlled using the `occs` parameter.

All matches of `p` in `e` are considered for occurrences,
but for each match that is included by the `occs` parameter,
metavariables appearing in `p` (or `e`) may become instantiated,
affecting the possibility of subsequent matches.
For matches that are not included in the `occs` parameter, the metavariable context is rolled back
to prevent blocking subsequent matches which require different instantiations.
-/
def kabstract (e : Expr) (p : Expr) (occs : Occurrences := .all) : MetaM Expr 
goal: StateRefT' IO.RealWorld Nat Lean.MetaM Lean.Expr

full_name: Lean.Meta.kabstract
code: /--
Abstract occurrences of `p` in `e`. We detect subterms equivalent to `p` using key-matching.
That is, only perform `isDefEq` tests when the head symbol of substerm is equivalent to head symbol of `p`.

By default, all occurrences are abstracted,
but this behavior can be controlled using the `occs` parameter.

All matches of `p` in `e` are considered for occurrences,
but for each match that is included by the `occs` parameter,
metavariables appearing in `p` (or `e`) may become instantiated,
affecting the possibility of subsequent matches.
For matches that are not included in the `occs` parameter, the metavariable context is rolled back
to prevent blocking subsequent matches which require different instantiations.
-/
def kabstract (e : Expr) (p : Expr) (occs : Occurrences := .all) : MetaM Expr 
goal: Lean.MetaM Lean.Expr