ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Tactic/AdaptationNote.lean

full_name: initFn._@.Mathlib.Tactic.AdaptationNote._hyg.5
code: initialize registerTraceClass `adaptationNote
goal: IO Unit

full_name: reportAdaptationNote
code: /-- General function implementing adaptation notes. -/
def reportAdaptationNote (f : Syntax → Meta.Tactic.TryThis.Suggestion) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: _aux_Mathlib_Tactic_AdaptationNote___elabRules_adaptationNoteCmd_1
code: /-- Adaptation notes are comments that are used to indicate that a piece of code
has been changed to accomodate a change in Lean core.
They typically require further action/maintenance to be taken in the future. -/
elab (name := adaptationNoteCmd) "#adaptation_note " (docComment)? : command => do
  Elab.Command.liftTermElabM <| reportAdaptationNote (fun s => (⟨s⟩ : TSyntax `tactic))
goal: Lean.Elab.Command.CommandElab

full_name: adaptationNoteCmd
code: /-- Adaptation notes are comments that are used to indicate that a piece of code
has been changed to accomodate a change in Lean core.
They typically require further action/maintenance to be taken in the future. -/
elab (name := adaptationNoteCmd) "#adaptation_note " (docComment)? : command => do
  Elab.Command.liftTermElabM <| reportAdaptationNote (fun s => (⟨s⟩ : TSyntax `tactic))
goal: Lean.ParserDescr

full_name: «tactic#adaptation_note_»
code: @[inherit_doc adaptationNoteCmd]
elab "#adaptation_note " (docComment)? : tactic =>
  reportAdaptationNote (fun s => (⟨s⟩ : TSyntax `tactic))
goal: Lean.ParserDescr

full_name: «_aux_Mathlib_Tactic_AdaptationNote___elabRules_tactic#adaptation_note__1»
code: @[inherit_doc adaptationNoteCmd]
elab "#adaptation_note " (docComment)? : tactic =>
  reportAdaptationNote (fun s => (⟨s⟩ : TSyntax `tactic))
goal: Lean.Elab.Tactic.Tactic

full_name: adaptationNoteTermStx
code: @[inherit_doc adaptationNoteCmd]
syntax (name := adaptationNoteTermStx) "#adaptation_note " (docComment)? term : term
goal: Lean.ParserDescr

full_name: adaptationNoteTermElab
code: /-- Elaborator for adaptation notes. -/
@[term_elab adaptationNoteTermStx]
def adaptationNoteTermElab : Elab.Term.TermElab
  
goal: Lean.Elab.Term.TermElab
File: Mathlib/Tactic/PPWithUniv.lean

full_name: Mathlib.PPWithUniv.delabWithUniv
code: /--
Delaborator that prints the current application with universe parameters on the head symbol,
unless `pp.universes` is explicitly set to `false`.
-/
def delabWithUniv : Delab 
goal: Lean.PrettyPrinter.Delaborator.Delab

full_name: Mathlib.PPWithUniv.ppWithUnivAttr
code: /--
`attribute [pp_with_univ] Ordinal` instructs the pretty-printer to
print `Ordinal.{u}` with universe parameters by default
(unless `pp.universes` is explicitly set to `false`).
-/
syntax (name := ppWithUnivAttr) "pp_with_univ" : attr
goal: Lean.ParserDescr

full_name: Mathlib.PPWithUniv.initFn._@.Mathlib.Tactic.PPWithUniv._hyg.64
code: initialize registerBuiltinAttribute {
  name := `ppWithUnivAttr
  descr := ""
  applicationTime := .afterCompilation
  add := fun src ref kind => match ref with
  | `(attr| pp_with_univ) => do
    liftCommandElabM <| withRef ref do
      let attr ← Elab.elabAttr <| ← `(Term.attrInstance| delab $(mkIdent <| `app ++ src))
      liftTermElabM <| Term.applyAttributes ``delabWithUniv #[{attr with kind}]
  | _ => throwUnsupportedSyntax }
goal: IO Unit
File: Mathlib/Tactic/SwapVar.lean

full_name: Mathlib.Tactic.swapRule
code: /-- The parser for swap rules -/
syntax swapRule := ident " ↔"? ppSpace ident
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.«tacticSwap_var__,,»
code: /--
`swap_var swap_rule₁, swap_rule₂, ⋯` applies `swap_rule₁` then `swap_rule₂` then `⋯`.

A *swap_rule* is of the form `x y` or `x ↔ y`, and "applying it" means swapping the variable name
`x` by `y` and vice-versa on all hypotheses and the goal.

```lean
example {P Q : Prop} (q : P) (p : Q) : P ∧ Q := by
  swap_var p ↔ q
  exact ⟨p, q⟩
```
-/
elab "swap_var " swapRules:(colGt swapRule),+ : tactic => do
  let mvarId ← getMainGoal
  let mdecl ← mvarId.getDecl
  let localInstances := mdecl.localInstances
  let lctx ← swapRules.getElems.foldlM (init := mdecl.lctx) fun lctx swapRule ↦ do
    withLCtx lctx localInstances do
      let `(swapRule| $n₁:ident $[↔]? $n₂:ident) := swapRule
        | unreachable!
      let n₁ := n₁.getId
      let n₂ := n₂.getId
      let fvarId₁ := (← getLocalDeclFromUserName n₁).fvarId
      let fvarId₂ := (← getLocalDeclFromUserName n₂).fvarId
      return lctx.setUserName fvarId₁ n₂ |>.setUserName fvarId₂ n₁
  let mdecl := { mdecl with lctx := lctx }
  modifyMCtx fun mctx ↦ { mctx with decls := mctx.decls.insert mvarId mdecl }
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.«_aux_Mathlib_Tactic_SwapVar___elabRules_Mathlib_Tactic_tacticSwap_var__,,_1»
code: /--
`swap_var swap_rule₁, swap_rule₂, ⋯` applies `swap_rule₁` then `swap_rule₂` then `⋯`.

A *swap_rule* is of the form `x y` or `x ↔ y`, and "applying it" means swapping the variable name
`x` by `y` and vice-versa on all hypotheses and the goal.

```lean
example {P Q : Prop} (q : P) (p : Q) : P ∧ Q := by
  swap_var p ↔ q
  exact ⟨p, q⟩
```
-/
elab "swap_var " swapRules:(colGt swapRule),+ : tactic => do
  let mvarId ← getMainGoal
  let mdecl ← mvarId.getDecl
  let localInstances := mdecl.localInstances
  let lctx ← swapRules.getElems.foldlM (init := mdecl.lctx) fun lctx swapRule ↦ do
    withLCtx lctx localInstances do
      let `(swapRule| $n₁:ident $[↔]? $n₂:ident) := swapRule
        | unreachable!
      let n₁ := n₁.getId
      let n₂ := n₂.getId
      let fvarId₁ := (← getLocalDeclFromUserName n₁).fvarId
      let fvarId₂ := (← getLocalDeclFromUserName n₂).fvarId
      return lctx.setUserName fvarId₁ n₂ |>.setUserName fvarId₂ n₁
  let mdecl := { mdecl with lctx := lctx }
  modifyMCtx fun mctx ↦ { mctx with decls := mctx.decls.insert mvarId mdecl }
goal: Lean.Elab.Tactic.Tactic
File: Mathlib/Tactic/HaveI.lean

full_name: Mathlib.Tactic.HaveI.termHaveIDummy_._@.Mathlib.Tactic.HaveI._hyg.4
code: local syntax "haveIDummy" haveDecl : term
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.HaveI._aux_Mathlib_Tactic_HaveI___macroRules_Lean_Parser_Term_assert_1
code: macro_rules
  | `(assert! haveIDummy $hd:haveDecl; $body) => `(haveI $hd:haveDecl; $body)
goal: Lean.Macro

full_name: Mathlib.Tactic.HaveI._aux_Mathlib_Tactic_HaveI___macroRules_Mathlib_Tactic_HaveI_doElemHaveI'__1
code: macro "haveI' " hd:haveDecl : doElem =>
  `(doElem| assert! haveIDummy $hd:haveDecl)
goal: Lean.Macro

full_name: Mathlib.Tactic.HaveI.doElemHaveI'_
code: macro "haveI' " hd:haveDecl : doElem =>
  `(doElem| assert! haveIDummy $hd:haveDecl)
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.HaveI.termLetIDummy_._@.Mathlib.Tactic.HaveI._hyg.443
code: local syntax "letIDummy" haveDecl : term
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.HaveI._aux_Mathlib_Tactic_HaveI___macroRules_Lean_Parser_Term_assert_2
code: macro_rules
  | `(assert! letIDummy $hd:haveDecl; $body) => `(letI $hd:haveDecl; $body)
goal: Lean.Macro

full_name: Mathlib.Tactic.HaveI.doElemLetI'_
code: macro "letI' " hd:haveDecl : doElem =>
  `(doElem| assert! letIDummy $hd:haveDecl)
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.HaveI._aux_Mathlib_Tactic_HaveI___macroRules_Mathlib_Tactic_HaveI_doElemLetI'__1
code: macro "letI' " hd:haveDecl : doElem =>
  `(doElem| assert! letIDummy $hd:haveDecl)
goal: Lean.Macro
File: Mathlib/Tactic/Contrapose.lean

full_name: Mathlib.Tactic.Contrapose.mtr
code: lemma mtr {p q : Prop} : (¬ q → ¬ p) → (p → q) 
goal: (¬q → ¬p) → p → q

full_name: Mathlib.Tactic.Contrapose.contrapose
code: /--
Transforms the goal into its contrapositive.
* `contrapose`     turns a goal `P → Q` into `¬ Q → ¬ P`
* `contrapose h`   first reverts the local assumption `h`, and then uses `contrapose` and `intro h`
* `contrapose h with new_h` uses the name `new_h` for the introduced hypothesis
-/
syntax (name := contrapose) "contrapose" (ppSpace colGt ident (" with " ident)?)? : tactic
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose_1
code: macro_rules
  | `(tactic| contrapose) => `(tactic| (refine mtr ?_))
  | `(tactic| contrapose $e) => `(tactic| (revert $e:ident; contrapose; intro $e:ident))
  | `(tactic| contrapose $e with $e') => `(tactic| (revert $e:ident; contrapose; intro $e':ident))
goal: Lean.Macro

full_name: Mathlib.Tactic.Contrapose.contrapose!
code: /--
Transforms the goal into its contrapositive and uses pushes negations inside `P` and `Q`.
Usage matches `contrapose`
-/
syntax (name := contrapose!) "contrapose!" (ppSpace colGt ident (" with " ident)?)? : tactic
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1
code: macro_rules
  | `(tactic| contrapose!) => `(tactic| (contrapose; try push_neg))
  | `(tactic| contrapose! $e) => `(tactic| (revert $e:ident; contrapose!; intro $e:ident))
  | `(tactic| contrapose! $e with $e') => `(tactic| (revert $e:ident; contrapose!; intro $e':ident))
goal: Lean.Macro
File: Mathlib/Tactic/ByContra.lean

full_name: byContra!
code: /--
If the target of the main goal is a proposition `p`,
`by_contra!` reduces the goal to proving `False` using the additional hypothesis `this : ¬ p`.
`by_contra! h` can be used to name the hypothesis `h : ¬ p`.
The hypothesis `¬ p` will be negation normalized using `push_neg`.
For instance, `¬ a < b` will be changed to `b ≤ a`.
`by_contra! h : q` will normalize negations in `¬ p`, normalize negations in `q`,
and then check that the two normalized forms are equal.
The resulting hypothesis is the pre-normalized form, `q`.
If the name `h` is not explicitly provided, then `this` will be used as name.
This tactic uses classical reasoning.
It is a variant on the tactic `by_contra`.
Examples:
```lean
example : 1 < 2 := by
  by_contra! h
  -- h : 2 ≤ 1 ⊢ False

example : 1 < 2 := by
  by_contra! h : ¬ 1 < 2
  -- h : ¬ 1 < 2 ⊢ False
```
-/
syntax (name := byContra!) "by_contra!" (ppSpace colGt binderIdent)? Term.optType : tactic
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_ByContra___macroRules_byContra!_1
code: macro_rules
  | `(tactic| by_contra!%$tk $[_%$under]? $[: $ty]?) =>
    `(tactic| by_contra! $(mkIdentFrom (under.getD tk) `this (canonical := true)):ident $[: $ty]?)
  | `(tactic| by_contra! $e:ident) => `(tactic| (by_contra $e:ident; try push_neg at $e:ident))
  | `(tactic| by_contra! $e:ident : $y) => `(tactic|
       (by_contra! h
        -- if the below `exact` call fails then this tactic should fail with the message
        -- tactic failed: <goal type> and <type of h> are not definitionally equal
        have $e:ident : $y := by { (try push_neg); exact h }
        clear h))
goal: Lean.Macro
File: Mathlib/Tactic/GuardGoalNums.lean

full_name: guardGoalNums
code: /-- `guard_goal_nums n` succeeds if there are exactly `n` goals and fails otherwise. -/
elab (name := guardGoalNums) "guard_goal_nums " n:num : tactic => do
  let numGoals := (← getGoals).length
  guard (numGoals = n.getNat) <|>
    throwError "expected {n.getNat} goals but found {numGoals}"
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_GuardGoalNums___elabRules_guardGoalNums_1
code: /-- `guard_goal_nums n` succeeds if there are exactly `n` goals and fails otherwise. -/
elab (name := guardGoalNums) "guard_goal_nums " n:num : tactic => do
  let numGoals := (← getGoals).length
  guard (numGoals = n.getNat) <|>
    throwError "expected {n.getNat} goals but found {numGoals}"
goal: Lean.Elab.Tactic.Tactic
File: Mathlib/Tactic/ApplyWith.lean

full_name: Mathlib.Tactic._aux_Mathlib_Tactic_ApplyWith___elabRules_Mathlib_Tactic_applyWith_1
code: /--
`apply (config := cfg) e` is like `apply e` but allows you to provide a configuration
`cfg : ApplyConfig` to pass to the underlying `apply` operation.
-/
elab (name := applyWith) "apply" " (" &"config" " := " cfg:term ") " e:term : tactic => do
  let cfg ← unsafe evalTerm ApplyConfig (mkConst ``ApplyConfig) cfg
  evalApplyLikeTactic (·.apply · cfg) e
goal: Lean.Elab.Tactic.Tactic

full_name: Mathlib.Tactic.applyWith
code: /--
`apply (config := cfg) e` is like `apply e` but allows you to provide a configuration
`cfg : ApplyConfig` to pass to the underlying `apply` operation.
-/
elab (name := applyWith) "apply" " (" &"config" " := " cfg:term ") " e:term : tactic => do
  let cfg ← unsafe evalTerm ApplyConfig (mkConst ``ApplyConfig) cfg
  evalApplyLikeTactic (·.apply · cfg) e
goal: Lean.ParserDescr
File: Mathlib/Tactic/Positivity/Finset.lean

full_name: Mathlib.Meta.Positivity.evalFinsetCard
code: /-- Extension for `Finset.card`. `s.card` is positive if `s` is nonempty.

It calls `Mathlib.Meta.proveFinsetNonempty` to attempt proving that the finset is nonempty. -/
@[positivity Finset.card _]
def evalFinsetCard : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalFintypeCard
code: /-- Extension for `Fintype.card`. `Fintype.card α` is positive if `α` is nonempty. -/
@[positivity Fintype.card _]
def evalFintypeCard : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalFinsetDens
code: /-- Extension for `Finset.dens`. `s.card` is positive if `s` is nonempty.

It calls `Mathlib.Meta.proveFinsetNonempty` to attempt proving that the finset is nonempty. -/
@[positivity Finset.dens _]
def evalFinsetDens : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt
File: Mathlib/Tactic/Have.lean

full_name: Mathlib.Tactic.optBinderIdent
code: /-- A parser for optional binder identifiers -/
def optBinderIdent : Parser 
goal: Lean.Parser.Parser

full_name: Mathlib.Tactic.optBinderIdent.name
code: /-- Retrieves the name of the optional identifier, if provided. Returns `this` otherwise -/
def optBinderIdent.name (id : TSyntax ``optBinderIdent) : Name 
goal: Lean.Name

full_name: Mathlib.Tactic.haveIdLhs'
code: /--
Uses `checkColGt` to prevent

```lean
have h
exact Nat
```

From being interpreted as
```lean
have h
  exact Nat
```
-/
def haveIdLhs' : Parser 
goal: Lean.Parser.Parser

full_name: Mathlib.Tactic.tacticHave_
code: syntax "have" haveIdLhs' : tactic
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.tacticLet_
code: syntax "let " haveIdLhs' : tactic
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.tacticSuffices_
code: syntax "suffices" haveIdLhs' : tactic
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.haveLetCore
code: /--
Adds hypotheses to the context, turning them into goals to be proved later if their proof terms
aren't provided (`t: Option Term := none`).

If the bound term is intended to be kept in the context, pass `keepTerm : Bool := true`. This is
useful when extending the `let` tactic, which is expected to show the proof term in the infoview.
-/
def haveLetCore (goal : MVarId) (name : TSyntax ``optBinderIdent)
    (bis : Array (TSyntax ``letIdBinder))
    (t : Option Term) (keepTerm : Bool) : TermElabM (MVarId × MVarId) 
goal: Lean.Elab.TermElabM (Lean.MVarId × Lean.MVarId)

full_name: Mathlib.Tactic._aux_Mathlib_Tactic_Have___elabRules_Mathlib_Tactic_tacticHave__1
code: /-- An extension of the `have` tactic that turns the hypothesis into a goal to be proved later -/
elab_rules : tactic
| `(tactic| have $n:optBinderIdent $bs* $[: $t:term]?) => do
  let (goal1, goal2) ← haveLetCore (← getMainGoal) n bs t false
  replaceMainGoal [goal1, goal2]
goal: Lean.Elab.Tactic.Tactic

full_name: Mathlib.Tactic._aux_Mathlib_Tactic_Have___elabRules_Mathlib_Tactic_tacticSuffices__1
code: /--
An extension of the `suffices` tactic that turns the hypothesis into a goal to be proved later
-/
elab_rules : tactic
| `(tactic| suffices $n:optBinderIdent $bs* $[: $t:term]?) => do
  let (goal1, goal2) ← haveLetCore (← getMainGoal) n bs t false
  replaceMainGoal [goal2, goal1]
goal: Lean.Elab.Tactic.Tactic

full_name: Mathlib.Tactic._aux_Mathlib_Tactic_Have___elabRules_Mathlib_Tactic_tacticLet__1
code: /-- An extension of the `let` tactic that turns the hypothesis into a goal to be proved later -/
elab_rules : tactic
| `(tactic| let $n:optBinderIdent $bs* $[: $t:term]?) => withMainContext do
  let (goal1, goal2) ← haveLetCore (← getMainGoal) n bs t true
  replaceMainGoal [goal1, goal2]
goal: Lean.Elab.Tactic.Tactic
File: Mathlib/Tactic/Qify.lean

full_name: Mathlib.Tactic.Qify.qify
code: /--
The `qify` tactic is used to shift propositions from `ℕ` or `ℤ` to `ℚ`.
This is often useful since `ℚ` has well-behaved division.
```
example (a b c x y z : ℕ) (h : ¬ x*y*z < 0) : c < a + 3*b := by
  qify
  qify at h
  /-
  h : ¬↑x * ↑y * ↑z < 0
  ⊢ ↑c < ↑a + 3 * ↑b
  -/
  sorry
```
`qify` can be given extra lemmas to use in simplification. This is especially useful in the
presence of nat subtraction: passing `≤` arguments will allow `push_cast` to do more work.
```
example (a b c : ℤ) (h : a / b = c) (hab : b ∣ a) (hb : b ≠ 0) : a = c * b := by
  qify [hab] at h hb ⊢
  exact (div_eq_iff hb).1 h
```
`qify` makes use of the `@[zify_simps]` and `@[qify_simps]` attributes to move propositions,
and the `push_cast` tactic to simplify the `ℚ`-valued expressions. -/
syntax (name := qify) "qify" (simpArgs)? (location)? : tactic
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.Qify._aux_Mathlib_Tactic_Qify___macroRules_Mathlib_Tactic_Qify_qify_1
code: macro_rules
| `(tactic| qify $[[$simpArgs,*]]? $[at $location]?) =>
  let args := simpArgs.map (·.getElems) |>.getD #[]
  `(tactic|
    simp (config := {decide := false}) only [zify_simps, qify_simps, push_cast, $args,*]
      $[at $location]?)
goal: Lean.Macro

full_name: Mathlib.Tactic.Qify.intCast_eq
code: @[qify_simps] lemma intCast_eq (a b : ℤ) : a = b ↔ (a : ℚ) = (b : ℚ) 
goal: a = b ↔ ↑a = ↑b

full_name: Mathlib.Tactic.Qify.intCast_le
code: @[qify_simps] lemma intCast_le (a b : ℤ) : a ≤ b ↔ (a : ℚ) ≤ (b : ℚ) 
goal: a ≤ b ↔ ↑a ≤ ↑b

full_name: Mathlib.Tactic.Qify.intCast_lt
code: @[qify_simps] lemma intCast_lt (a b : ℤ) : a < b ↔ (a : ℚ) < (b : ℚ) 
goal: a < b ↔ ↑a < ↑b

full_name: Mathlib.Tactic.Qify.intCast_ne
code: @[qify_simps] lemma intCast_ne (a b : ℤ) : a ≠ b ↔ (a : ℚ) ≠ (b : ℚ) 
goal: a ≠ b ↔ ↑a ≠ ↑b
File: Mathlib/Tactic/CategoryTheory/Slice.lean

full_name: slice
code: /--
`slice` is a conv tactic; if the current focus is a composition of several morphisms,
`slice a b` reassociates as needed, and zooms in on the `a`-th through `b`-th morphisms.
Thus if the current focus is `(a ≫ b) ≫ ((c ≫ d) ≫ e)`, then `slice 2 3` zooms to `b ≫ c`.
 -/
syntax (name := slice) "slice " num ppSpace num : conv
goal: Lean.ParserDescr

full_name: evalSlice
code: /--
`evalSlice`
- rewrites the target expression using `Category.assoc`.
- uses `congr` to split off the first `a-1` terms and rotates to `a`-th (last) term
- counts the number `k` of rewrites as it uses `←Category.assoc` to bring the target to
  left associated form; from the first step this is the total number of remaining terms from `C`
- it now splits off `b-a` terms from target using `congr` leaving the desired subterm
- finally, it rewrites it once more using `Category.assoc` to bring it to right-associated
  normal form
-/
def evalSlice (a b : Nat) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: _aux_Mathlib_Tactic_CategoryTheory_Slice___elabRules_convSlice____1
code: /-- `slice` is implemented by `evalSlice`. -/
elab "slice " a:num ppSpace b:num : conv => evalSlice a.getNat b.getNat
goal: Lean.Elab.Tactic.Tactic

full_name: convSlice___
code: /-- `slice` is implemented by `evalSlice`. -/
elab "slice " a:num ppSpace b:num : conv => evalSlice a.getNat b.getNat
goal: Lean.ParserDescr

full_name: sliceLHS
code: /--
`slice_lhs a b => tac` zooms to the left hand side, uses associativity for categorical
composition as needed, zooms in on the `a`-th through `b`-th morphisms, and invokes `tac`.
-/
syntax (name := sliceLHS) "slice_lhs " num ppSpace num " => " convSeq : tactic
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_CategoryTheory_Slice___macroRules_sliceLHS_1
code: macro_rules
  | `(tactic| slice_lhs $a $b => $seq) =>
    `(tactic| conv => lhs; slice $a $b; ($seq:convSeq))
goal: Lean.Macro

full_name: sliceRHS
code: /--
`slice_rhs a b => tac` zooms to the right hand side, uses associativity for categorical
composition as needed, zooms in on the `a`-th through `b`-th morphisms, and invokes `tac`.
-/
syntax (name := sliceRHS) "slice_rhs " num ppSpace num " => " convSeq : tactic
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_CategoryTheory_Slice___macroRules_sliceRHS_1
code: macro_rules
  | `(tactic| slice_rhs $a $b => $seq) =>
    `(tactic| conv => rhs; slice $a $b; ($seq:convSeq))
goal: Lean.Macro
File: Mathlib/Tactic/ArithMult/Init.lean

full_name: initFn._@.Mathlib.Tactic.ArithMult.Init._hyg.5
code: declare_aesop_rule_sets [IsMultiplicative]
goal: IO Unit
File: Mathlib/Tactic/Clean.lean

full_name: Lean.Expr.cleanConsts
code: /-- List of names removed by the `clean` tactic.
All of these names must resolve to functions defeq `id`. -/
-- Note: one could also add `hidden`, but this doesn't arise from type hints.
def cleanConsts : List Name 
goal: List Lean.Name

full_name: Lean.Expr.clean
code: /-- Clean an expression by eliminating identify functions listed in `cleanConsts`.
Also eliminates `fun x => x` applications and tautological `let_fun` bindings. -/
def clean (e : Expr) : Expr 
goal: Lean.Expr

full_name: Mathlib.Tactic.cleanStx
code: /--
`clean% t` fully elaborates `t` and then eliminates all identity functions from it.

Identity functions are normally generated with terms like `show t from p`,
which translate to some variant on `@id t p` in order to retain the type.
These are also generated by tactics such as `dsimp` to insert type hints.

Example:
```lean
def x : Id Nat := by dsimp [Id]; exact 1
#print x
-- def x : Id Nat := id 1

def x' : Id Nat := clean% by dsimp [Id]; exact 1
#print x'
-- def x' : Id Nat := 1
```
-/
syntax (name := cleanStx) "clean% " term : term
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.elabClean
code: @[term_elab cleanStx, inherit_doc cleanStx]
def elabClean : Term.TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Mathlib.Tactic._aux_Mathlib_Tactic_Clean___macroRules_Mathlib_Tactic_tacticClean__1
code: macro "clean " t:term : tactic => `(tactic| exact clean% $t)
goal: Lean.Macro

full_name: Mathlib.Tactic.tacticClean_
code: macro "clean " t:term : tactic => `(tactic| exact clean% $t)
goal: Lean.ParserDescr
File: Mathlib/Tactic/Ring/PNat.lean

full_name: Mathlib.Tactic.Ring.instCSLiftPNatNat
code: instance : CSLift ℕ+ Nat 
goal: Mathlib.Tactic.Ring.CSLift ℕ+ ℕ

full_name: Mathlib.Tactic.Ring.instCSLiftValPNatNatOfNatHAdd
code: instance {n} : CSLiftVal (no_index (OfNat.ofNat (n+1)) : ℕ+) (n + 1) 
goal: Mathlib.Tactic.Ring.CSLiftVal (OfNat.ofNat (n + 1)) (n + 1)

full_name: Mathlib.Tactic.Ring.instCSLiftValPNatNatToPNat
code: instance {n h} : CSLiftVal (Nat.toPNat n h) n 
goal: Mathlib.Tactic.Ring.CSLiftVal (n.toPNat h) n

full_name: Mathlib.Tactic.Ring.instCSLiftValPNatNatSuccPNatHAddOfNat
code: instance {n} : CSLiftVal (Nat.succPNat n) (n + 1) 
goal: Mathlib.Tactic.Ring.CSLiftVal n.succPNat (n + 1)

full_name: Mathlib.Tactic.Ring.instCSLiftValPNatNatToPNat'HAddPredOfNat
code: instance {n} : CSLiftVal (Nat.toPNat' n) (n.pred + 1) 
goal: Mathlib.Tactic.Ring.CSLiftVal n.toPNat' (n.pred + 1)

full_name: Mathlib.Tactic.Ring.instCSLiftValPNatNatDivExactHAddDivOfNat
code: instance {n k} : CSLiftVal (PNat.divExact n k) (n.div k + 1) 
goal: Mathlib.Tactic.Ring.CSLiftVal (n.divExact k) (n.div k + 1)

full_name: Mathlib.Tactic.Ring.instCSLiftValPNatNatHAdd
code: instance {n n' k k'} [h1 : CSLiftVal (n : ℕ+) n'] [h2 : CSLiftVal (k : ℕ+) k'] :
    CSLiftVal (n + k) (n' + k') 
goal: Mathlib.Tactic.Ring.CSLiftVal (n + k) (n' + k')

full_name: Mathlib.Tactic.Ring.instCSLiftValPNatNatHMul
code: instance {n n' k k'} [h1 : CSLiftVal (n : ℕ+) n'] [h2 : CSLiftVal (k : ℕ+) k'] :
    CSLiftVal (n * k) (n' * k') 
goal: Mathlib.Tactic.Ring.CSLiftVal (n * k) (n' * k')

full_name: Mathlib.Tactic.Ring.instCSLiftValPNatNatHPow
code: instance {n n' k} [h1 : CSLiftVal (n : ℕ+) n'] :
    CSLiftVal (n ^ k) (n' ^ k) 
goal: Mathlib.Tactic.Ring.CSLiftVal (n ^ k) (n' ^ k)