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

full_name: Aesop.RuleTacInput.patternInstantiations
code: /--
Input for a rule tactic. Contains:

- `goal`: the goal on which the rule is run.
- `mvars`: the set of mvars which occur in `goal`.
- `indexMatchLocations`: if the rule is indexed, the locations (e.g. hyps or the
  target) matched by the rule's index entries. Otherwise an empty set.
- `patternInstantiations`: if the rule has a pattern, the pattern instantiations
  that were found in the goal. Each instantiation is a list of expressions which
  were found by matching the pattern against expressions in the goal. For
  example, if `h : max a b = max a c` appears in the goal and the rule has
  pattern `max x y`, there will be two pattern instantiations `[a, b]`
  (representing the substitution `{x ↦ a, y ↦ b}`) and `[a, c]`. If the rule
  does not have a pattern, `patternInstantiations` is empty; otherwise it's
  guaranteed to be non-empty.
- `options`: the options given to Aesop.
-/
structure RuleTacInput where
  goal : MVarId
  mvars : UnorderedArraySet MVarId
  indexMatchLocations : HashSet IndexMatchLocation
  patternInstantiations : HashSet RulePatternInstantiation
  options : Options'
  deriving Inhabited
goal: Lean.HashSet Aesop.RulePatternInstantiation

full_name: Aesop.RuleTacInput.goal
code: /--
Input for a rule tactic. Contains:

- `goal`: the goal on which the rule is run.
- `mvars`: the set of mvars which occur in `goal`.
- `indexMatchLocations`: if the rule is indexed, the locations (e.g. hyps or the
  target) matched by the rule's index entries. Otherwise an empty set.
- `patternInstantiations`: if the rule has a pattern, the pattern instantiations
  that were found in the goal. Each instantiation is a list of expressions which
  were found by matching the pattern against expressions in the goal. For
  example, if `h : max a b = max a c` appears in the goal and the rule has
  pattern `max x y`, there will be two pattern instantiations `[a, b]`
  (representing the substitution `{x ↦ a, y ↦ b}`) and `[a, c]`. If the rule
  does not have a pattern, `patternInstantiations` is empty; otherwise it's
  guaranteed to be non-empty.
- `options`: the options given to Aesop.
-/
structure RuleTacInput where
  goal : MVarId
  mvars : UnorderedArraySet MVarId
  indexMatchLocations : HashSet IndexMatchLocation
  patternInstantiations : HashSet RulePatternInstantiation
  options : Options'
  deriving Inhabited
goal: Lean.MVarId

full_name: Aesop.RuleTacInput.options
code: /--
Input for a rule tactic. Contains:

- `goal`: the goal on which the rule is run.
- `mvars`: the set of mvars which occur in `goal`.
- `indexMatchLocations`: if the rule is indexed, the locations (e.g. hyps or the
  target) matched by the rule's index entries. Otherwise an empty set.
- `patternInstantiations`: if the rule has a pattern, the pattern instantiations
  that were found in the goal. Each instantiation is a list of expressions which
  were found by matching the pattern against expressions in the goal. For
  example, if `h : max a b = max a c` appears in the goal and the rule has
  pattern `max x y`, there will be two pattern instantiations `[a, b]`
  (representing the substitution `{x ↦ a, y ↦ b}`) and `[a, c]`. If the rule
  does not have a pattern, `patternInstantiations` is empty; otherwise it's
  guaranteed to be non-empty.
- `options`: the options given to Aesop.
-/
structure RuleTacInput where
  goal : MVarId
  mvars : UnorderedArraySet MVarId
  indexMatchLocations : HashSet IndexMatchLocation
  patternInstantiations : HashSet RulePatternInstantiation
  options : Options'
  deriving Inhabited
goal: Aesop.Options'

full_name: Aesop.RuleTacInput
code: /--
Input for a rule tactic. Contains:

- `goal`: the goal on which the rule is run.
- `mvars`: the set of mvars which occur in `goal`.
- `indexMatchLocations`: if the rule is indexed, the locations (e.g. hyps or the
  target) matched by the rule's index entries. Otherwise an empty set.
- `patternInstantiations`: if the rule has a pattern, the pattern instantiations
  that were found in the goal. Each instantiation is a list of expressions which
  were found by matching the pattern against expressions in the goal. For
  example, if `h : max a b = max a c` appears in the goal and the rule has
  pattern `max x y`, there will be two pattern instantiations `[a, b]`
  (representing the substitution `{x ↦ a, y ↦ b}`) and `[a, c]`. If the rule
  does not have a pattern, `patternInstantiations` is empty; otherwise it's
  guaranteed to be non-empty.
- `options`: the options given to Aesop.
-/
structure RuleTacInput where
  goal : MVarId
  mvars : UnorderedArraySet MVarId
  indexMatchLocations : HashSet IndexMatchLocation
  patternInstantiations : HashSet RulePatternInstantiation
  options : Options'
  deriving Inhabited
goal: Type

full_name: Aesop.instInhabitedRuleTacInput
code: /--
Input for a rule tactic. Contains:

- `goal`: the goal on which the rule is run.
- `mvars`: the set of mvars which occur in `goal`.
- `indexMatchLocations`: if the rule is indexed, the locations (e.g. hyps or the
  target) matched by the rule's index entries. Otherwise an empty set.
- `patternInstantiations`: if the rule has a pattern, the pattern instantiations
  that were found in the goal. Each instantiation is a list of expressions which
  were found by matching the pattern against expressions in the goal. For
  example, if `h : max a b = max a c` appears in the goal and the rule has
  pattern `max x y`, there will be two pattern instantiations `[a, b]`
  (representing the substitution `{x ↦ a, y ↦ b}`) and `[a, c]`. If the rule
  does not have a pattern, `patternInstantiations` is empty; otherwise it's
  guaranteed to be non-empty.
- `options`: the options given to Aesop.
-/
structure RuleTacInput where
  goal : MVarId
  mvars : UnorderedArraySet MVarId
  indexMatchLocations : HashSet IndexMatchLocation
  patternInstantiations : HashSet RulePatternInstantiation
  options : Options'
  deriving Inhabited
goal: Inhabited Aesop.RuleTacInput

full_name: Aesop.RuleTacInput.mvars
code: /--
Input for a rule tactic. Contains:

- `goal`: the goal on which the rule is run.
- `mvars`: the set of mvars which occur in `goal`.
- `indexMatchLocations`: if the rule is indexed, the locations (e.g. hyps or the
  target) matched by the rule's index entries. Otherwise an empty set.
- `patternInstantiations`: if the rule has a pattern, the pattern instantiations
  that were found in the goal. Each instantiation is a list of expressions which
  were found by matching the pattern against expressions in the goal. For
  example, if `h : max a b = max a c` appears in the goal and the rule has
  pattern `max x y`, there will be two pattern instantiations `[a, b]`
  (representing the substitution `{x ↦ a, y ↦ b}`) and `[a, c]`. If the rule
  does not have a pattern, `patternInstantiations` is empty; otherwise it's
  guaranteed to be non-empty.
- `options`: the options given to Aesop.
-/
structure RuleTacInput where
  goal : MVarId
  mvars : UnorderedArraySet MVarId
  indexMatchLocations : HashSet IndexMatchLocation
  patternInstantiations : HashSet RulePatternInstantiation
  options : Options'
  deriving Inhabited
goal: Aesop.UnorderedArraySet Lean.MVarId

full_name: Aesop.RuleTacInput.indexMatchLocations
code: /--
Input for a rule tactic. Contains:

- `goal`: the goal on which the rule is run.
- `mvars`: the set of mvars which occur in `goal`.
- `indexMatchLocations`: if the rule is indexed, the locations (e.g. hyps or the
  target) matched by the rule's index entries. Otherwise an empty set.
- `patternInstantiations`: if the rule has a pattern, the pattern instantiations
  that were found in the goal. Each instantiation is a list of expressions which
  were found by matching the pattern against expressions in the goal. For
  example, if `h : max a b = max a c` appears in the goal and the rule has
  pattern `max x y`, there will be two pattern instantiations `[a, b]`
  (representing the substitution `{x ↦ a, y ↦ b}`) and `[a, c]`. If the rule
  does not have a pattern, `patternInstantiations` is empty; otherwise it's
  guaranteed to be non-empty.
- `options`: the options given to Aesop.
-/
structure RuleTacInput where
  goal : MVarId
  mvars : UnorderedArraySet MVarId
  indexMatchLocations : HashSet IndexMatchLocation
  patternInstantiations : HashSet RulePatternInstantiation
  options : Options'
  deriving Inhabited
goal: Lean.HashSet Aesop.IndexMatchLocation

full_name: Aesop.RuleApplication.postState
code: /--
A single rule application, representing the application of a tactic to the input
goal. Must accurately report the following information:

- `goals`: the goals generated by the tactic.
- `postState`: the `MetaM` state after the tactic was run.
- `scriptSteps?`: script steps which produce the same effect as the rule tactic.
  If `input.options.generateScript = false` (where `input` is the
  `RuleTacInput`), this field is ignored. If the tactic does not support script
  generation, use `none`.
- `successProbability`: The success probability of this rule application. If
  `none`, we use the success probability of the applied rule.
-/
structure RuleApplication where
  goals : Array MVarId
  postState : Meta.SavedState
  scriptSteps? : Option (Array Script.LazyStep)
  successProbability? : Option Percent
goal: Lean.Meta.SavedState

full_name: Aesop.RuleApplication
code: /--
A single rule application, representing the application of a tactic to the input
goal. Must accurately report the following information:

- `goals`: the goals generated by the tactic.
- `postState`: the `MetaM` state after the tactic was run.
- `scriptSteps?`: script steps which produce the same effect as the rule tactic.
  If `input.options.generateScript = false` (where `input` is the
  `RuleTacInput`), this field is ignored. If the tactic does not support script
  generation, use `none`.
- `successProbability`: The success probability of this rule application. If
  `none`, we use the success probability of the applied rule.
-/
structure RuleApplication where
  goals : Array MVarId
  postState : Meta.SavedState
  scriptSteps? : Option (Array Script.LazyStep)
  successProbability? : Option Percent
goal: Type

full_name: Aesop.RuleApplication.goals
code: /--
A single rule application, representing the application of a tactic to the input
goal. Must accurately report the following information:

- `goals`: the goals generated by the tactic.
- `postState`: the `MetaM` state after the tactic was run.
- `scriptSteps?`: script steps which produce the same effect as the rule tactic.
  If `input.options.generateScript = false` (where `input` is the
  `RuleTacInput`), this field is ignored. If the tactic does not support script
  generation, use `none`.
- `successProbability`: The success probability of this rule application. If
  `none`, we use the success probability of the applied rule.
-/
structure RuleApplication where
  goals : Array MVarId
  postState : Meta.SavedState
  scriptSteps? : Option (Array Script.LazyStep)
  successProbability? : Option Percent
goal: Array Lean.MVarId

full_name: Aesop.RuleApplication.scriptSteps?
code: /--
A single rule application, representing the application of a tactic to the input
goal. Must accurately report the following information:

- `goals`: the goals generated by the tactic.
- `postState`: the `MetaM` state after the tactic was run.
- `scriptSteps?`: script steps which produce the same effect as the rule tactic.
  If `input.options.generateScript = false` (where `input` is the
  `RuleTacInput`), this field is ignored. If the tactic does not support script
  generation, use `none`.
- `successProbability`: The success probability of this rule application. If
  `none`, we use the success probability of the applied rule.
-/
structure RuleApplication where
  goals : Array MVarId
  postState : Meta.SavedState
  scriptSteps? : Option (Array Script.LazyStep)
  successProbability? : Option Percent
goal: Option (Array Aesop.Script.LazyStep)

full_name: Aesop.RuleApplication.successProbability?
code: /--
A single rule application, representing the application of a tactic to the input
goal. Must accurately report the following information:

- `goals`: the goals generated by the tactic.
- `postState`: the `MetaM` state after the tactic was run.
- `scriptSteps?`: script steps which produce the same effect as the rule tactic.
  If `input.options.generateScript = false` (where `input` is the
  `RuleTacInput`), this field is ignored. If the tactic does not support script
  generation, use `none`.
- `successProbability`: The success probability of this rule application. If
  `none`, we use the success probability of the applied rule.
-/
structure RuleApplication where
  goals : Array MVarId
  postState : Meta.SavedState
  scriptSteps? : Option (Array Script.LazyStep)
  successProbability? : Option Percent
goal: Option Aesop.Percent

full_name: Aesop.RuleApplication.check
code: def check (r : RuleApplication) : MetaM (Option MessageData) 
goal: Lean.MetaM (Option Lean.MessageData)

full_name: Aesop.RuleApplication.ofLazyScriptStep
code: def ofLazyScriptStep (step : Script.LazyStep)
    (successProbability? : Option Percent) : RuleApplication 
goal: Aesop.RuleApplication

full_name: Aesop.RuleTacOutput.applications
code: /--
The result of a rule tactic is a list of rule applications.
-/
structure RuleTacOutput where
  applications : Array RuleApplication
  deriving Inhabited
goal: Array Aesop.RuleApplication

full_name: Aesop.instInhabitedRuleTacOutput
code: /--
The result of a rule tactic is a list of rule applications.
-/
structure RuleTacOutput where
  applications : Array RuleApplication
  deriving Inhabited
goal: Inhabited Aesop.RuleTacOutput

full_name: Aesop.RuleTacOutput
code: /--
The result of a rule tactic is a list of rule applications.
-/
structure RuleTacOutput where
  applications : Array RuleApplication
  deriving Inhabited
goal: Type

full_name: Aesop.RuleTac
code: /--
A `RuleTac` is the tactic that is run when a rule is applied to a goal.
-/
def RuleTac 
goal: Type

full_name: Aesop.instInhabitedRuleTac
code: instance : Inhabited RuleTac 
goal: Inhabited Aesop.RuleTac

full_name: Aesop.SingleRuleTac
code: /--
A `RuleTac` which generates only a single `RuleApplication`.
-/
def SingleRuleTac 
goal: Type

full_name: Aesop.SingleRuleTac.toRuleTac
code: @[inline]
def SingleRuleTac.toRuleTac (t : SingleRuleTac) : RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.ofSingleRuleTac
code: @[inline]
def RuleTac.ofSingleRuleTac 
goal: Aesop.RuleTac

full_name: Aesop.TacGen
code: /--
A tactic generator is a special sort of rule tactic, intended for use with
generative machine learning methods. It generates zero or more tactics
(represented as strings) that could be applied to the goal, plus a success
probability for each tactic. When Aesop executes a tactic generator, it executes
each of the tactics and, if the tactic succeeds, adds a rule application for it.
The tactic's success probability (which must be between 0 and 1, inclusive)
becomes the success probability of the rule application. A `TacGen` rule
succeeds if at least one of its suggested tactics succeeds.
-/
abbrev TacGen 
goal: Type

full_name: Aesop.CasesPattern
code: def CasesPattern 
goal: Type

full_name: Aesop.CasesTarget
code: inductive CasesTarget
  | decl (decl : Name)
  | patterns (patterns : Array CasesPattern)
  deriving Inhabited
goal: Type

full_name: Aesop.CasesTarget.decl
code: inductive CasesTarget
  | decl (decl : Name)
  | patterns (patterns : Array CasesPattern)
  deriving Inhabited
goal: Aesop.CasesTarget

full_name: Aesop.instInhabitedCasesTarget
code: inductive CasesTarget
  | decl (decl : Name)
  | patterns (patterns : Array CasesPattern)
  deriving Inhabited
goal: Inhabited Aesop.CasesTarget

full_name: Aesop.CasesTarget.patterns
code: inductive CasesTarget
  | decl (decl : Name)
  | patterns (patterns : Array CasesPattern)
  deriving Inhabited
goal: Aesop.CasesTarget

full_name: Aesop.RuleTerm.const
code: inductive RuleTerm
  | const (decl : Name)
  | term (term : Term)
goal: Aesop.RuleTerm

full_name: Aesop.RuleTerm.term
code: inductive RuleTerm
  | const (decl : Name)
  | term (term : Term)
goal: Aesop.RuleTerm

full_name: Aesop.RuleTerm
code: inductive RuleTerm
  | const (decl : Name)
  | term (term : Term)
goal: Type

full_name: Aesop.RuleTacDescr.apply
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Aesop.RuleTacDescr

full_name: Aesop.RuleTacDescr.ruleTac
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Aesop.RuleTacDescr

full_name: Aesop.RuleTacDescr.tacticStx
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Aesop.RuleTacDescr

full_name: Aesop.RuleTacDescr.cases
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Aesop.RuleTacDescr

full_name: Aesop.RuleTacDescr
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Type

full_name: Aesop.RuleTacDescr.forward
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Aesop.RuleTacDescr

full_name: Aesop.RuleTacDescr.tacGen
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Aesop.RuleTacDescr

full_name: Aesop.RuleTacDescr.constructors
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Aesop.RuleTacDescr

full_name: Aesop.RuleTacDescr.tacticM
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Aesop.RuleTacDescr

full_name: Aesop.RuleTacDescr.preprocess
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Aesop.RuleTacDescr

full_name: Aesop.RuleTacDescr.singleRuleTac
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Aesop.RuleTacDescr

full_name: Aesop.instInhabitedRuleTacDescr
code: inductive RuleTacDescr
  | apply (term : RuleTerm) (md : TransparencyMode) (pat? : Option RulePattern)
  | constructors (constructorNames : Array Name) (md : TransparencyMode)
  | forward (term : RuleTerm) (pat? : Option RulePattern)
      (immediate : UnorderedArraySet Nat) (isDestruct : Bool)
      (md : TransparencyMode)
  | cases (target : CasesTarget) (md : TransparencyMode)
      (isRecursiveType : Bool) (ctorNames : Array CtorNames)
  | tacticM (decl : Name)
  | ruleTac (decl : Name)
  | tacGen (decl : Name)
  | singleRuleTac (decl : Name)
  | tacticStx (stx : Syntax)
  | preprocess
  deriving Inhabited
goal: Inhabited Aesop.RuleTacDescr