def Std.Tactic.tacticExfalso : Lean.ParserDescr

exfalso converts a goal ⊢ tgt into ⊢ False by applying False.elim.

def Std.Tactic.tactic_ : Lean.ParserDescr

_ in tactic position acts like the done tactic: it fails and gives the list of goals if there are any. It is useful as a placeholder after starting a tactic block such as by _ to make it syntactically correct and show the current goal.

def Std.Tactic.failIfSuccessConv : Lean.ParserDescr

fail_if_success t fails if the tactic t succeeds.

def Std.Tactic.tacticRwa__ : Lean.ParserDescr

rwa calls rw, then closes any remaining goals using assumption.

def Std.Tactic.exacts : Lean.ParserDescr

Like exact, but takes a list of terms and checks that all goals are discharged after the tactic.

def Std.Tactic.byContra : Lean.ParserDescr

by_contra h proves ⊢ p by contradiction, introducing a hypothesis h : ¬p and proving False.

• If p is a negation ¬q, h : q will be introduced instead of ¬¬q.
• If p is decidable, it uses Decidable.byContradiction instead of Classical.byContradiction.
• If h is omitted, the introduced variable _: ¬p will be anonymous.

def Std.Tactic.tacticAbsurd_ : Lean.ParserDescr

Given a proof h of p, absurd h changes the goal to ⊢ ¬ p. If p is a negation ¬q then the goal is changed to ⊢ q instead.

def Std.Tactic.tacticIterate____ : Lean.ParserDescr

iterate n tac runs tac exactly n times. iterate tac runs tac repeatedly until failure.

To run multiple tactics, one can do iterate (tac₁; tac₂; ⋯) or

iterate
  tac₁
  tac₂
  ⋯

def Std.Tactic.tacticRepeat'_ : Lean.ParserDescr

repeat' tac runs tac on all of the goals to produce a new list of goals, then runs tac again on all of those goals, and repeats until tac fails on all remaining goals.

def Std.Tactic.tacticRepeat1_ : Lean.ParserDescr

repeat1 tac applies tac to main goal at least once. If the application succeeds, the tactic is applied recursively to the generated subgoals until it eventually fails.

def Std.Tactic.tacticSubst_eqs : Lean.ParserDescr

subst_eqs applies subst to all equalities in the context as long as it makes progress.

def Std.Tactic.tacticSplit_ands : Lean.ParserDescr

split_ands applies And.intro until it does not make progress.

def Std.Tactic.tacticFapply_ : Lean.ParserDescr

fapply e is like apply e but it adds goals in the order they appear, rather than putting the dependent goals first.

def Std.Tactic.tacticEapply_ : Lean.ParserDescr

eapply e is like apply e but it does not add subgoals for variables that appear in the types of other goals. Note that this can lead to a failure where there are no goals remaining but there are still metavariables in the term:

example (h : ∀ x : Nat, x = x → True) : True := by
  eapply h
  rfl
  -- no goals
-- (kernel) declaration has metavariables '_example'

def Std.Tactic.triv : Lean.ParserDescr

Tries to solve the goal using a canonical proof of True, or the rfl tactic. Unlike trivial or trivial', does not use the contradiction tactic.

def Std.Tactic.Conv.exact : Lean.ParserDescr

conv tactic to close a goal using an equality theorem.

def Std.Tactic.Conv.equals : Lean.ParserDescr

The conv tactic equals claims that the currently focused subexpression is equal to the given expression, and proves this claim using the given tactic.

example (P : (Nat → Nat) → Prop) : P (fun n => n - n) := by
  conv in (_ - _) => equals 0 =>
    -- current goal: ⊢ n - n = 0
    apply Nat.sub_self
  -- current goal: P (fun n => 0)