Tactic Index

+ | = | [ | a | b | c | d | e | f | g | h | i | l | m | n | o | p | r | s | t | u | v | w | x | z | { | | | } |
 
+
+ (backtracking branching)
 
=
=>
 
[
[ … | … | … ] (dispatch)
[> … | … | … ] (dispatch)
 
a
abstract
abstract (ssreflect)
absurd
admit
apply
apply (ssreflect)
assert
assert_fails
assert_succeeds
assumption
auto
autoapply
autorewrite
autounfold
autounfold_one
 
b
btauto
bullet (- + *)
by
 
c
case
case (ssreflect)
case_eq
cbn
cbv
change
change_no_check
classical_left
classical_right
clear
clear dependent
clearbody
cofix
compare
compute
congr
congruence
constr_eq
constr_eq_nounivs
constr_eq_strict
constructor
context
contradict
contradiction
convert
cut
cycle
 
d
debug auto
debug eauto
debug trivial
decide
decide equality
decompose
decompose record
decompose sum
dependent destruction
dependent generalize_eqs
dependent generalize_eqs_vars
dependent induction
dependent inversion
dependent inversion_clear
dependent rewrite
dependent simple inversion
destauto
destruct
dfs eauto
dintuition
discriminate
discrR
do
do (ssreflect)
done
dtauto
 
e
eapply
eassert
eassumption
easy
eauto
ecase
econstructor
edestruct
ediscriminate
eelim
eenough
eexact
eexists
einduction
einjection
eintros
eleft
elim
elim (ssreflect)
enough
epose
epose proof
eremember
erewrite
eright
eset
esimplify_eq
esplit
etransitivity
eval
evar
exact
exact (ssreflect)
exact_no_check
exactly_once
exfalso
exists
 
f
f_equal
fail
field
field_lookup
field_simplify
field_simplify_eq
finish_timing
first
first (ssreflect)
first last
firstorder
fix
fold
fresh
fun
functional induction
functional inversion
 
g
generalize
generalize dependent
generalize_eqs
generalize_eqs_vars
generally have
gfail
gintuition
give_up
guard
 
h
has_evar
have
head_of_constr
hnf
 
i
idtac
if-then-else (Ltac2)
in
induction
info_auto
info_eauto
info_trivial
injection
instantiate
intro
intros
intros until
intuition
inversion
inversion_clear
inversion_sigma
is_cofix
is_const
is_constructor
is_evar
is_fix
is_ground
is_ind
is_proj
is_var
 
l
lapply
last
last first
lazy
lazy_match!
lazy_match! goal
lazymatch
lazymatch goal
left
let
lia
lra
ltac-seq
 
m
match
match (Ltac2)
match goal
match!
match! goal
move
move (ssreflect)
multi_match!
multi_match! goal
multimatch
multimatch goal
 
n
native_cast_no_check
native_compute
nia
not_evar
now
now_show
nra
nsatz
nsatz_compute
numgoals
 
o
once
only
optimize_heap
over
 
p
pattern
pose
pose (ssreflect)
pose proof
progress
protect_fv
psatz
 
r
rapply
red
refine
reflexivity
remember
rename
repeat
replace
reset ltac profile
restart_timer
revert
revert dependent
revgoals
rewrite
rewrite (ssreflect)
rewrite *
rewrite_db
rewrite_strat
right
ring
ring_lookup
ring_simplify
rtauto
 
s
set
set (ssreflect)
setoid_etransitivity
setoid_reflexivity
setoid_replace
setoid_rewrite
setoid_symmetry
setoid_transitivity
shelve
shelve_unifiable
show ltac profile
simpl
simple apply
simple congruence
simple destruct
simple eapply
simple induction
simple injection
simple inversion
simple subst
simplify_eq
soft functional induction
solve
solve_constraints
specialize
specialize_eqs
split
split_Rabs
split_Rmult
start ltac profiling
stepl
stepr
stop ltac profiling
subst
substitute
suff
suffices
swap
symmetry
 
t
tauto
time
time_constr
timeout
transitivity
transparent_abstract
trivial
try
tryif
type of
type_term
typeclasses eauto
 
u
under
unfold
unify
unlock
unshelve
 
v
vm_cast_no_check
vm_compute
 
w
with_strategy
without loss
wlia
wlog
wlra_Q
wnia
wnra_Q
wpsatz_Q
wpsatz_Z
wsos_Q
wsos_Z
 
x
xlia
xlra_Q
xlra_R
xnia
xnra_Q
xnra_R
xpsatz_Q
xpsatz_R
xpsatz_Z
xsos_Q
xsos_R
xsos_Z
 
z
zify
zify_elim_let
zify_iter_let
zify_iter_specs
zify_op
zify_saturate
 
{
{
 
|
|| (first tactic making progress)
 
}
}
 
… : … (goal selector)
… : … (ssreflect)