From 6cf8d80ac0a9869d97373d6813441eabebce8980 Mon Sep 17 00:00:00 2001
From: herbelin
Date: Thu, 23 Feb 2006 13:58:10 +0000
Subject: Nettoyage de l'archive doc et restructuration avant intégration à
 l'archive principale de Coq et publication des sources (HH)

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/coq/trunk@8606 85f007b7-540e-0410-9357-904b9bb8a0f7
---
 doc/Recursive-Definition.tex | 251 -------------------------------------------
 1 file changed, 251 deletions(-)
 delete mode 100755 doc/Recursive-Definition.tex

(limited to 'doc/Recursive-Definition.tex')

diff --git a/doc/Recursive-Definition.tex b/doc/Recursive-Definition.tex
deleted file mode 100755
index ba9423409e..0000000000
--- a/doc/Recursive-Definition.tex
+++ /dev/null
@@ -1,251 +0,0 @@
-\documentstyle[]{article}
-\input{title}
-
-\newcommand{\xx}{\noindent}
-\newcommand{\Coq}{\textsc{Coq}}
-
-\begin{document}
-
-\coverpage{Users friendly {\tt Recursive Definition}}{Pascal MANOURY}
-
-This command allows to define functions in
-the following syntax :
-\begin{verbatim}
-Recursive Definition f [X1:U1;..;Xk:Uk] : T1-> .. -> Tn -> T :=
- p11 .. p1n => t1
-...
-|pm1 .. pmn => tm.
-\end{verbatim}
-This definition schema must be understood as :
-\begin{itemize}
-\item {\tt f} is the name of the constant we want
-to define;
-\item {\tt (X1:U1)..(Xk:Uk) T1-> .. -> Tn -> T}
-is its intended type;
-\item {\tt  p11 .. p1n => t1 | ... |pm1 .. pmn => tm.}
-describe its beha\-viour in terms of patterns.
-We
-call the {\sl patterns clauses} this part of the {\tt Recursive Definition}.
-\end{itemize}
-The semantics of the {\tt Recursive Definition} 
-is to
-define the new constant {\tt f} as a term (say {\tt F}) of
-the intended type providing that {\tt F} has the intended
-computational behavior expressed in the {\sl patterns
-clauses}. Moreover, a {\tt Recursive Definition} states and
-proves all equational theorems corresponding to {\sl
-patterns clauses}. In other words, a {\tt Recursive Definition} is
-equivalent to :
-\begin{verbatim}
-Definition f : (X1:U1)..(Xk:Uk) T1-> .. -> Tn -> T := F.
-Theorem f_eq1 : (X1:U1)..(Xk:Uk)(x11:V11)..(x1l:V1l)(F X1 .. Xk p11 .. p1n)=t1.
-Intros; Unfold F; Simpl; Trivial. Save.
-...
-Theorem f_eqm : (X1:U1)..(Xk:Uk)(xm1:Vm1)..(xml:Vml)(F X1 .. Xk pm1 .. pmn)=tm.
-Intros; Unfold F; Simpl; Trivial. Save.
-\end{verbatim}
-For instance, one can write :
-\begin{coq_example}
-Recursive Definition Ack : nat -> nat -> nat :=
-  O m => (S m)
- |(S n) O => (Ack n (S O))
- |(S n) (S m) => (Ack n (Ack (S n) m)).
-\end{coq_example}
-
-Unfortunately, the problem of finding a term (of \Coq)
-satisfying a set of {\sl patterns clauses} does not always have a
-solution, as shown by the following example~:\\
-\centerline {\tt Recursive Definition fix :
-nat -> nat := n => (fix n).} 
-The point is that, in \Coq, any term {\tt F} of type {\tt
-nat -> nat} represents a function which always terminates
-and it is easy to see that the function {\tt fix} never
-terminates. This general property of \Coq's terms is called
-{\it strong normalization}.
-
-\xx
-The fact that a syntactically correct {\tt Recursive
-Definition} as the one of {\tt fix} does not correspond to any
-term in \Coq~ points out that we cannot content with the {\it
-syntactical level} of the declaration to obtain a term, but we
-have to lift up onto the {\it logical level} to ensure that
-the aimed function satisfies such a  strong property as
-termination. And here comes the difficulty, since the termination
-problem is known to be undecidable in general.
-
-\xx
-In fact, termination is the main logical property we
-have to face with. Then the main job of the {\tt Recursive
-Definition} is to build a proof of {\tt (X1:U1)..(Xk:Uk)
-T1-> .. -> Tn -> T} understood as a termination proof of the
-aimed function.\\
-Let's see how it works on the Ackermann's function example
-:
-\begin{coq_eval}
-Restore State Initial.
-\end{coq_eval}
-\begin{coq_example}
-Theorem Ack : nat -> nat -> nat.
-Intro n; Elim n.
-Intro m; exact (S m).
-Intros p Ack_n m; Elim m.
-exact (Ack_n (S O)).
-Intros q Ack_Sn_m; exact (Ack_n Ack_Sn_m).
-Save.
-\end{coq_example}
-One can check that the term {\tt Ack} ({\it eg} : the above
-proof of {\tt nat -> nat -> nat}) actually satisfies
-the intended {\sl patterns clauses} of Ackermann's
-function.
-
-\xx
-Such a proof is {\em automatically} synthesized by a
-{specialized strategy} which was originally designed for the
-\textsc{ProPre} programming language. It has been adapted for
-the \Coq's framework. For a short description of the \textsc{ProPre}
-programming language, we refer the reader to 
-\cite{MPSI}. For details 
-concerning the original proof search strategy, we refer the
-reader to \cite{MSAR}. For theoretical settings of the
-method involved in \textsc{ProPre}, we refer the reader to
-\cite{KRPA} and \cite{PARI}.
-
-\xx
-We list bellow some correct and incorrect usages of
-the {\tt Recursive Definition} feature. 
-
-\subsection*{Correct {\tt Recursive Definition}'s}
-\begin{coq_example*}
-Recursive Definition IfSet [X:Set] : bool -> X -> X -> X :=
-  true x y => x
- |false x y => y.
-Recursive Definition equal_nat : nat -> nat -> bool :=
-  O O => true
- |O (S m) => false
- |(S n) O => false
- |(S n) (S m) => (equal_nat n m).
-Recursive Definition less_equal : nat -> nat -> bool :=
-  O m => true
- |(S n) O => false
- |(S n) (S m) => (less_equal n m).
-Inductive Set bintree :=
-  Le : bintree
- |Br : nat -> bintree -> bintree -> bintree.
-Recursive Definition ins_bsr [n:nat] : bintree -> bintree :=
-  Le => (Br n Le Le)
- |(Br m a1 a2)
-  => (IfSet bintree (less_equal n m) (Br m (ins_bsr n a1) a2)
-         (Br m a1 (ins_bsr n a2))).
-Inductive list [X:Set] : Set :=
-  Nil : (list X)
- |Cons : X -> (list X) -> (list X).
-Recursive Definition append [X:Set;ys:(list X)] : (list X) -> (list X) :=
-  (Nil X) => ys
- |(Cons X x xs) => (Cons X x (append X ys xs)).
-Recursive Definition soml : (list nat) -> nat :=
-  (Nil nat) => O
- |(Cons nat O x) => (soml x)
- |(Cons nat (S n) x) => (S (soml (Cons nat n x))).
-Recursive Definition sorted_list : (list nat) -> Prop :=
-  (Nil nat) => True
- |(Cons nat n (Nil nat)) => True
-|(Cons nat n (Cons nat m x)) 
-  => (<bool>(less_equal n m)=true) /\ (sorted_list (Cons nat m x)).
-\end{coq_example*}
-
-\subsection*{Incorrect {\tt Recursive Definition}'s}
-\begin{coq_example}
-Recursive Definition equal_list : (list nat) -> (list nat) -> bool :=
-  (Nil nat) (Nil nat) => true
- |(Nil nat) (Cons nat n y) => false
- |(Cons nat n x) (Nil nat) => false
- |(Cons nat n x) (Cons nat n y) => (equal_list x y).
-\end{coq_example}
-As explains the error message, a same pattern variable can't be used
-more than one time.
-\begin{coq_example}
-Recursive Definition min : nat -> nat -> nat :=
-  O m => m
- |n O => n
- |(S n) (S m) => (S (min n m)).
-\end{coq_example}
-We do not allow the various left members of {\sl patterns clauses} to
-overlap.
-\begin{coq_example}
-Recursive Definition wrong_equal : nat -> nat -> bool :=
-  O O => true
- |(S n) (S m) => (wrong_equal n m).
-\end{coq_example}
-As we need to prove that the function is totally defined, we need an
-exhaustive pattern matching of the inputs.
-\begin{coq_example}
-Recursive Definition div2 : nat -> nat :=
-  O => O
- |(S O) => O
- |(S (S n)) => (S (div2 n)).
-\end{coq_example}
-The strategy makes use of structural induction to search a proof of
-{\tt nat -> nat}, then it can only accept arguments decreasing in one
-step ({\it eg} from {\tt (S n)} to {\tt n}) which is not the case
-here.
-\begin{coq_example}
-Recursive Definition wrong_fact : nat -> nat :=
- n => (IfSet nat (equal_nat n O) (S O) (mult n (wrong_fact (pred n)))).
-\end{coq_example}
-This error comes from the fact that the strategy doesn't recognize
-that the {\tt IfSet} is used as matching on naturals and that, when
-{\tt n} is not {\tt O}, {\tt (pred n)} is less than {\tt n}. Indeed,
-matching must be explicit and decreasing too.
-\begin{coq_example}
-Recursive Definition heap_merge : bintree -> bintree -> bintree :=
-  Le b => b
- |(Br n a1 a2) Le => (Br n a1 a2)
- |(Br n a1 a2) (Br m b1 b2)
-  => (IfSet bintree
-         (less_equal n m)
-         (Br n (heap_merge a1 a2) (Br m b1 b2))
-         (Br m (Br n a1 a2) (heap_merge  b1 b2))).
-\end{coq_example}
-This failure of the strategy is due to the fact than with simple
-structural induction one can't get any induction hypothesis for both
-inductive calls {\tt (heap\_merge a1 a2)} and {\tt (heap\_merge b1
-  b2)}.
-
-
-\begin{thebibliography}{9999}
-\bibitem{KRPA} J.L Krivine, M. Parigot
- {\it Programming with proofs} ; in SCT 87 (1987),
-Wendish-Rietz ; in EIK 26 (1990) pp 146-167.
-
-\bibitem{MPSI} P. Manoury, M. Parigot, M. Simonot {\it {\sf
-ProPre} : a programming language with proofs} ; in
-proceedings LPAR 92, LNAI 624.
-
-\bibitem{MSTH} P. Manoury and M. Simonot {\it Des preuves
-de totalit\'e de fonctions comme synth\`ese de
-programmes} ; Phd Thesis, Universit\'e Paris 7, December
-1992. 
-
-\bibitem{MSAR} P. Manoury and M. Simonot {\it
-Automatizing termination proof of recursively defined
-functions} ; to appear in TCS.
-
-\bibitem{PARI} M. Parigot {\it Recursive programming with
-proofs} ; in TCS 94 (1992) pp 335-356. 
-
-\bibitem{PAUL} C. Paulin-Mohring {\it Inductive
-Definitions in the System Coq - Rules and properties} ;
-proceedings TLCA 93, LNCS 664 (1993).
-
-\bibitem{WERN} B. Werner {\it Une th\'eorie des
-constructions inductives} ; Phd Thesis, Universit\'e Paris
-7, May 1994.
-
-\end{thebibliography}
-
-\end{document}
-
-
-
-
-% $Id$ 
-- 
cgit v1.2.3

