(* This program is free software; you can redistribute it and/or      *)
(* modify it under the terms of the GNU Lesser General Public License *)
(* as published by the Free Software Foundation; either version 2.1   *)
(* of the License, or (at your option) any later version.             *)
(*                                                                    *)
(* This program is distributed in the hope that it will be useful,    *)
(* but WITHOUT ANY WARRANTY; without even the implied warranty of     *)
(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the      *)
(* GNU General Public License for more details.                       *)
(*                                                                    *)
(* You should have received a copy of the GNU Lesser General Public   *)
(* License along with this program; if not, write to the Free         *)
(* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *)
(* 02110-1301 USA                                                     *)
(* Contribution to the Coq Library   V6.3 (July 1999)                    *)
(****************************************************************************)
(*                 The Calculus of Inductive Constructions                  *)
(*                                                                          *)
(*                                Projet Coq                                *)
(*                                                                          *)
(*                     INRIA                        ENS-CNRS                *)
(*              Rocquencourt                        Lyon                    *)
(*                                                                          *)
(*                                Coq V5.10                                 *)
(*                              Nov 25th 1994                               *)
(*                                                                          *)
(****************************************************************************)
(*                                  Reg.v                                   *)
(****************************************************************************)
(*              Formal Language Theory                                      *)
(*                                                                          *)
(*              Judicael Courant - Jean-Christophe Filliatre                *)
(*                                                                          *)
(*              Developped in V5.8  June-July 1993                          *)
(*              Ported     to V5.10 October 1994                            *)
(****************************************************************************)
(*                 							*)
(*  AUTOMATES FINIS       						*)
(*    On definit le predicat (automate q qd qa d), ou q represente      *)
(*    l'ensemble des etats, qd ceux de depart, qa ceux d'arrivee,	*)
(*    et d la relation de transition, comme la conjonction de :		*)
(*    qd et qa sont inclus dans q , et d est inclus dans qxalphxq	*)
(*                  							*)
Definition automate (q qd qa d : Ensf) : Prop :=
inclus qa q /\ inclus qd q /\ inclus d (prodcart q (prodcart alph q)).
intros q qd qa d H.
elim H.
intros H1 H0; elim H0; clear H0.
auto.
Qed.
intros q qd qa d H.
elim H.
intros H1 H0; elim H0; clear H0.
auto.
Qed.
intros q qd qa d H.
elim H.
intros H1 H0; elim H0; clear H0.
auto.
Qed.
(*									*)
(*  On definit le predicat (chemin e1 e2 q d w), qui signifie :		*)
(*  On passe de e1 a e2 par le mot w dans un automate d'ensemble  	*)
(*  d'etats q et de transition d.					*)
(*									*)
Inductive chemin : Elt -> Elt -> Ensf -> Ensf -> Word -> Prop :=
| chemin_nil :
forall (e1 e2 : Elt) (q d : Ensf),
dans e1 q -> e1 = e2 :>Elt -> chemin e1 e2 q d nil
| chemin_cons :
forall (e1 e2 : Elt) (q d : Ensf) (w : Word) (e a : Elt),
chemin e1 e2 q d w ->
dans e q ->
dans a alph ->
dans (couple e (couple a e1)) d -> chemin e e2 q d (cons a w).
Hint Resolve chemin_nil.
(*  On definit le meme predicat d'une autre facon, qui sera plus utile	*)
(*  par la suite							*)
Definition Chemin (e1 e2 : Elt) (q d : Ensf) (w : Word) : Prop :=
match w return Prop with
| nil =>
(* nil  *)  dans e1 q /\ e1 = e2 :>Elt (* cons *)
| cons a w' =>
exists e : Elt,
chemin e e2 q d w' /\
dans e1 q /\ dans a alph /\ dans (couple e1 (couple a e)) d
end.
(*  On montre l'equivalence entre les 2 definitions : 			*)
intros e1 e2 q d.
simple induction w.
intro.
cut (dans e1 q /\ e1 = e2 :>Elt); auto.
intro H0; elim H0; clear H0.
intros; apply chemin_nil; auto.
intros x w0 H H0.
cut
(exists e : Elt,
chemin e e2 q d w0 /\
dans e1 q /\ dans x alph /\ dans (couple e1 (couple x e)) d);
auto.
intro H1; elim H1.
intros e H2; elim H2; clear H1 H2.
intros H1 H2; elim H2; clear H2.
intros H2 H3; elim H3; clear H3.
intros.
apply chemin_cons with e; auto.
Qed.
Hint Resolve Chemin_chemin.
intros e1 e2 q d w H; elim H; clear H.
intros.
red in |- *; simpl in |- *; auto.
intros.
red in |- *; simpl in |- *.
exists e0.
auto.
Qed.
Hint Resolve chemin_Chemin.
(*  									*)
(*  Si (q,qd,qa,d) est un automate alors (reconnait q qd qa d) est le   *)
(*  langage reconnu par cet automate.					*)
(*  On le definit est disant que w est dans ce langage s'il est tout	*)
(*  d'abord dans le monoid libre engendre par alph, et s'il existe	*)
(*  2 etats e1 et e2, repsectivement dans qd et qa, tels que		*)
(*  (chemin e1 e2 q d w) soit vrai.					*)
(*									*)
Definition reconnait (q qd qa d : Ensf) (w : Word) : Prop :=
inmonoid alph w /\
(exists e1 : Elt,
(exists e2 : Elt, dans e1 qd /\ dans e2 qa /\ chemin e1 e2 q d w)).
(*									*)
(*  Si on a un chemin de e1 a e2 alors e1 et e2 sont dans q.		*)
(*									*)
intros q d.
simple induction w.
intros.
cut (Chemin e1 e2 q d nil); auto.
intro.
cut (dans e1 q /\ e1 = e2 :>Elt); auto.
intro Ht; elim Ht; auto.
intros x w0 H e1 e2 H0.
cut (Chemin e1 e2 q d (cons x w0)); auto.
intro.
cut
(exists e : Elt,
chemin e e2 q d w0 /\
dans e1 q /\ dans x alph /\ dans (couple e1 (couple x e)) d);
auto.
intro Ht; elim Ht; clear Ht.
intros e Ht; elim Ht; clear Ht.
intros H2 Ht; elim Ht; auto.
Qed.
intros q d.
simple induction w.
intros.
cut (Chemin e1 e2 q d nil); auto.
intro.
cut (dans e1 q /\ e1 = e2 :>Elt); auto.
intro Ht; elim Ht; auto.
intros.
rewrite <- H2; auto.
intros x w0 H e1 e2 H0.
cut (Chemin e1 e2 q d (cons x w0)); auto.
intro.
cut
(exists e : Elt,
chemin e e2 q d w0 /\
dans e1 q /\ dans x alph /\ dans (couple e1 (couple x e)) d);
auto.
intro Ht; elim Ht; clear Ht.
intros e Ht; elim Ht; clear Ht.
intros H2 Ht.
apply (H e e2); auto.
Qed.
(*									*)
(*  Un chemin est un mot sur X  					*)
(*									*)
simple induction w.
auto.
intros x w0 H q qd qa d H0 e1 e2 H1.
cut (Chemin e1 e2 q d (cons x w0)); auto.
intro.
cut
(exists e : Elt,
chemin e e2 q d w0 /\
dans e1 q /\ dans x alph /\ dans (couple e1 (couple x e)) d);
auto.
intro H3; elim H3; clear H3.
intros e H3; elim H3; clear H3.
intros H3 H4; elim H4; clear H4.
intros H4 H5; elim H5; clear H5; intros.
apply inmonoid_cons; auto.
apply (H q qd qa d H0 e e2); auto.
Qed.
(*									*)
(*  Si le triplet (e1,x,e2) est dans d alors on a 			*)
(*    (chemin e1 e2 q d (cons x nil))					*)
(*									*)
intros.
apply chemin_cons with e2; auto.
Qed.
(*									*)
(*  AUTOMATES ASYNCHRONES						*)
(*									*)
Definition automate_A (q qd qa d : Ensf) : Prop :=
inclus qa q /\
inclus qd q /\ inclus d (prodcart q (prodcart (add epsilon alph) q)).
intros.
elim H.
intros H0 Ht; elim Ht; auto.
Qed.
(*									*)
(*  On va definir de meme la notion de chemin sur un automate		*)
(*  asynchrone en rajoutant les transitions par epsilon.		*)
(*									*)
Inductive chemin_A (q d : Ensf) : Elt -> Elt -> Word -> Prop :=
| chemin_A_nil :
forall e1 e2 : Elt,
dans e1 q -> e1 = e2 :>Elt -> chemin_A q d e1 e2 nil
| chemin_A_cons :
forall (e1 e e2 x : Elt) (w : Word),
chemin_A q d e e2 w ->
dans e1 q ->
dans x alph ->
dans (couple e1 (couple x e)) d -> chemin_A q d e1 e2 (cons x w)
| chemin_A_epsilon :
forall (e1 e e2 : Elt) (w : Word),
chemin_A q d e e2 w ->
dans e1 q ->
dans (couple e1 (couple epsilon e)) d -> chemin_A q d e1 e2 w.
Hint Resolve chemin_A_nil.
(*  Inversion de la definition...					*)
Definition Chemin_A (q d : Ensf) (e1 e2 : Elt) (w : Word) : Prop :=
match w return Prop with
| nil =>
(* nil  *)
dans e1 q /\ e1 = e2 :>Elt \/
(exists e : Elt,
chemin_A q d e e2 nil /\
dans e1 q /\ dans (couple e1 (couple epsilon e)) d)
(* cons *)
| cons a w =>
(exists e : Elt,
chemin_A q d e e2 w /\
dans e1 q /\ dans a alph /\ dans (couple e1 (couple a e)) d) \/
(exists e : Elt,
chemin_A q d e e2 w /\
dans e1 q /\ dans (couple e1 (couple epsilon e)) d)
end.
(*  Si on a un chemin pour une relation de transition d1 alors on a	*)
(*  le meme chemin pour toute relation de transition contenant d1.	*)

Lemma chemin_A_d1_d2 :
forall (q d1 d2 : Ensf) (w : Word) (e1 e2 : Elt),
chemin_A q d1 e1 e2 w -> inclus d1 d2 -> chemin_A q d2 e1 e2 w.