(* 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                                                     *)
Unset Standard Proposition Elimination Names.
(* fonction définissant la sémantique : reconnaissance d'un terme par un automate *)
Fixpoint rec_term (d : preDTA) (a : ad) (t : term)
(n : nat) {struct n} : bool :=
match n with
| O => false
| S k =>
match t with
| app c l =>
match MapGet _ d a with
| None => false
| Some lts =>
match MapGet _ lts c with
| None => false
| Some pre => rec_list_terms d pre l k
end
end
end
end
with rec_list_terms (d : preDTA) (pre : prec_list)
(l : term_list) (n : nat) {struct n} : bool :=
match n with
| O => false
| S k =>
match pre with
| prec_empty => match l with
| tnil => true
| _ => false
end
| prec_cons st stp pre' =>
match l with
| tnil => false
| tcons hd tl =>
rec_list_terms d pre' l k
|| rec_term d st hd k && rec_list_terms d stp tl k
end
end
end.
(* bornes sur l'entier décroissant (terminaison de la fonction reconnaissance *)
(* définition de la quantité d'essence (Astuce de Boyer, définition de *)
(* la reconnaissance par fixpoint...) *)
Definition essence (t : term) (d : preDTA) : nat :=
S (term_high t) * S (DTA_taille d).
(* "hauteur" d'une liste : term_high_0 *)
Definition essence_list (l : term_list) (d : preDTA)
(pl : prec_list) : nat :=
match l, pl with
| tnil, _ => 1
| _, prec_empty => 1
| _, prec_cons a la ls =>
taille_0 pl + S (term_high_0 l) * S (DTA_taille d)
end.
(* lemmes concernant la gestion de la diminution de la quantité d'essence *)
Definition dta_rec_term (d : DTA) (t : term) : bool :=
match d with
| dta p a => rec_term p a t (essence t p)
end.
(* définitions inductives pour la reconnaissance d'un terme par un automate *)
Inductive reconnaissance : preDTA -> ad -> term -> Prop :=
rec_dta :
forall (d : preDTA) (a : ad) (t : term) (ladj : state),
MapGet state d a = Some ladj ->
state_reconnait d ladj t -> reconnaissance d a t
with state_reconnait : preDTA -> state -> term -> Prop :=
rec_st :
forall (d : preDTA) (s : state) (c : ad) (tl : term_list)
(l : prec_list),
MapGet prec_list s c = Some l ->
liste_reconnait d l tl -> state_reconnait d s (app c tl)
with liste_reconnait : preDTA -> prec_list -> term_list -> Prop :=
| rec_empty : forall d : preDTA, liste_reconnait d prec_empty tnil
| rec_consi :
forall (d : preDTA) (a : ad) (la ls : prec_list)
(hd : term) (tl : term_list),
reconnaissance d a hd ->
liste_reconnait d la tl ->
liste_reconnait d (prec_cons a la ls) (tcons hd tl)
| rec_consn :
forall (d : preDTA) (a : ad) (la ls : prec_list)
(hd : term) (tl : term_list),
liste_reconnait d ls (tcons hd tl) ->
liste_reconnait d (prec_cons a la ls) (tcons hd tl).
Definition reconnait (d : DTA) (t : term) : Prop :=
match d with
| dta p a => reconnaissance p a t
end.
(* principe d'induction commun *)
Scheme mreconnaissance_ind := Induction for reconnaissance
Sort Prop
with mstrec_ind := Induction for state_reconnait
Sort Prop
with mlrec_ind := Induction for liste_reconnait Sort Prop.
(* lemmes de base sur la sémantique précédente (pour simplifier d'autres démos) *)
(* lemmes d'équivalence sémantique entre la fonction calculatoire (Fixpoint) *)
(* et la définition par Inductive *)
Definition sem_equiv_prop_t (t : term) :=
forall (d : preDTA) (a : ad) (n : nat),
rec_term d a t n = true -> reconnaissance d a t.
Definition sem_equiv_prop_l (l : term_list) :=
forall (d : preDTA) (p : prec_list) (n : nat),
rec_list_terms d p l n = true -> liste_reconnait d p l.
(* conservation de la reconnaissance d'un terme si on met plus d'essence ... *)
Definition invar_term (t : term) : Prop :=
forall (n m : nat) (d : preDTA) (a : ad),
rec_term d a t n = true -> n <= m -> rec_term d a t m = true.
Definition invar_list (tl : term_list) : Prop :=
forall (n m : nat) (d : preDTA) (p : prec_list),
rec_list_terms d p tl n = true -> n <= m -> rec_list_terms d p tl m = true.
(* Second sens de l'équivalence sémantique *)
Definition dta_reconnait (d : preDTA) (a : ad) (t : term)
(pr : reconnaissance d a t) := rec_term d a t (essence t d) = true.
Definition st_reconnait (d : preDTA) (s : state) (t : term)
(pr : state_reconnait d s t) :=
match t with
| app c l =>
exists p : prec_list,
MapGet prec_list s c = Some p /\
rec_list_terms d p l (essence_list l d p) = true
end.
Definition pre_reconnait (d : preDTA) (p : prec_list)
(t : term_list) (pr : liste_reconnait d p t) :=
rec_list_terms d p t (essence_list t d p) = true.

Lemma semantic_equiv_1_1 :
forall (d : preDTA) (s : state) (c : ad) (tl : term_list)
(l : prec_list) (e : MapGet prec_list s c = Some l)
(l0 : liste_reconnait d l tl),
pre_reconnait d l tl l0 ->
st_reconnait d s (app c tl) (rec_st d s c tl l e l0).