<!-- ============ Tactics ====================== -->
<chapter id="sec_tactics">
- <title>Tactics</title>
+ <title>Tactics</title>
+
+ <sect1 id="tactics_quickref">
+ <title>Quick reference card</title>
+ <para>
+ &tacticref;
+ </para>
+ </sect1>
<sect1 id="tac_absurd">
- <title>absurd <term></title>
+ <title>absurd</title>
<titleabbrev>absurd</titleabbrev>
<para><userinput>absurd P</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">absurd</emphasis> &sterm;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_apply">
- <title>apply <term></title>
+ <title>apply</title>
<titleabbrev>apply</titleabbrev>
<para><userinput>apply t</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">apply</emphasis> &sterm;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</variablelist>
</para>
</sect1>
+ <sect1 id="tac_applyS">
+ <title>applyS</title>
+ <titleabbrev>applyS</titleabbrev>
+ <para><userinput>applyS t auto_params</userinput></para>
+ <para>
+ <variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">applyS</emphasis> &sterm; &autoparams;</para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Pre-conditions:</term>
+ <listitem>
+ <para><command>t</command> must have type
+ <command>T<subscript>1</subscript> → ... →
+ T<subscript>n</subscript> → G</command>.</para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Action:</term>
+ <listitem>
+ <para><command>applyS</command> is useful when
+ <command>apply</command> fails because the current goal
+ and the conclusion of the applied theorems are extensionally
+ equivalent up to instantiation of metavariables, but cannot
+ be unified. E.g. the goal is <command>P(n*O+m)</command> and
+ the theorem to be applied proves <command>∀m.P(m+O)</command>.
+ </para>
+ <para>
+ It tries to automatically rewrite the current goal using
+ <link linkend="tac_auto">auto paramodulation</link>
+ to make it unifiable with <command>G</command>.
+ Then it closes the current sequent by applying
+ <command>t</command> to <command>n</command>
+ implicit arguments (that become new sequents).
+ The <command>auto_params</command> parameters are passed
+ directly to <command>auto paramodulation</command>.
+ </para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>New sequents to prove:</term>
+ <listitem>
+ <para>It opens a new sequent for each premise
+ <command>T<subscript>i</subscript></command> that is not
+ instantiated by unification. <command>T<subscript>i</subscript></command> is
+ the conclusion of the <command>i</command>-th new sequent to
+ prove.</para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
+ </para>
+ </sect1>
<sect1 id="tac_assumption">
<title>assumption</title>
<titleabbrev>assumption</titleabbrev>
<para><userinput>assumption </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">assumption</emphasis></para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_auto">
- <title>auto [depth=<int>] [width=<int>] [paramodulation] [full]</title>
+ <title>auto</title>
<titleabbrev>auto</titleabbrev>
- <para><userinput>auto depth=d width=w paramodulation full</userinput></para>
+ <para><userinput>auto params</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">auto</emphasis> &autoparams;. </para>
+ <para><emphasis role="bold">autobatch</emphasis> &autoparams;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
<para>None, but the tactic may fail finding a proof if every
proof is in the search space that is pruned away. Pruning is
- controlled by <command>d</command> and <command>w</command>.
+ controlled by the optional <command>params</command>.
Moreover, only lemmas whose type signature is a subset of the
signature of the current sequent are considered. The signature of
- a sequent is ...TODO</para>
+ a sequent is essentially the set of constats appearing in it.
+ </para>
</listitem>
</varlistentry>
<varlistentry>
</variablelist>
</para>
</sect1>
+ <sect1 id="tac_cases">
+ <title>cases</title>
+ <titleabbrev>cases</titleabbrev>
+ <para><userinput>
+ cases t hyps
+ </userinput></para>
+ <para>
+ <variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para>
+ <emphasis role="bold">cases</emphasis>
+ &term; [<emphasis role="bold">(</emphasis>[&id;]…<emphasis role="bold">)</emphasis>]
+ </para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Pre-conditions:</term>
+ <listitem>
+ <para>
+ <command>t</command> must inhabit an inductive type
+ </para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Action:</term>
+ <listitem>
+ <para>
+ It proceed by cases on <command>t</command>. The new generated
+ hypothesis in each branch are named according to
+ <command>hyps</command>.
+ </para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>New sequents to prove:</term>
+ <listitem>
+ <para>One new sequent for each constructor of the type of
+ <command>t</command>. Each sequent has a new hypothesis for
+ each argument of the constructor.</para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
+ </para>
+ </sect1>
<sect1 id="tac_clear">
- <title>clear <id></title>
+ <title>clear</title>
<titleabbrev>clear</titleabbrev>
- <para><userinput>clear H</userinput></para>
+ <para><userinput>
+ clear H<subscript>1</subscript> ... H<subscript>m</subscript>
+ </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para>
+ <emphasis role="bold">clear</emphasis>
+ &id; [&id;…]
+ </para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
- <para><command>H</command> must be an hypothesis of the
- current sequent to prove.</para>
+ <para>
+ <command>
+ H<subscript>1</subscript> ... H<subscript>m</subscript>
+ </command> must be hypotheses of the
+ current sequent to prove.
+ </para>
</listitem>
</varlistentry>
<varlistentry>
<term>Action:</term>
<listitem>
- <para>It hides the hypothesis <command>H</command> from the
- current sequent.</para>
+ <para>
+ It hides the hypotheses
+ <command>
+ H<subscript>1</subscript> ... H<subscript>m</subscript>
+ </command> from the current sequent.
+ </para>
</listitem>
</varlistentry>
<varlistentry>
</para>
</sect1>
<sect1 id="tac_clearbody">
- <title>clearbody <id></title>
+ <title>clearbody</title>
<titleabbrev>clearbody</titleabbrev>
<para><userinput>clearbody H</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">clearbody</emphasis> &id;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</variablelist>
</para>
</sect1>
+ <sect1 id="tac_compose">
+ <title>compose</title>
+ <titleabbrev>compose</titleabbrev>
+ <para><userinput>compose n t1 with t2 hyps</userinput></para>
+ <para>
+ <variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">compose</emphasis> [&nat;] &sterm; [<emphasis role="bold">with</emphasis> &sterm;] [&intros-spec;]</para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Pre-conditions:</term>
+ <listitem>
+ <para></para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Action:</term>
+ <listitem>
+ <para>Composes t1 with t2 in every possible way
+ <command>n</command> times introducing generated terms
+ as if <command>intros hyps</command> was issued.</para>
+ <para>If <command>t1:∀x:A.B[x]</command> and
+ <command>t2:∀x,y:A.B[x]→B[y]→C[x,y]</command> it generates:
+ <itemizedlist>
+ <listitem>
+ <para><command>λx,y:A.t2 x y (t1 x) : ∀x,y:A.B[y]→C[x,y]</command></para>
+ </listitem>
+ <listitem>
+ <para><command>λx,y:A.λH:B[x].t2 x y H (t1 y) : ∀x,y:A.B[x]→C[x,y]
+ </command></para>
+ </listitem>
+ </itemizedlist>
+ </para>
+ <para>If <command>t2</command> is omitted it composes
+ <command>t1</command>
+ with every hypothesis that can be introduced.
+ <command>n</command> iterates the process.</para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>New sequents to prove:</term>
+ <listitem>
+ <para>The same, but with more hypothesis eventually introduced
+ by the &intros-spec;.</para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
+ </para>
+ </sect1>
<sect1 id="tac_change">
- <title>change <pattern> with <term></title>
+ <title>change</title>
<titleabbrev>change</titleabbrev>
<para><userinput>change patt with t</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">change</emphasis> &pattern; <emphasis role="bold">with</emphasis> &sterm;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_constructor">
- <title>constructor <int></title>
+ <title>constructor</title>
<titleabbrev>constructor</titleabbrev>
<para><userinput>constructor n</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">constructor</emphasis> &nat;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
<para><userinput>contradiction </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">contradiction</emphasis></para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_cut">
- <title>cut <term> [as <id>]</title>
+ <title>cut</title>
<titleabbrev>cut</titleabbrev>
<para><userinput>cut P as H</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">cut</emphasis> &sterm; [<emphasis role="bold">as</emphasis> &id;]</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_decompose">
- <title>decompose [<ident list>] <ident> [<intros_spec>]</title>
+ <title>decompose</title>
<titleabbrev>decompose</titleabbrev>
- <para><userinput>decompose ???</userinput></para>
+ <para><userinput>
+ decompose as H<subscript>1</subscript> ... H<subscript>m</subscript>
+ </userinput></para>
+ <para>
+ <variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para>
+ <emphasis role="bold">decompose</emphasis>
+ [<emphasis role="bold">as</emphasis> &id;…]
+ </para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Pre-conditions:</term>
+ <listitem>
+ <para>None.</para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Action:</term>
+ <listitem>
+ <para>
+ For each each premise <command>H</command> of type
+ <command>T</command> in the current context where
+ <command>T</command> is a non-recursive inductive type without
+ right parameters and of sort Prop or CProp, the tactic runs
+ <command>
+ elim H as H<subscript>1</subscript> ... H<subscript>m</subscript>
+ </command>, clears <command>H</command> and runs itself
+ recursively on each new premise introduced by
+ <command>elim</command> in the opened sequents.
+ </para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>New sequents to prove:</term>
+ <listitem>
+ <para>
+ The ones generated by all the <command>elim</command> tactics run.
+ </para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
+ </para>
+ </sect1>
+ <sect1 id="tac_demodulate">
+ <title>demodulate</title>
+ <titleabbrev>demodulate</titleabbrev>
+ <para><userinput>demodulate auto_params</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">demodulate</emphasis> &autoparams;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
- <para>TODO.</para>
+ <para>None.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Action:</term>
<listitem>
- <para>TODO.</para>
+ <para>&TODO;</para>
</listitem>
</varlistentry>
<varlistentry>
<term>New sequents to prove:</term>
<listitem>
- <para>TODO.</para>
+ <para>None.</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect1>
- <sect1 id="tac_discriminate">
- <title>discriminate <term></title>
- <titleabbrev>discriminate</titleabbrev>
- <para><userinput>discriminate p</userinput></para>
+ <sect1 id="tac_destruct">
+ <title>destruct</title>
+ <titleabbrev>destruct</titleabbrev>
+ <para><userinput>destruct p</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">destruct</emphasis> &sterm;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
- <para><command>p</command> must have type <command>K t<subscript>1</subscript> ... t<subscript>n</subscript> = K' t'<subscript>1</subscript> ... t'<subscript>m</subscript></command> where <command>K</command> and <command>K'</command> must be different constructors of the same inductive type and each argument list can be empty if
-its constructor takes no arguments.</para>
+ <para><command>p</command> must have type <command>E<subscript>1</subscript> = E<subscript>2</subscript></command> where the two sides of the equality are possibly applied constructors of an inductive type.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Action:</term>
<listitem>
- <para>It closes the current sequent by proving the absurdity of
- <command>p</command>.</para>
+ <para>The tactic recursively compare the two sides of the equality
+ looking for different constructors in corresponding position.
+ If two of them are found, the tactic closes the current sequent
+ by proving the absurdity of <command>p</command>. Otherwise
+ it adds a new hypothesis for each leaf of the formula that
+ states the equality of the subformulae in the corresponding
+ positions on the two sides of the equality.
+ </para>
</listitem>
</varlistentry>
<varlistentry>
</para>
</sect1>
<sect1 id="tac_elim">
- <title>elim <term> [using <term>] [<intros_spec>]</title>
+ <title>elim</title>
<titleabbrev>elim</titleabbrev>
<para><userinput>elim t using th hyps</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">elim</emphasis> &sterm; [<emphasis role="bold">using</emphasis> &sterm;] &intros-spec;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_elimType">
- <title>elimType <term> [using <term>] [<intros_spec>]</title>
+ <title>elimType</title>
<titleabbrev>elimType</titleabbrev>
<para><userinput>elimType T using th hyps</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">elimType</emphasis> &sterm; [<emphasis role="bold">using</emphasis> &sterm;] &intros-spec;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_exact">
- <title>exact <term></title>
+ <title>exact</title>
<titleabbrev>exact</titleabbrev>
<para><userinput>exact p</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">exact</emphasis> &sterm;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
<para><userinput>exists </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">exists</emphasis></para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_fail">
- <title>fail </title>
- <titleabbrev>failt</titleabbrev>
+ <title>fail</title>
+ <titleabbrev>fail</titleabbrev>
<para><userinput>fail</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">fail</emphasis></para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_fold">
- <title>fold <reduction_kind> <term> <pattern></title>
+ <title>fold</title>
<titleabbrev>fold</titleabbrev>
<para><userinput>fold red t patt</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">fold</emphasis> &reduction-kind; &sterm; &pattern;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
<para><userinput>fourier </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">fourier</emphasis></para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_fwd">
- <title>fwd <ident> [<ident list>]</title>
+ <title>fwd</title>
<titleabbrev>fwd</titleabbrev>
- <para><userinput>fwd ...TODO</userinput></para>
+ <para><userinput>fwd H as H<subscript>0</subscript> ... H<subscript>n</subscript></userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">fwd</emphasis> &id; [<emphasis role="bold">as</emphasis> &id; [&id;]…]</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
- <para>TODO.</para>
+ <para>
+ The type of <command>H</command> must be the premise of a
+ forward simplification theorem.
+ </para>
</listitem>
</varlistentry>
<varlistentry>
<term>Action:</term>
<listitem>
- <para>TODO.</para>
+ <para>
+ This tactic is under development.
+ It simplifies the current context by removing
+ <command>H</command> using the following methods:
+ forward application (by <command>lapply</command>) of a suitable
+ simplification theorem, chosen automatically, of which the type
+ of <command>H</command> is a premise,
+ decomposition (by <command>decompose</command>),
+ rewriting (by <command>rewrite</command>).
+ <command>H<subscript>0</subscript> ... H<subscript>n</subscript></command>
+ are passed to the tactics <command>fwd</command> invokes, as
+ names for the premise they introduce.
+ </para>
</listitem>
</varlistentry>
<varlistentry>
<term>New sequents to prove:</term>
<listitem>
- <para>TODO.</para>
+ <para>
+ The ones opened by the tactics <command>fwd</command> invokes.
+ </para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect1>
<sect1 id="tac_generalize">
- <title>generalize <pattern> [as <id>]</title>
+ <title>generalize</title>
<titleabbrev>generalize</titleabbrev>
<para><userinput>generalize patt as H</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">generalize</emphasis> &pattern; [<emphasis role="bold">as</emphasis> &id;]</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
<para><userinput>id </userinput></para>
<para>
<variablelist>
- <varlistentry>
- <term>Pre-conditions:</term>
- <listitem>
- <para>None.</para>
- </listitem>
- </varlistentry>
- <varlistentry>
- <term>Action:</term>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
<listitem>
- <para>This identity tactic does nothing without failing.</para>
+ <para><emphasis role="bold">id</emphasis></para>
</listitem>
</varlistentry>
- <varlistentry>
- <term>New sequents to prove:</term>
- <listitem>
- <para>None.</para>
- </listitem>
- </varlistentry>
- </variablelist>
- </para>
- </sect1>
- <sect1 id="tac_injection">
- <title>injection <term></title>
- <titleabbrev>injection</titleabbrev>
- <para><userinput>injection p</userinput></para>
- <para>
- <variablelist>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
- <para><command>p</command> must have type <command>K t<subscript>1</subscript> ... t<subscript>n</subscript> = K t'<subscript>1</subscript> ... t'<subscript>n</subscript></command> where both argument lists are empty if
-<command>K</command> takes no arguments.</para>
+ <para>None.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Action:</term>
<listitem>
- <para>It derives new hypotheses by injectivity of
- <command>K</command>.</para>
+ <para>This identity tactic does nothing without failing.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>New sequents to prove:</term>
<listitem>
- <para>The new sequent to prove is equal to the current sequent
- with the additional hypotheses
- <command>t<subscript>1</subscript>=t'<subscript>1</subscript></command> ... <command>t<subscript>n</subscript>=t'<subscript>n</subscript></command>.</para>
+ <para>None.</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect1>
<sect1 id="tac_intro">
- <title>intro [<ident>]</title>
+ <title>intro</title>
<titleabbrev>intro</titleabbrev>
<para><userinput>intro H</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">intro</emphasis> [&id;]</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_intros">
- <title>intros <intros_spec></title>
+ <title>intros</title>
<titleabbrev>intros</titleabbrev>
<para><userinput>intros hyps</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">intros</emphasis> &intros-spec;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_inversion">
- <title>inversion <term></title>
+ <title>inversion</title>
<titleabbrev>inversion</titleabbrev>
<para><userinput>inversion t</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">inversion</emphasis> &sterm;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_lapply">
- <title>lapply [depth=<int>] <term> [to <term list] [using <ident>]</title>
+ <title>lapply</title>
<titleabbrev>lapply</titleabbrev>
- <para><userinput>lapply ???</userinput></para>
+ <para><userinput>
+ lapply linear depth=d t
+ to t<subscript>1</subscript>, ..., t<subscript>n</subscript> as H
+ </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para>
+ <emphasis role="bold">lapply</emphasis>
+ [<emphasis role="bold">linear</emphasis>]
+ [<emphasis role="bold">depth=</emphasis>&nat;]
+ &sterm;
+ [<emphasis role="bold">to</emphasis>
+ &sterm;
+ [<emphasis role="bold">,</emphasis>&sterm;…]
+ ]
+ [<emphasis role="bold">as</emphasis> &id;]
+ </para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
- <para>TODO.</para>
+ <para>
+ <command>t</command> must have at least <command>d</command>
+ independent premises and <command>n</command> must not be
+ greater than <command>d</command>.
+ </para>
</listitem>
</varlistentry>
<varlistentry>
<term>Action:</term>
<listitem>
- <para>TODO.</para>
+ <para>
+ Invokes <command>letin H ≝ (t ? ... ?)</command>
+ with enough <command>?</command>'s to reach the
+ <command>d</command>-th independent premise of
+ <command>t</command>
+ (<command>d</command> is maximum if unspecified).
+ Then istantiates (by <command>apply</command>) with
+ t<subscript>1</subscript>, ..., t<subscript>n</subscript>
+ the <command>?</command>'s corresponding to the first
+ <command>n</command> independent premises of
+ <command>t</command>.
+ Usually the other <command>?</command>'s preceding the
+ <command>n</command>-th independent premise of
+ <command>t</command> are istantiated as a consequence.
+ If the <command>linear</command> flag is specified and if
+ <command>t, t<subscript>1</subscript>, ..., t<subscript>n</subscript></command>
+ are (applications of) premises in the current context, they are
+ <command>clear</command>ed.
+ </para>
</listitem>
</varlistentry>
<varlistentry>
<term>New sequents to prove:</term>
<listitem>
- <para>TODO.</para>
+ <para>
+ The ones opened by the tactics <command>lapply</command> invokes.
+ </para>
</listitem>
</varlistentry>
</variablelist>
<para><userinput>left </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">left</emphasis></para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_letin">
- <title>letin <ident> ≝ <term></title>
+ <title>letin</title>
<titleabbrev>letin</titleabbrev>
<para><userinput>letin x ≝ t</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">letin</emphasis> &id; <emphasis role="bold">≝</emphasis> &sterm;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_normalize">
- <title>normalize <pattern></title>
+ <title>normalize</title>
<titleabbrev>normalize</titleabbrev>
<para><userinput>normalize patt</userinput></para>
<para>
<variablelist>
- <varlistentry>
- <term>Pre-conditions:</term>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
<listitem>
- <para>None.</para>
+ <para><emphasis role="bold">normalize</emphasis> &pattern;</para>
</listitem>
</varlistentry>
- <varlistentry>
- <term>Action:</term>
- <listitem>
- <para>It replaces all the terms matched by <command>patt</command>
- with their βδιζ-normal form.</para>
- </listitem>
- </varlistentry>
- <varlistentry>
- <term>New sequents to prove:</term>
- <listitem>
- <para>None.</para>
- </listitem>
- </varlistentry>
- </variablelist>
- </para>
- </sect1>
- <sect1 id="tac_paramodulation">
- <title>paramodulation <pattern></title>
- <titleabbrev>paramodulation</titleabbrev>
- <para><userinput>paramodulation patt</userinput></para>
- <para>
- <variablelist>
- <varlistentry>
- <term>Pre-conditions:</term>
- <listitem>
- <para>TODO.</para>
- </listitem>
- </varlistentry>
- <varlistentry>
- <term>Action:</term>
- <listitem>
- <para>TODO.</para>
- </listitem>
- </varlistentry>
- <varlistentry>
- <term>New sequents to prove:</term>
- <listitem>
- <para>TODO.</para>
- </listitem>
- </varlistentry>
- </variablelist>
- </para>
- </sect1>
- <sect1 id="tac_reduce">
- <title>reduce <pattern></title>
- <titleabbrev>reduce</titleabbrev>
- <para><userinput>reduce patt</userinput></para>
- <para>
- <variablelist>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
<para><userinput>reflexivity </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">reflexivity</emphasis></para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_replace">
- <title>replace <pattern> with <term></title>
+ <title>replace</title>
<titleabbrev>change</titleabbrev>
<para><userinput>change patt with t</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">replace</emphasis> &pattern; <emphasis role="bold">with</emphasis> &sterm;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_rewrite">
- <title>rewrite {<|>} <term> <pattern></title>
+ <title>rewrite</title>
<titleabbrev>rewrite</titleabbrev>
<para><userinput>rewrite dir p patt</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">rewrite</emphasis> [<emphasis role="bold"><</emphasis>|<emphasis role="bold">></emphasis>] &sterm; &pattern;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
<para><userinput>right </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">right</emphasis></para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
<para><userinput>ring </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">ring</emphasis></para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_simplify">
- <title>simplify <pattern></title>
+ <title>simplify</title>
<titleabbrev>simplify</titleabbrev>
<para><userinput>simplify patt</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">simplify</emphasis> &pattern;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
<para><userinput>split </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">split</emphasis></para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</variablelist>
</para>
</sect1>
+
+ <sect1 id="tac_subst">
+ <title>subst</title>
+ <titleabbrev>subst</titleabbrev>
+ <para><userinput>subst</userinput></para>
+ <para>
+ <variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">subst</emphasis></para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Pre-conditions:</term>
+ <listitem><para>
+ None.
+ </para></listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Action:</term>
+ <listitem><para>
+ For each premise of the form
+ <command>H: x = t</command> or <command>H: t = x</command>
+ where <command>x</command> is a local variable and
+ <command>t</command> does not depend on <command>x</command>,
+ the tactic rewrites <command>H</command> wherever
+ <command>x</command> appears clearing <command>H</command> and
+ <command>x</command> afterwards.
+ </para></listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>New sequents to prove:</term>
+ <listitem><para>
+ The one opened by the applied tactics.
+ </para></listitem>
+ </varlistentry>
+ </variablelist>
+ </para>
+ </sect1>
<sect1 id="tac_symmetry">
<title>symmetry</title>
<titleabbrev>symmetry</titleabbrev>
<para><userinput>symmetry </userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">symmetry</emphasis></para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_transitivity">
- <title>transitivity <term></title>
+ <title>transitivity</title>
<titleabbrev>transitivity</titleabbrev>
<para><userinput>transitivity t</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">transitivity</emphasis> &sterm;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_unfold">
- <title>unfold [<term>] <pattern></title>
+ <title>unfold</title>
<titleabbrev>unfold</titleabbrev>
<para><userinput>unfold t patt</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">unfold</emphasis> [&sterm;] &pattern;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>
</para>
</sect1>
<sect1 id="tac_whd">
- <title>whd <pattern></title>
+ <title>whd</title>
<titleabbrev>whd</titleabbrev>
<para><userinput>whd patt</userinput></para>
<para>
<variablelist>
+ <varlistentry role="tactic.synopsis">
+ <term>Synopsis:</term>
+ <listitem>
+ <para><emphasis role="bold">whd</emphasis> &pattern;</para>
+ </listitem>
+ </varlistentry>
<varlistentry>
<term>Pre-conditions:</term>
<listitem>