(*									*)
(*  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.(*									*)
(*  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.(*									*)
(*  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.(*									*)
(*  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.(*  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.

Lemma chemin_chemin_A : forall (q d : Ensf) (w : Word) (e1 e2 : Elt), chemin e1 e2 q d w -> chemin_A q d e1 e2 w.