Simple tactics that are used throughout Batteries.

def Batteries.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 Batteries.Tactic.exacts : Lean.ParserDescr

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

def Batteries.Tactic.tacticBy_contra_core : Lean.ParserDescr

by_contra_core is the component of by_contra that turns the goal into the form p → False. by_contra h is defined as by_contra_core followed by rintro h.

• If the goal is a negation ¬q, the goal becomes q → False.
• If the goal has a Decidable instance, it uses Decidable.byContradiction instead of Classical.byContradiction.

def Batteries.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 will be called this.

def Batteries.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 Batteries.Tactic.tacticSplit_ands : Lean.ParserDescr

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

def Batteries.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 Batteries.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 Batteries.Tactic.triv : Lean.ParserDescr

Deprecated variant of trivial.

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

conv tactic to close a goal using an equality theorem.

def Batteries.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)