File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Induction.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getFirstAltLhs
code: private def getFirstAltLhs (alt : Syntax) : Syntax 
goal: Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getAltName
code: /-- Return `inductionAlt` name. It assumes `alt` does not have multiple `inductionAltLHS` -/
private def getAltName (alt : Syntax) : Name 
goal: Lean.Name

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getAltNameStx
code: /-- Returns the `inductionAlt` `ident <|> hole` -/
private def getAltNameStx (alt : Syntax) : Syntax 
goal: Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.altHasExplicitModifier
code: /-- Return `true` if the first LHS of the given alternative contains `@`. -/
private def altHasExplicitModifier (alt : Syntax) : Bool 
goal: Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getAltVars
code: /-- Return the variables in the first LHS of the given alternative. -/
private def getAltVars (alt : Syntax) : Array Syntax 
goal: Array Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getAltRHS
code: private def getAltRHS (alt : Syntax) : Syntax 
goal: Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getAltDArrow
code: private def getAltDArrow (alt : Syntax) : Syntax 
goal: Lean.Syntax

full_name: Lean.Elab.Tactic.isHoleRHS
code: def isHoleRHS (rhs : Syntax) : Bool 
goal: Bool

full_name: Lean.Elab.Tactic.evalAlt
code: def evalAlt (mvarId : MVarId) (alt : Syntax) (addInfo : TermElabM Unit) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.ElimApp.Alt
code: structure Alt where
  /-- The short name of the alternative, used in `| foo =>` cases -/
  name      : Name
  info      : ElimAltInfo
  /-- The subgoal metavariable for the alternative. -/
  mvarId    : MVarId
  deriving Inhabited
goal: Type

full_name: Lean.Elab.Tactic.ElimApp.Alt.info
code: structure Alt where
  /-- The short name of the alternative, used in `| foo =>` cases -/
  name      : Name
  info      : ElimAltInfo
  /-- The subgoal metavariable for the alternative. -/
  mvarId    : MVarId
  deriving Inhabited
goal: Lean.Meta.ElimAltInfo

full_name: Lean.Elab.Tactic.ElimApp.instInhabitedAlt
code: structure Alt where
  /-- The short name of the alternative, used in `| foo =>` cases -/
  name      : Name
  info      : ElimAltInfo
  /-- The subgoal metavariable for the alternative. -/
  mvarId    : MVarId
  deriving Inhabited
goal: Inhabited Lean.Elab.Tactic.ElimApp.Alt

full_name: Lean.Elab.Tactic.ElimApp.Alt.mvarId
code: structure Alt where
  /-- The short name of the alternative, used in `| foo =>` cases -/
  name      : Name
  info      : ElimAltInfo
  /-- The subgoal metavariable for the alternative. -/
  mvarId    : MVarId
  deriving Inhabited
goal: Lean.MVarId

full_name: Lean.Elab.Tactic.ElimApp.Alt.name
code: structure Alt where
  /-- The short name of the alternative, used in `| foo =>` cases -/
  name      : Name
  info      : ElimAltInfo
  /-- The subgoal metavariable for the alternative. -/
  mvarId    : MVarId
  deriving Inhabited
goal: Lean.Name

full_name: Lean.Elab.Tactic.ElimApp.Context.targets
code: structure Context where
  elimInfo : ElimInfo
  targets  : Array Expr
goal: Array Lean.Expr

full_name: Lean.Elab.Tactic.ElimApp.Context.elimInfo
code: structure Context where
  elimInfo : ElimInfo
  targets  : Array Expr
goal: Lean.Meta.ElimInfo

full_name: Lean.Elab.Tactic.ElimApp.Context
code: structure Context where
  elimInfo : ElimInfo
  targets  : Array Expr
goal: Type

full_name: Lean.Elab.Tactic.ElimApp.State
code: structure State where
  argPos    : Nat := 0 -- current argument position
  targetPos : Nat := 0 -- current target at targetsStx
  motive    : Option MVarId -- motive metavariable
  f         : Expr
  fType     : Expr
  alts      : Array Alt := #[]
  insts     : Array MVarId := #[]
goal: Type

full_name: Lean.Elab.Tactic.ElimApp.State.alts
code: structure State where
  argPos    : Nat := 0 -- current argument position
  targetPos : Nat := 0 -- current target at targetsStx
  motive    : Option MVarId -- motive metavariable
  f         : Expr
  fType     : Expr
  alts      : Array Alt := #[]
  insts     : Array MVarId := #[]
goal: Array Lean.Elab.Tactic.ElimApp.Alt

full_name: Lean.Elab.Tactic.ElimApp.State.argPos
code: structure State where
  argPos    : Nat := 0 -- current argument position
  targetPos : Nat := 0 -- current target at targetsStx
  motive    : Option MVarId -- motive metavariable
  f         : Expr
  fType     : Expr
  alts      : Array Alt := #[]
  insts     : Array MVarId := #[]
goal: Nat

full_name: Lean.Elab.Tactic.ElimApp.State.f
code: structure State where
  argPos    : Nat := 0 -- current argument position
  targetPos : Nat := 0 -- current target at targetsStx
  motive    : Option MVarId -- motive metavariable
  f         : Expr
  fType     : Expr
  alts      : Array Alt := #[]
  insts     : Array MVarId := #[]
goal: Lean.Expr

full_name: Lean.Elab.Tactic.ElimApp.State.fType
code: structure State where
  argPos    : Nat := 0 -- current argument position
  targetPos : Nat := 0 -- current target at targetsStx
  motive    : Option MVarId -- motive metavariable
  f         : Expr
  fType     : Expr
  alts      : Array Alt := #[]
  insts     : Array MVarId := #[]
goal: Lean.Expr

full_name: Lean.Elab.Tactic.ElimApp.State.targetPos
code: structure State where
  argPos    : Nat := 0 -- current argument position
  targetPos : Nat := 0 -- current target at targetsStx
  motive    : Option MVarId -- motive metavariable
  f         : Expr
  fType     : Expr
  alts      : Array Alt := #[]
  insts     : Array MVarId := #[]
goal: Nat

full_name: Lean.Elab.Tactic.ElimApp.State.motive
code: structure State where
  argPos    : Nat := 0 -- current argument position
  targetPos : Nat := 0 -- current target at targetsStx
  motive    : Option MVarId -- motive metavariable
  f         : Expr
  fType     : Expr
  alts      : Array Alt := #[]
  insts     : Array MVarId := #[]
goal: Option Lean.MVarId

full_name: Lean.Elab.Tactic.ElimApp.State.insts
code: structure State where
  argPos    : Nat := 0 -- current argument position
  targetPos : Nat := 0 -- current target at targetsStx
  motive    : Option MVarId -- motive metavariable
  f         : Expr
  fType     : Expr
  alts      : Array Alt := #[]
  insts     : Array MVarId := #[]
goal: Array Lean.MVarId

full_name: Lean.Elab.Tactic.ElimApp.M
code: abbrev M 
goal: Type

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.addNewArg
code: private def addNewArg (arg : Expr) : M Unit 
goal: Lean.Elab.Tactic.ElimApp.M Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.getBindingName
code: /-- Return the binder name at `fType`. This method assumes `fType` is a function type. -/
private def getBindingName : M Name 
goal: Lean.Elab.Tactic.ElimApp.M Lean.Name

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.getArgExpectedType
code: /-- Return the next argument expected type. This method assumes `fType` is a function type. -/
private def getArgExpectedType : M Expr 
goal: Lean.Elab.Tactic.ElimApp.M Lean.Expr

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.getFType
code: private def getFType : M Expr 
goal: Lean.Elab.Tactic.ElimApp.M Lean.Expr

full_name: Lean.Elab.Tactic.ElimApp.Result.elimApp
code: structure Result where
  elimApp : Expr
  motive  : MVarId
  alts    : Array Alt := #[]
  others  : Array MVarId := #[]
goal: Lean.Expr

full_name: Lean.Elab.Tactic.ElimApp.Result
code: structure Result where
  elimApp : Expr
  motive  : MVarId
  alts    : Array Alt := #[]
  others  : Array MVarId := #[]
goal: Type

full_name: Lean.Elab.Tactic.ElimApp.Result.motive
code: structure Result where
  elimApp : Expr
  motive  : MVarId
  alts    : Array Alt := #[]
  others  : Array MVarId := #[]
goal: Lean.MVarId

full_name: Lean.Elab.Tactic.ElimApp.Result.alts
code: structure Result where
  elimApp : Expr
  motive  : MVarId
  alts    : Array Alt := #[]
  others  : Array MVarId := #[]
goal: Array Lean.Elab.Tactic.ElimApp.Alt

full_name: Lean.Elab.Tactic.ElimApp.Result.others
code: structure Result where
  elimApp : Expr
  motive  : MVarId
  alts    : Array Alt := #[]
  others  : Array MVarId := #[]
goal: Array Lean.MVarId

full_name: Lean.Elab.Tactic.ElimApp.mkElimApp
code: /--
  Construct the an eliminator/recursor application. `targets` contains the explicit and implicit targets for
  the eliminator. For example, the indices of builtin recursors are considered implicit targets.
  Remark: the method `addImplicitTargets` may be used to compute the sequence of implicit and explicit targets
  from the explicit ones.
-/
partial def mkElimApp (elimInfo : ElimInfo) (targets : Array Expr) (tag : Name) : TermElabM Result 
goal: Lean.Elab.TermElabM Lean.Elab.Tactic.ElimApp.Result

full_name: Lean.Elab.Tactic.ElimApp.mkElimApp.loop
code: /--
  Construct the an eliminator/recursor application. `targets` contains the explicit and implicit targets for
  the eliminator. For example, the indices of builtin recursors are considered implicit targets.
  Remark: the method `addImplicitTargets` may be used to compute the sequence of implicit and explicit targets
  from the explicit ones.
-/
partial def mkElimApp (elimInfo : ElimInfo) (targets : Array Expr) (tag : Name) : TermElabM Result 
goal: Lean.Elab.Tactic.ElimApp.M Unit

full_name: Lean.Elab.Tactic.ElimApp.setMotiveArg
code: /-- Given a goal `... targets ... |- C[targets]` associated with `mvarId`, assign
  `motiveArg := fun targets => C[targets]` -/
def setMotiveArg (mvarId : MVarId) (motiveArg : MVarId) (targets : Array FVarId) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.getAltNumFields
code: private def getAltNumFields (elimInfo : ElimInfo) (altName : Name) : TermElabM Nat 
goal: Lean.Elab.TermElabM Nat

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.isWildcard
code: private def isWildcard (altStx : Syntax) : Bool 
goal: Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.checkAltNames
code: private def checkAltNames (alts : Array Alt) (altsSyntax : Array Syntax) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.getNumExplicitFields
code: /-- Given the goal `altMVarId` for a given alternative that introduces `numFields` new variables,
    return the number of explicit variables. Recall that when the `@` is not used, only the explicit variables can
    be named by the user. -/
private def getNumExplicitFields (altMVarId : MVarId) (numFields : Nat) : MetaM Nat 
goal: Lean.MetaM Nat

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.saveAltVarsInfo
code: private def saveAltVarsInfo (altMVarId : MVarId) (altStx : Syntax) (fvarIds : Array FVarId) : TermElabM Unit 
goal: Lean.Elab.TermElabM Unit

full_name: Lean.Elab.Tactic.ElimApp.evalAlts.applyAltStx
code: def evalAlts (elimInfo : ElimInfo) (alts : Array Alt) (optPreTac : Syntax) (altStxs : Array Syntax)
    (initialInfo : Info)
    (numEqs : Nat := 0) (numGeneralized : Nat := 0) (toClear : Array FVarId := #[])
    (toTag : Array (Ident × FVarId) := #[]) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM PUnit

full_name: Lean.Elab.Tactic.ElimApp.evalAlts
code: def evalAlts (elimInfo : ElimInfo) (alts : Array Alt) (optPreTac : Syntax) (altStxs : Array Syntax)
    (initialInfo : Info)
    (numEqs : Nat := 0) (numGeneralized : Nat := 0) (toClear : Array FVarId := #[])
    (toTag : Array (Ident × FVarId) := #[]) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.ElimApp.evalAlts.goWithIncremental
code: def evalAlts (elimInfo : ElimInfo) (alts : Array Alt) (optPreTac : Syntax) (altStxs : Array Syntax)
    (initialInfo : Info)
    (numEqs : Nat := 0) (numGeneralized : Nat := 0) (toClear : Array FVarId := #[])
    (toTag : Array (Ident × FVarId) := #[]) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM PUnit

full_name: Lean.Elab.Tactic.ElimApp.evalAlts.goWithInfo
code: def evalAlts (elimInfo : ElimInfo) (alts : Array Alt) (optPreTac : Syntax) (altStxs : Array Syntax)
    (initialInfo : Info)
    (numEqs : Nat := 0) (numGeneralized : Nat := 0) (toClear : Array FVarId := #[])
    (toTag : Array (Ident × FVarId) := #[]) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.ElimApp.evalAlts.applyPreTac
code: def evalAlts (elimInfo : ElimInfo) (alts : Array Alt) (optPreTac : Syntax) (altStxs : Array Syntax)
    (initialInfo : Info)
    (numEqs : Nat := 0) (numGeneralized : Nat := 0) (toClear : Array FVarId := #[])
    (toTag : Array (Ident × FVarId) := #[]) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM (List Lean.MVarId)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getUserGeneralizingFVarIds
code: private def getUserGeneralizingFVarIds (stx : Syntax) : TacticM (Array FVarId) 
goal: Lean.Elab.Tactic.TacticM (Array Lean.FVarId)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.generalizeVars
code: private def generalizeVars (mvarId : MVarId) (stx : Syntax) (targets : Array Expr) : TacticM (Nat × MVarId) 
goal: Lean.Elab.Tactic.TacticM (Nat × Lean.MVarId)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getAltsOfInductionAlts
code: /--
Given `inductionAlts` of the form
```
syntax inductionAlts := "with " (tactic)? withPosition( (colGe inductionAlt)+)
```
Return an array containing its alternatives.
-/
private def getAltsOfInductionAlts (inductionAlts : Syntax) : Array Syntax 
goal: Array Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.withAltsOfOptInductionAlts
code: /--
Given `inductionAlts` of the form
```
syntax inductionAlts := "with " (tactic)? withPosition( (colGe inductionAlt)+)
```
runs `cont alts` where `alts` is an array containing all `inductionAlt`s while disabling incremental
reuse if any other syntax changed.
-/
private def withAltsOfOptInductionAlts (optInductionAlts : Syntax)
    (cont : Array Syntax → TacticM α) : TacticM α 
goal: Lean.Elab.Tactic.TacticM α

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getOptPreTacOfOptInductionAlts
code: private def getOptPreTacOfOptInductionAlts (optInductionAlts : Syntax) : Syntax 
goal: Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.isMultiAlt
code: private def isMultiAlt (alt : Syntax) : Bool 
goal: Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.expandMultiAlt?
code: /-- Return `some #[alt_1, ..., alt_n]` if `alt` has multiple LHSs. -/
private def expandMultiAlt? (alt : Syntax) : Option (Array Syntax) 
goal: Option (Array Lean.Syntax)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.expandInductionAlts?
code: /--
Given `inductionAlts` of the form
```
syntax inductionAlts := "with " (tactic)? withPosition( (colGe inductionAlt)+)
```
Return `some inductionAlts'` if one of the alternatives have multiple LHSs, in the new `inductionAlts'`
all alternatives have a single LHS.

Remark: the `RHS` of alternatives with multi LHSs is copied.
-/
private def expandInductionAlts? (inductionAlts : Syntax) : Option Syntax 
goal: Option Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.expandInduction?
code: /--
Expand
```
syntax "induction " term,+ (" using " ident)?  ("generalizing " (colGt term:max)+)? (inductionAlts)? : tactic
```
if `inductionAlts` has an alternative with multiple LHSs.
-/
private def expandInduction? (induction : Syntax) : Option Syntax 
goal: Option Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.expandCases?
code: /--
Expand
```
syntax "cases " casesTarget,+ (" using " ident)? (inductionAlts)? : tactic
```
if `inductionAlts` has an alternative with multiple LHSs.
-/
private def expandCases? (induction : Syntax) : Option Syntax 
goal: Option Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.checkAltsOfOptInductionAlts
code: /--
  We may have at most one `| _ => ...` (wildcard alternative), and it must not set variable names.
  The idea is to make sure users do not write unstructured tactics. -/
private def checkAltsOfOptInductionAlts (optInductionAlts : Syntax) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.getInductiveValFromMajor
code: def getInductiveValFromMajor (major : Expr) : TacticM InductiveVal 
goal: Lean.Elab.Tactic.TacticM Lean.InductiveVal

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.elabTermForElim
code: /--
Elaborates the term in the `using` clause. We want to allow parameters to be instantiated
(e.g. `using foo (p := …)`), but preserve other paramters, like the motives, as parameters,
without turning them into MVars. So this uses `abstractMVars` at the end. This is inspired by
`Lean.Elab.Tactic.addSimpTheorem`.

It also elaborates without `heedElabAsElim` so that users can use constants that are marked
`elabAsElim` in the `using` clause`.
-/
private def elabTermForElim (stx : Syntax) : TermElabM Expr 
goal: Lean.Elab.TermElabM Lean.Expr

full_name: Lean.Elab.Tactic.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Tactic.Induction._hyg.7767
code: register_builtin_option tactic.customEliminators : Bool := {
  defValue := true
  group    := "tactic"
  descr    := "enable using custom eliminators in the 'induction' and 'cases' tactics \
    defined using the '@[induction_eliminator]' and '@[cases_eliminator]' attributes"
}
goal: IO (Lean.Option Bool)

full_name: Lean.Elab.Tactic.tactic.customEliminators
code: register_builtin_option tactic.customEliminators : Bool := {
  defValue := true
  group    := "tactic"
  descr    := "enable using custom eliminators in the 'induction' and 'cases' tactics \
    defined using the '@[induction_eliminator]' and '@[cases_eliminator]' attributes"
}
goal: Lean.Option Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getElimNameInfo
code: private def getElimNameInfo (optElimId : Syntax) (targets : Array Expr) (induction : Bool) : TacticM ElimInfo 
goal: Lean.Elab.Tactic.TacticM Lean.Meta.ElimInfo

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.shouldGeneralizeTarget
code: private def shouldGeneralizeTarget (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.generalizeTargets
code: private def generalizeTargets (exprs : Array Expr) : TacticM (Array Expr) 
goal: Lean.Elab.Tactic.TacticM (Array Lean.Expr)

full_name: Lean.Elab.Tactic.evalInduction.checkTargets
code: @[builtin_tactic Lean.Parser.Tactic.induction, builtin_incremental]
def evalInduction : Tactic 
goal: Lean.MetaM Unit

full_name: Lean.Elab.Tactic.evalInduction
code: @[builtin_tactic Lean.Parser.Tactic.induction, builtin_incremental]
def evalInduction : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.elabCasesTargets
code: def elabCasesTargets (targets : Array Syntax) : TacticM (Array Expr × Array (Ident × FVarId)) 
goal: Lean.Elab.Tactic.TacticM (Array Lean.Expr × Array (Lean.Ident × Lean.FVarId))

full_name: Lean.Elab.Tactic.evalCases
code: @[builtin_tactic Lean.Parser.Tactic.cases, builtin_incremental]
def evalCases : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Tactic.Induction._hyg.10753
code: builtin_initialize
  registerTraceClass `Elab.cases
  registerTraceClass `Elab.induction
goal: IO Unit