doc-src/IsarRef/generic.tex

   holding.  Class axioms may not contain more than one type variable.  The
   class axioms (with implicit sort constraints added) are bound to the given
   names.  Furthermore a class introduction rule is generated, which is
   employed by method $intro_classes$ to support instantiation proofs of this
   class.
-  
+
 \item [$\isarkeyword{instance}~c@1 < c@2$ and $\isarkeyword{instance}~t ::
   (\vec s)c$] setup a goal stating a class relation or type arity.  The proof
   would usually proceed by $intro_classes$, and then establish the
   characteristic theorems of the type classes involved.  After finishing the
   proof, the theory will be augmented by a type signature declaration

   initializes $calculation$ by $this$. Any subsequent $\ALSO$ on the same
   level of block-structure updates $calculation$ by some transitivity rule
   applied to $calculation$ and $this$ (in that order).  Transitivity rules are
   picked from the current context plus those given as explicit arguments (the
   latter have precedence).
-  
+
 \item [$\FINALLY~(\vec a)$] maintaining $calculation$ in the same way as
   $\ALSO$, and concludes the current calculational thread.  The final result
   is exhibited as fact for forward chaining towards the next goal. Basically,
   $\FINALLY$ just abbreviates $\ALSO~\FROM{calculation}$.  Note that
   ``$\FINALLY~\SHOW{}{\Var{thesis}}~\DOT$'' and
   ``$\FINALLY~\HAVE{}{\phi}~\DOT$'' are typical idioms for concluding
   calculational proofs.
-  
+
 \item [$\MOREOVER$ and $\ULTIMATELY$] are analogous to $\ALSO$ and $\FINALLY$,
   but collect results only, without applying rules.
-  
+
 \item [$\isarkeyword{print_trans_rules}$] prints the list of transitivity
   rules declared in the current context.
-  
+
 \item [$trans$] declares theorems as transitivity rules.
- 
+
 \end{descr}
 
 
 \section{Named local contexts (cases)}\label{sec:cases}
 

 \item [$case_names~\vec c$] declares names for the local contexts of premises
   of some theorem; $\vec c$ refers to the \emph{suffix} of the list premises.
 \item [$params~\vec p@1 \dots \vec p@n$] renames the innermost parameters of
   premises $1, \dots, n$ of some theorem.  An empty list of names may be given
   to skip positions, leaving the present parameters unchanged.
-\end{descr}
-
-
-\section{Generalized existence}
+
+  Note that the default usage of case rules does \emph{not} directly expose
+  parameters to the proof context (see also \S\ref{sec:induct-method-proper}).
+\end{descr}
+
+
+\section{Generalized existence}\label{sec:obtain}
 
 \indexisarcmd{obtain}
 \begin{matharray}{rcl}
   \isarcmd{obtain} & : & \isartrans{proof(state)}{proof(prove)} \\
 \end{matharray}

 \item [$erule~\vec a$, $drule~\vec a$, and $frule~\vec a$] are similar to the
   basic $rule$ method (see \S\ref{sec:pure-meth-att}), but apply rules by
   elim-resolution, destruct-resolution, and forward-resolution, respectively
   \cite{isabelle-ref}.  These are improper method, mainly for experimentation
   and emulating tactic scripts.
-  
+
   Different modes of basic rule application are usually expressed in Isar at
   the proof language level, rather than via implicit proof state
   manipulations.  For example, a proper single-step elimination would be done
   using the basic $rule$ method, with forward chaining of current facts.
 \item [$insert~\vec a$] inserts theorems as facts into all goals of the proof

 
 \indexisaratt{standard}
 \indexisaratt{elimify}
 \indexisaratt{no-vars}
 
-\indexisaratt{RS}\indexisaratt{COMP}
+\indexisaratt{THEN}\indexisaratt{COMP}
 \indexisaratt{where}
 \indexisaratt{tag}\indexisaratt{untag}
 \indexisaratt{export}
 \indexisaratt{unfold}\indexisaratt{fold}
 \begin{matharray}{rcl}
   tag & : & \isaratt \\
   untag & : & \isaratt \\[0.5ex]
-  RS & : & \isaratt \\
+  THEN & : & \isaratt \\
   COMP & : & \isaratt \\[0.5ex]
   where & : & \isaratt \\[0.5ex]
   unfold & : & \isaratt \\
   fold & : & \isaratt \\[0.5ex]
   standard & : & \isaratt \\

 \begin{rail}
   'tag' (nameref+)
   ;
   'untag' name
   ;
-  ('RS' | 'COMP') nat? thmref
+  ('THEN' | 'COMP') nat? thmref
   ;
   'where' (name '=' term * 'and')
   ;
   ('unfold' | 'fold') thmrefs
   ;

 \item [$tag~name~args$ and $untag~name$] add and remove $tags$ of some
   theorem.  Tags may be any list of strings that serve as comment for some
   tools (e.g.\ $\LEMMANAME$ causes the tag ``$lemma$'' to be added to the
   result).  The first string is considered the tag name, the rest its
   arguments.  Note that untag removes any tags of the same name.
-\item [$RS~n~a$ and $COMP~n~a$] compose rules.  $RS$ resolves with the $n$-th
-  premise of $a$; $COMP$ is a version of $RS$ that skips the automatic lifting
+\item [$THEN~n~a$ and $COMP~n~a$] compose rules.  $THEN$ resolves with the
+  $n$-th premise of $a$; the $COMP$ version skips the automatic lifting
   process that is normally intended (cf.\ \texttt{RS} and \texttt{COMP} in
   \cite[\S5]{isabelle-ref}).
 \item [$where~\vec x = \vec t$] perform named instantiation of schematic
   variables occurring in a theorem.  Unlike instantiation tactics such as
   $rule_tac$ (see \S\ref{sec:tactic-commands}), actual schematic variables
   have to be specified (e.g.\ $\Var{x@3}$).
-  
+
 \item [$unfold~\vec a$ and $fold~\vec a$] expand and fold back again the given
   meta-level definitions throughout a rule.
- 
+
 \item [$standard$] puts a theorem into the standard form of object-rules, just
   as the ML function \texttt{standard} (see \cite[\S5]{isabelle-ref}).
-  
+
 \item [$elimify$] turns an destruction rule into an elimination, just as the
   ML function \texttt{make\_elim} (see \cite{isabelle-ref}).
-  
+
 \item [$no_vars$] replaces schematic variables by free ones; this is mainly
   for tuning output of pretty printed theorems.
-  
+
 \item [$export$] lifts a local result out of the current proof context,
   generalizing all fixed variables and discharging all assumptions.  Note that
   proper incremental export is already done as part of the basic Isar
   machinery.  This attribute is mainly for experimentation.
-  
+
 \end{descr}
 
 
 \section{Tactic emulations}\label{sec:tactics}
 

 named $foo_tac$.
 
 \indexisarmeth{rule-tac}\indexisarmeth{erule-tac}
 \indexisarmeth{drule-tac}\indexisarmeth{frule-tac}
 \indexisarmeth{cut-tac}\indexisarmeth{thin-tac}
-\indexisarmeth{subgoal-tac}\indexisarmeth{tactic}
+\indexisarmeth{subgoal-tac}\indexisarmeth{rename_tac}
+\indexisarmeth{rotate-tac}\indexisarmeth{tactic}
 \begin{matharray}{rcl}
   rule_tac^* & : & \isarmeth \\
   erule_tac^* & : & \isarmeth \\
   drule_tac^* & : & \isarmeth \\
   frule_tac^* & : & \isarmeth \\
   cut_tac^* & : & \isarmeth \\
   thin_tac^* & : & \isarmeth \\
   subgoal_tac^* & : & \isarmeth \\
+  rename_tac^* & : & \isarmeth \\
+  rotate_tac^* & : & \isarmeth \\
   tactic^* & : & \isarmeth \\
 \end{matharray}
 
 \railalias{ruletac}{rule\_tac}
 \railterm{ruletac}

 \railterm{thintac}
 
 \railalias{subgoaltac}{subgoal\_tac}
 \railterm{subgoaltac}
 
+\railalias{renametac}{rename\_tac}
+\railterm{renametac}
+
+\railalias{rotatetac}{rotate\_tac}
+\railterm{rotatetac}
+
 \begin{rail}
   ( ruletac | eruletac | druletac | fruletac | cuttac | thintac ) goalspec?
   ( insts thmref | thmrefs )
   ;
   subgoaltac goalspec? (prop +)
+  ;
+  renametac goalspec? (name +)
+  ;
+  rotatetac goalspec? int?
   ;
   'tactic' text
   ;
 
   insts: ((name '=' term) + 'and') 'in'

 
 \begin{descr}
 \item [$rule_tac$ etc.] do resolution of rules with explicit instantiation.
   This works the same way as the ML tactics \texttt{res_inst_tac} etc. (see
   \cite[\S3]{isabelle-ref}).
-  
+
   Note that multiple rules may be only given there is no instantiation.  Then
   $rule_tac$ is the same as \texttt{resolve_tac} in ML (see
   \cite[\S3]{isabelle-ref}).
 \item [$cut_tac$] inserts facts into the proof state as assumption of a
   subgoal, see also \texttt{cut_facts_tac} in \cite[\S3]{isabelle-ref}.  Note

   that $\phi$ may contain schematic variables.  See also \texttt{thin_tac} in
   \cite[\S3]{isabelle-ref}.
 \item [$subgoal_tac~\phi$] adds $\phi$ as an assumption to a subgoal.  See
   also \texttt{subgoal_tac} and \texttt{subgoals_tac} in
   \cite[\S3]{isabelle-ref}.
+\item [$rename_tac~\vec x$] renames parameters of a goal according to the list
+  $\vec x$, which refers to the \emph{suffix} of variables.
+\item [$rotate_tac~n$] rotates the assumptions of a goal by $n$ positions:
+  from right to left if $n$ is positive, and from left to right if $n$ is
+  negative; the default value is $1$.  See also \texttt{rotate_tac} in
+  \cite[\S3]{isabelle-ref}.
 \item [$tactic~text$] produces a proof method from any ML text of type
   \texttt{tactic}.  Apart from the usual ML environment and the current
   implicit theory context, the ML code may refer to the following locally
   bound values:
 

   \texttt{thm}~/~\texttt{thms} retrieve named facts (including global
   theorems) from the context.
 \end{descr}
 
 
-\section{The Simplifier}
+\section{The Simplifier}\label{sec:simplifier}
 
 \subsection{Simplification methods}\label{sec:simp}
 
 \indexisarmeth{simp}\indexisarmeth{simp-all}
 \begin{matharray}{rcl}

 \begin{descr}
 \item [$simp$] invokes Isabelle's simplifier, after declaring additional rules
   according to the arguments given.  Note that the \railtterm{only} modifier
   first removes all other rewrite rules, congruences, and looper tactics
   (including splits), and then behaves like \railtterm{add}.
-  
+
   The \railtterm{split} modifiers add or delete rules for the Splitter (see
   also \cite{isabelle-ref}), the default is to add.  This works only if the
   Simplifier method has been properly setup to include the Splitter (all major
   object logics such HOL, HOLCF, FOL, ZF do this already).
-  
+
   The \railtterm{other} modifier ignores its arguments.  Nevertheless,
   additional kinds of rules may be declared by including appropriate
   attributes in the specification.
 \item [$simp_all$] is similar to $simp$, but acts on all goals.
 \end{descr}

 forward-chaining (using $\THEN$, $\FROMNAME$ etc.).  The full context of
 assumptions is only included if the ``$!$'' (bang) argument is given, which
 should be used with some care, though.
 
 Additional Simplifier options may be specified to tune the behavior even
-further: $(no_asm)$ means assumptions are ignored completely (cf.\ 
+further: $(no_asm)$ means assumptions are ignored completely (cf.\
 \texttt{simp_tac}), $(no_asm_simp)$ means assumptions are used in the
-simplification of the conclusion but are not themselves simplified (cf.\ 
+simplification of the conclusion but are not themselves simplified (cf.\
 \texttt{asm_simp_tac}), and $(no_asm_use)$ means assumptions are simplified
 but are not used in the simplification of each other or the conclusion (cf.
 \texttt{full_simp_tac}).
 
 \medskip

 used only very rarely.  There are no separate options for declaring
 simplification rules locally.
 
 See the ML functions of the same name in \cite[\S10]{isabelle-ref} for more
 information.
+
+
+\section{Basic equational reasoning}
+
+\indexisarmeth{subst}\indexisarmeth{hypsubst}\indexisaratt{symmetric}
+\begin{matharray}{rcl}
+  subst & : & \isarmeth \\
+  hypsubst^* & : & \isarmeth \\
+  symmetric & : & \isaratt \\
+\end{matharray}
+
+\begin{rail}
+  'subst' thmref
+  ;
+\end{rail}
+
+These methods and attributes provide basic facilities for equational reasoning
+that are intended for specialized applications only.  Normally, single step
+reasoning would be performed by calculation (see \S\ref{sec:calculation}),
+while the Simplifier is the canonical tool for automated normalization (see
+\S\ref{sec:simplifier}).
+
+\begin{descr}
+\item [$subst~thm$] performs a single substitution step using rule $thm$,
+  which may be either a meta or object equality.
+\item [$hypsubst$] performs substitution using some assumption.
+\item [$symmetric$] applies the symmetry rule of meta or object equality.
+\end{descr}
 
 
 \section{The Classical Reasoner}
 
 \subsection{Basic methods}\label{sec:classical-basic}

   provided as arguments, it automatically determines elimination and
   introduction rules from the context (see also \S\ref{sec:classical-mod}).
   This is made the default method for basic proof steps, such as $\PROOFNAME$
   and ``$\DDOT$'' (two dots), see also \S\ref{sec:proof-steps} and
   \S\ref{sec:pure-meth-att}.
-  
+
 \item [$intro$ and $elim$] repeatedly refine some goal by intro- or
   elim-resolution, after having inserted any facts.  Omitting the arguments
   refers to any suitable rules declared in the context, otherwise only the
   explicitly given ones may be applied.  The latter form admits better control
   of what actually happens, thus it is very appropriate as an initial method
   for $\PROOFNAME$ that splits up certain connectives of the goal, before
   entering the actual sub-proof.
-  
+
 \item [$contradiction$] solves some goal by contradiction, deriving any result
   from both $\neg A$ and $A$.  Facts, which are guaranteed to participate, may
   appear in either order.
 \end{descr}
 

   \texttt{fast_tac} (with the Simplifier added as wrapper), see
   \cite[\S11]{isabelle-ref} for more information.  The modifier arguments
   correspond to those given in \S\ref{sec:simp} and
   \S\ref{sec:classical-auto}.  Just note that the ones related to the
   Simplifier are prefixed by \railtterm{simp} here.
-  
+
   Facts provided by forward chaining are inserted into the goal before doing
   the search.  The ``!''~argument causes the full context of assumptions to be
   included as well.
 \end{descr}
 

   destruct rules, respectively.  By default, rules are considered as
   \emph{unsafe} (i.e.\ not applied blindly without backtracking), while a
   single ``!'' classifies as \emph{safe}, and ``?'' as \emph{extra} (i.e.\ not
   applied in the search-oriented automated methods, but only in single-step
   methods such as $rule$).
-  
+
 \item [$iff$] declares equations both as rules for the Simplifier and
   Classical Reasoner.
 
 \item [$delrule$] deletes introduction or elimination rules from the context.
   Note that destruction rules would have to be turned into elimination rules
   first, e.g.\ by using the $elimify$ attribute.
 \end{descr}
 
 
-%%% Local Variables: 
+%%% Local Variables:
 %%% mode: latex
 %%% TeX-master: "isar-ref"
-%%% End: 
+%%% End: