(* ========================================================================= *)
(*---------------------------------------------------------------------------*)
(* Description: Formalization of Zsyntax     		                         *)
(*---------------------------------------------------------------------------*)
(*                                                                           *)
(*     (c) Author :  Adnan Rashid*			                                 *)
(*      Co-Author :  Umair Siddique**					                     *)
(*      Co-Author :  Dr. Osman Hasan*					                     *)
(*                                                                           *)
(* 	   *System Analyis & Verification (SAVe) LAB                  	         *)
(*          School of Electrical Engineering and Computer Sciences           *)
(*          National University of Sciences and Technology (NUST)            *)
(*                     Islamabad, Pakistan                                   *)
(*                                                                	         *)
(*      **Hardware Verification Group                                        *)
(*          Department of Electrical and Computer Engineering                *)
(*                Concordia University, Montreal, Canada                     *)
(*                                                                           *)
(*     Contact: *<adnan.rashid@seecs.edu.pk>,                                *)
(*                                                                           *)
(* NOTE: This Script is written in HOL Light		               	         *)
(*                                                                           *)
(* ========================================================================= *)

(*===========================================================================*)
(*                Definitions of the Zsyntax Formalization                   *)
(*===========================================================================*)

let FLAT = new_recursive_definition list_RECURSION
  `(FLAT [] = []) /\
          (!h t. FLAT (CONS (h:(A)list) t) = APPEND h (FLAT t))`;;

(*  ======================================================================== *)
(*  		       Z-Syntax Fundamental Definitions                          *)
(*  ======================================================================== *)

(* ------------------------------------------------------------------------- *)
(*  		 Introduction of Z-Conjunction & Z-Interaction                   *)
(* ------------------------------------------------------------------------- *)

let zsyn_conjun_intro = new_definition
       `(zsyn_conjun_intro (l:((A) list) list) x y = CONS (FLAT [EL x l; EL y l]) l )`;;

(* ------------------------------------------------------------------------- *)
(*  		               Element Deletion			                         *)
(* ------------------------------------------------------------------------- *)

let delet = new_recursive_definition num_RECURSION
  `(delet l 0 = TL l) /\ 
  	(delet (l:(A) list) (SUC n) = CONS (HD l) (delet (TL l) n))`;;

(* ------------------------------------------------------------------------- *)
(*                          Double Element Deletion		                     *)
(* ------------------------------------------------------------------------- *)
	
let zsyn_delet = new_definition
  `( zsyn_delet (l:(A)list) x y = if (x > y) then (delet (delet l x) y) else (delet (delet l y) x))`;;

(* ------------------------------------------------------------------------- *)
(*  		          Elimination of Z-Conjunction	                         *)
(* ------------------------------------------------------------------------- *)

let zsyn_conjun_elimin = new_definition
  `( zsyn_conjun_elimin (l:(A) list) x = if (MEM x l) then [x] else l)`;;

(* ========================================================================= *)
(*  		Formal Reasoning Support for Z-Syntax Definitions                *)
(* ========================================================================= *)

(* ------------------------------------------------------------------------- *)
(*  		                EVF Matching	  		                         *)
(* ------------------------------------------------------------------------- *)

let zsyn_EVF = new_recursive_definition num_RECURSION
    `( zsyn_EVF (l:(((A)list) list)) (e:((((A)list) # (((A)list) list)) list)) 0 x y = 
			if (FST(EL 0 e) = HD l) then
					(T,(zsyn_delet (APPEND (TL l) (SND(EL 0 e))) x y)) 
			else
					(F,(TL l)))   /\
	(zsyn_EVF l e (SUC p) x y = 
			if (FST(EL (SUC p) e) = HD l) then
					(T,(zsyn_delet (APPEND (TL l) (SND(EL (SUC p) e))) x y)) 
			else
					(zsyn_EVF l e p x y) )`;;


(* ------------------------------------------------------------------------- *)
(*  		    First Recursive Function for variable n                      *)
(* ------------------------------------------------------------------------- *)

let zsyn_recurs1 = new_recursive_definition num_RECURSION
`	( zsyn_recurs1 l (e:((((A)list) # (((A)list) list)) list)) x 0 = 
					zsyn_EVF (zsyn_conjun_intro l x 0) e (LENGTH e - 1) x 0) 		/\
					
	( zsyn_recurs1 l e x (SUC y) = 
			if (FST(zsyn_EVF (zsyn_conjun_intro l x (SUC y)) e (LENGTH e - 1) x (SUC y)) = T) then
					(zsyn_EVF (zsyn_conjun_intro l x (SUC y)) e (LENGTH e - 1) x (SUC y))
			else
					(zsyn_recurs1 l e x y)) `;;

(* ------------------------------------------------------------------------- *)
(*  		   Second Recursive Function for variable m                      *)
(* ------------------------------------------------------------------------- *)

let zsyn_recurs2 = new_recursive_definition num_RECURSION
`	( zsyn_recurs2 l (e:((((A)list) # (((A)list) list)) list)) 0 y = 
			if (FST(zsyn_recurs1 l e 0 y) = T) then
					(T,SND(zsyn_recurs1 l e 0 y)) 
					else
					(F,SND(zsyn_recurs1 l e 0 y))) 		/\
					
	( zsyn_recurs2 l e (SUC x) y = 
			if (FST(zsyn_recurs1 l e (SUC x) y) = T) then
					(T,SND(zsyn_recurs1 l e (SUC x) y)) 
			else
					(zsyn_recurs2 l e x (LENGTH l - 1)))  `;;


(* ------------------------------------------------------------------------- *)
(*  		          Final Recursion Function		                         *)
(* ------------------------------------------------------------------------- *)

let zsyn_deduct_recurs = new_recursive_definition num_RECURSION
`	( zsyn_deduct_recurs l (e:((((A)list) # (((A)list) list)) list)) x y 0 = (T,l)) 		/\
	( zsyn_deduct_recurs l e x y (SUC q ) = 
			if (FST(zsyn_recurs2 l e x y) = T) then
					zsyn_deduct_recurs (SND(zsyn_recurs2 l e x y)) e (LENGTH(SND(zsyn_recurs2 l e x y))-1) (LENGTH(SND(zsyn_recurs2 l e x y))-1) q
			else
					(T,SND(zsyn_recurs2 l e (LENGTH l - 1) (LENGTH l - 1)))) `;;


let zsyn_deduct = new_definition
   `( zsyn_deduct l (e:((((A)list) # (((A)list) list)) list)) = SND (zsyn_deduct_recurs l e (LENGTH l - 1) (LENGTH l - 1) (LENGTH e)))`;;


(* ------------------------------------------------------------------------- *)
(*  		           Distinctness of Molecules		                     *)
(* ------------------------------------------------------------------------- *)

let UNIQ_MEM = new_recursive_definition list_RECURSION
    `(!x. UNIQ_MEM x [] = F) /\
            (!x (h:A) t. UNIQ_MEM x (CONS h t) = ((x = h) /\ UNIQ_MEM x t))`;;


let DISTINCT = new_recursive_definition list_RECURSION
    `(DISTINCT [] = T) /\
            (DISTINCT (CONS (h:A) t) = (~MEM h t /\ DISTINCT t))`;;


let ALL_DISTINCT = new_recursive_definition list_RECURSION
    `(ALL_DISTINCT [] = T) /\
        (ALL_DISTINCT (CONS (h:A) t) = (~MEM h t /\ ALL_DISTINCT t))`;;

(* ------------------------------------------------------------------------- *)
(*===========================================================================*)
(*         Supporting theorems used in the Formalization of Zsyntax.         *)
(*===========================================================================*)

(* ==========================================================================*)
(* Theorems List			  	                                             *)
(*---------------------------------------------------------------------------*)
(*   LENGTH_TL;  		                             		                 *)
(*   LENGTH_NOT_NULL;	                        			                 *)
(*   CONS_NOT_NULL;   		                        	             	     *)
(*   ALL_DISTINCT_EL_EQ;						     					     *) 
(*   ALL_DISTINCT_EL_IMP;								     			     *)
(*   LESS_NOT_EQ;						     	     						 *)
(*   ALL_DISTINCT_APPEND;					     	     					 *)
(*   NUM_MINUS_ONE_LT_NUM_EQ;					     	     				 *)
(*   NOT_NULL_IMP_CONS;						     	     					 *)
(*---------------------------------------------------------------------------*)

(* ------------------------------------------------------------------------- *)
(*          Some useful theorems                                             *)
(* ------------------------------------------------------------------------- *)

let G1 = prove
 (`1 = SUC 0`,
  REWRITE_TAC[BIT1; REWRITE_RULE[NUMERAL] ADD_CLAUSES; NUMERAL]);;

let G2 = prove
 (`2 = SUC 1`,
  REWRITE_TAC[BIT0; BIT1; REWRITE_RULE[NUMERAL] ADD_CLAUSES; NUMERAL]);;

let G3 = prove
 (`3 = SUC 2`,
  REWRITE_TAC[BIT0; BIT1; REWRITE_RULE[NUMERAL] ADD_CLAUSES; NUMERAL]);;

let G4 = prove
 (`4 = SUC 3`,
  REWRITE_TAC[BIT0; BIT1; REWRITE_RULE[NUMERAL] ADD_CLAUSES; NUMERAL]);;

let G5 = prove
 (`5 = SUC 4`,
  REWRITE_TAC[BIT0; BIT1; REWRITE_RULE[NUMERAL] ADD_CLAUSES; NUMERAL]);;

let G6 = prove
 (`6 = SUC 5`,
  REWRITE_TAC[BIT0; BIT1; REWRITE_RULE[NUMERAL] ADD_CLAUSES; NUMERAL]);;

let G7 = prove
 (`7 = SUC 6`,
  REWRITE_TAC[BIT0; BIT1; REWRITE_RULE[NUMERAL] ADD_CLAUSES; NUMERAL]);;

let G8 = prove
 (`8 = SUC 7`,
  REWRITE_TAC[BIT0; BIT1; REWRITE_RULE[NUMERAL] ADD_CLAUSES; NUMERAL]);;

(* ------------------------------------------------------------------------- *)
(*			          EQ_SUC											     *)
(* ------------------------------------------------------------------------- *)

let EQ_SUC = prove
 (`!m n. (SUC m = SUC n) <=> (m = n)`,
  MESON_TAC[LE_SUC; LE_ANTISYM]);;


(* ------------------------------------------------------------------------- *)
(*			         LENGTH_TL				   							     *)
(* ------------------------------------------------------------------------- *)

g `!(l:(A)list). 0 < LENGTH l ==> (LENGTH (TL l) = LENGTH l - 1)`;;

e (LIST_INDUCT_TAC);;
e (SIMP_TAC [LENGTH; TL]);;
e (ARITH_TAC);;
e (SIMP_TAC [LENGTH; TL; SUC_SUB1]);;

let LENGTH_TL = top_thm ();;

(*---------------------------------------------------------------------------*)
(*                            LENGTH_NOT_NULL                                *)
(*---------------------------------------------------------------------------*)

g `!l. 0 < LENGTH l <=> ~NULL l`;;

e (LIST_INDUCT_TAC);;
e (SIMP_TAC []);;
e (EQ_TAC);;
e (REWRITE_TAC [LENGTH]);;
e (ARITH_TAC);;
e (REWRITE_TAC [NULL]);;
e (REWRITE_TAC [NULL]);;
e (REWRITE_TAC [LENGTH]);;
e (REWRITE_TAC [LT_0]);;

let LENGTH_NOT_NULL = top_thm ();;

(*---------------------------------------------------------------------------*)
(*                            CONS_NOT_NULL                                  *)
(*---------------------------------------------------------------------------*)

g `!(l:(A)list). ~NULL l ==> (CONS (HD l) (TL l) = l)`;;

e (LIST_INDUCT_TAC);;
e (REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
e (REWRITE_TAC [LENGTH]);;
e (ARITH_TAC);;

e (REWRITE_TAC [HD; TL]);;

let CONS_NOT_NULL = top_thm ();;

(*---------------------------------------------------------------------------*)
(* 		             ALL_DISTINCT_EL_EQ  								     *)
(*---------------------------------------------------------------------------*)

g `!l. ALL_DISTINCT (l:(A) list) =
         (!n1 n2. n1 < LENGTH l /\ n2 < LENGTH l ==>
                 ((EL n1 l = EL n2 l) = (n1 = n2)))`;;

e (LIST_INDUCT_TAC);;
e (ASM_SIMP_TAC [ALL_DISTINCT; LENGTH]);;
e (ARITH_TAC);;

e (REWRITE_TAC [ALL_DISTINCT]);;
e (EQ_TAC);;
e (REPEAT STRIP_TAC);;
e (SUBGOAL_THEN `!p. p = 0 \/ (?n. p = SUC n)` ASSUME_TAC);;
      e (REWRITE_TAC [num_CASES]);;

e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `n1:num`));;
e (STRIP_TAC);;

e (SUBGOAL_THEN `!p. p = 0 \/ (?m. p = SUC m)` ASSUME_TAC);;
      e (REWRITE_TAC [num_CASES]);;

e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `n2:num`));;
e (STRIP_TAC);;
e (ASM_SIMP_TAC []);;

e (ONCE_ASM_REWRITE_TAC []);;
e (UNDISCH_TAC `n1 < LENGTH (CONS (h:A) t)`);;
e (UNDISCH_TAC `n2 < LENGTH (CONS (h:A) t)`);;
e (ONCE_ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM (K ALL_TAC));;
e (REPEAT DISCH_TAC);;
e (ASM_SIMP_TAC [EL; HD; TL]);;
e (SUBGOAL_THEN `(h = EL m (t:(A)list) <=> 0 = SUC m) = ~(h = EL m t)` ASSUME_TAC);;
      e (EQ_TAC);;
      e (STRIP_TAC);;
      e (ASM_REWRITE_TAC []);;
      e (ARITH_TAC);;

      e (SIMP_TAC []);;
      e (REWRITE_TAC [GSYM NOT_SUC]);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM MP_TAC);;
e (POP_ASSUM MP_TAC);;
e (REWRITE_TAC [LENGTH]);;
e (REWRITE_TAC [LT_SUC]);;
e (POP_ASSUM MP_TAC);;
e (POP_ASSUM MP_TAC);;
e (REWRITE_TAC [MEM_EXISTS_EL]);;
e (ASM_REWRITE_TAC []);;
e (SUBGOAL_THEN `~(?i. i < LENGTH t /\ h = EL i (t:(A)list)) = (!i. ~(i < LENGTH t) \/ ~(h = EL i t))` ASSUME_TAC);;
      e (MESON_TAC []);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_THEN (MP_TAC o SPEC `m:num`));;
e (REPEAT STRIP_TAC);;
e (ASM_MESON_TAC []);;
e (ASM_MESON_TAC []);;

e (SUBGOAL_THEN `!p. p = 0 \/ (?m. p = SUC m)` ASSUME_TAC);;
      e (REWRITE_TAC [num_CASES]);;

e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `n2:num`));;
e (STRIP_TAC);;
e (ASM_SIMP_TAC []);;

e (UNDISCH_TAC `n1 < LENGTH (CONS (h:A) t)`);;
e (UNDISCH_TAC `n2 < LENGTH (CONS (h:A) t)`);;
e (ONCE_ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM (K ALL_TAC));;
e (REPEAT DISCH_TAC);;
e (ASM_SIMP_TAC [EL; HD; TL]);;

e (SUBGOAL_THEN `(EL n (t:(A)list) = h <=> SUC n = 0) = ~(h = EL n t)` ASSUME_TAC);;
      e (EQ_TAC);;
      e (STRIP_TAC);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_REWRITE_TAC []);;
      e (ARITH_TAC);;

      e (SIMP_TAC []);;
      e (REWRITE_TAC [GSYM NOT_SUC]);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM MP_TAC);;
e (POP_ASSUM MP_TAC);;
e (REWRITE_TAC [LENGTH]);;
e (REWRITE_TAC [LT_SUC]);;
e (POP_ASSUM MP_TAC);;
e (POP_ASSUM MP_TAC);;
e (REWRITE_TAC [MEM_EXISTS_EL]);;
e (ASM_REWRITE_TAC []);;
e (SUBGOAL_THEN `~(?i. i < LENGTH t /\ h = EL i (t:(A)list)) = (!i. ~(i < LENGTH t) \/ ~(h = EL i t))` ASSUME_TAC);;
      e (MESON_TAC []);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_THEN (MP_TAC o SPEC `n:num`));;
e (REPEAT STRIP_TAC);;
e (ASM_MESON_TAC []);;
e (ASM_MESON_TAC []);;

e (ASM_REWRITE_TAC []);;
e (UNDISCH_TAC `n1 < LENGTH (CONS (h:A) t)`);;
e (UNDISCH_TAC `n2 < LENGTH (CONS (h:A) t)`);;
e (ONCE_ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM (K ALL_TAC));;
e (REWRITE_TAC [LENGTH]);;
e (REWRITE_TAC [LT_SUC]);;
e (REPEAT DISCH_TAC);;
e (ASM_SIMP_TAC [EL; HD; TL]);;
e (REWRITE_TAC [EQ_SUC]);;

e (POP_ASSUM MP_TAC);;
e (POP_ASSUM MP_TAC);;
e (POP_ASSUM MP_TAC);;
e (POP_ASSUM MP_TAC);;
e (REWRITE_TAC [MEM_EXISTS_EL]);;
e (ASM_REWRITE_TAC []);;
e (SUBGOAL_THEN `~(?i. i < LENGTH t /\ h = EL i (t:(A)list)) = (!i. ~(i < LENGTH t) \/ ~(h = EL i t))` ASSUME_TAC);;
      e (MESON_TAC []);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `n:num`));;
e (DISCH_THEN (MP_TAC o SPEC `m:num`));;
e (ASM_MESON_TAC []);;


e (REWRITE_TAC [ALL_DISTINCT]);;
e (REPEAT STRIP_TAC);;
e (POP_ASSUM MP_TAC);;
e (PURE_REWRITE_TAC [MEM_EXISTS_EL]);;
e (STRIP_TAC);;
e (FIRST_X_ASSUM (MP_TAC o SPEC `0`) );;
e (DISCH_THEN (MP_TAC o SPEC `SUC i`));;
e (REWRITE_TAC [LENGTH]);;
e (REWRITE_TAC [LT_SUC]);;
e (ASM_SIMP_TAC [EL; HD; TL]);;
e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (REPEAT STRIP_TAC);;
e (FIRST_X_ASSUM (MP_TAC o SPEC `SUC n1`) );;
e (DISCH_THEN (MP_TAC o SPEC `SUC n2`));;
e (REWRITE_TAC [LENGTH]);;
e (REWRITE_TAC [LT_SUC]);;
e (ASM_REWRITE_TAC []);;
e (ASM_SIMP_TAC [EL; HD; TL]);;
e (DISCH_TAC);;
e (REWRITE_TAC [EQ_SUC]);;

let ALL_DISTINCT_EL_EQ = top_thm ();;

(*---------------------------------------------------------------------------*)
(* 		              ALL_DISTINCT_EL_IMP 								     *)
(*---------------------------------------------------------------------------*)

g `!l n1 n2. ALL_DISTINCT (l:(A)list) /\ n1 < LENGTH l /\ n2 < LENGTH l ==>
               ((EL n1 l = EL n2 l) = (n1 = n2))`;;

e (REPEAT STRIP_TAC);;
e (UNDISCH_TAC `ALL_DISTINCT (l:(A)list)`);;
e (REWRITE_TAC [ALL_DISTINCT_EL_EQ]);;
e (DISCH_THEN (MP_TAC o SPEC `n1:num`));;
e (DISCH_THEN (MP_TAC o SPEC `n2:num`));;
e (ASM_REWRITE_TAC []);;

let ALL_DISTINCT_EL_IMP = top_thm ();;

(*---------------------------------------------------------------------------*)
(*                              LESS_NOT_EQ		 						     *)
(*---------------------------------------------------------------------------*)

g `!m n. (m:num) < n ==> ~(m = n)`;;

e (REPEAT GEN_TAC);;
e (DISCH_TAC);;
e (REWRITE_TAC [GSYM LE_ANTISYM]);;
e (REWRITE_TAC [DE_MORGAN_THM]);;
e (DISJ2_TAC);;
e (ASM_REWRITE_TAC [NOT_LE]);;

let LESS_NOT_EQ = top_thm ();;

(*---------------------------------------------------------------------------*)
(* 	          	     ALL_DISTINCT_APPEND 		   				             *)
(*---------------------------------------------------------------------------*)

g `!(l1:(A)list) l2. ALL_DISTINCT (APPEND l1 l2) =
             (ALL_DISTINCT l1 /\ ALL_DISTINCT l2 /\
             (!e. MEM e l1 ==> ~(MEM e l2)))`;;

e (LIST_INDUCT_TAC);;
e (ASM_SIMP_TAC [ALL_DISTINCT; MEM; APPEND]);;

e (ASM_SIMP_TAC [ALL_DISTINCT; MEM; APPEND]);;
e (REWRITE_TAC [MEM_APPEND]);;
e (REWRITE_TAC [DE_MORGAN_THM]);;
e (MESON_TAC []);;

let ALL_DISTINCT_APPEND = top_thm ();;

(*---------------------------------------------------------------------------*)
(* 			   NUM_MINUS_ONE_LT_NUM_EQ		       						     *)
(*---------------------------------------------------------------------------*)

g `!x. (0 < x) = (x - 1 < x)`;;

e (ARITH_TAC);;

let NUM_MINUS_ONE_LT_NUM_EQ  = top_thm ();;

(*---------------------------------------------------------------------------*)
(*		               NOT_NULL_IMP_CONS	         			             *)
(*---------------------------------------------------------------------------*)

g `!(l:(A)list). ~NULL l ==> (CONS (HD l) (TL l) = l)`;;

e (STRIP_TAC);;
e (SUBGOAL_THEN `!l:(A)list. (l = []) \/ ?h t. l = CONS h t` ASSUME_TAC);;
      e (REWRITE_TAC [list_CASES]);;

e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `l:(A)list`));;
e (STRIP_TAC);;
e (ASM_SIMP_TAC []);;
e (ASM_MESON_TAC [NULL]);;

e (ASM_SIMP_TAC []);;
e (STRIP_TAC);;
e (REWRITE_TAC [HD; TL]);;

let NOT_NULL_IMP_CONS = top_thm ();;


(*---------------------------------------------------------------------------*)
(*		               ALL_DISTINCT_APPEND_1	           		             *)
(*---------------------------------------------------------------------------*)

g `!(l1:(A)list) l2.
         ALL_DISTINCT (APPEND l1 l2) <=>
         ALL_DISTINCT l1 /\ ALL_DISTINCT l2 /\ (!a. MEM a l1 ==> ~MEM a l2)`;;

e (REWRITE_TAC [ALL_DISTINCT_APPEND]);;

let ALL_DISTINCT_APPEND_1 = top_thm ();;

(* ------------------------------------------------------------------------- *)
(*===========================================================================*)
(*        Theorems regarding Element Deletion used in the 
                          Verification of the Properties of Zsyntax.         *)
(*===========================================================================*)

(* ==========================================================================*)
(* Theorems List			  			                     			     *)
(*---------------------------------------------------------------------------*)
(*   delet_ASSOC_THM;					                   				     *)
(*   delet_LENGTH_THM;				                      			         *)
(*   delet_MEM_THM;   					                   			 	     *)
(*   delet_EL_THM;    							     		 		 	     *)
(*   delet_DISTINCT_THM;											    	 *)
(*   delet_NOT_MEM_THM;							   						     *)
(*---------------------------------------------------------------------------*)

(* ------------------------------------------------------------------------- *)
(*			       delet_ASSOC_THM	                            		     *)
(* ------------------------------------------------------------------------- *)

g `!(e:(((A)list) list)) (x:num) (l:(((A)list) list)).
     (x < LENGTH l)
     ==> ((delet (APPEND l e) x) = (APPEND (delet l x) e))`;;

e (GEN_TAC);;
e (INDUCT_TAC);;
e (SIMP_TAC [delet]);;
e (LIST_INDUCT_TAC);;
e (REWRITE_TAC [LENGTH]);;
e (ARITH_TAC);;
e (REPEAT STRIP_TAC);;
e (ASM_SIMP_TAC [APPEND; TL]);;

e (SIMP_TAC [delet]);;
e (STRIP_TAC);;
e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `TL (l:(((A)list) list))`));;
e (REWRITE_TAC [LENGTH_TL]);;
e (REPEAT DISCH_TAC);;
e (SUBGOAL_THEN `x < LENGTH (TL (l:(((A)list) list)))` ASSUME_TAC);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (ASM_ARITH_TAC);;

e (UNDISCH_TAC `(x:num) < LENGTH (TL (l:((A)list)list)) ==> delet (APPEND (TL l) e) x = APPEND (delet (TL l) x) e`);;
e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_TAC);;
e (SUBGOAL_THEN `!L M. ((0 < LENGTH L) ==> ((TL (APPEND (L:(((A)list) list)) M)) = (APPEND (TL L) M)))`  ASSUME_TAC);;
      e (LIST_INDUCT_TAC);;
      e (REWRITE_TAC [LENGTH]);;
      e (ARITH_TAC);;

      e (REPEAT STRIP_TAC);;
      e (REWRITE_TAC [APPEND]);;
      e (REWRITE_TAC [TL]);;
      e (POP_ASSUM MP_TAC);;
      e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
      e (DISCH_THEN (MP_TAC o SPEC `(e:(((A)list) list))`));;
      e (SUBGOAL_THEN `0 < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
            e (MATCH_MP_TAC LT_TRANS);;
	    e (EXISTS_TAC `SUC x`);;
	    e (ASM_REWRITE_TAC []);;
	    e (ARITH_TAC);;
      
      e (ASM_REWRITE_TAC []);;
      e (SIMP_TAC []);;
      e (DISCH_TAC);;
      e (SUBGOAL_THEN `!L M. (0 < LENGTH L) ==> (HD (APPEND (L:(((A)list) list)) M) = HD (L))` ASSUME_TAC);;
            e (LIST_INDUCT_TAC);;
	    e (REWRITE_TAC [LENGTH]);;
      	    e (ARITH_TAC);;

      	    e (REPEAT STRIP_TAC);;
      	    e (REWRITE_TAC [HD]);;
	    e (REWRITE_TAC [APPEND]);;
      	    e (REWRITE_TAC [HD]);;

      	    e (SUBGOAL_THEN `0 < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
                  e (MATCH_MP_TAC LT_TRANS);;
	    	  e (EXISTS_TAC `SUC x`);;
	    	  e (ASM_REWRITE_TAC []);;
	    	  e (ARITH_TAC);;

            e (UNDISCH_TAC `!(L:(((A)list) list)) M. 0 < LENGTH L ==> HD (APPEND L M) = HD L`);;
      	    e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
      	    e (DISCH_THEN (MP_TAC o SPEC `(e:(((A)list) list))`));;
	    e (ASM_REWRITE_TAC []);;
	    e (SIMP_TAC []);;
	    e (DISCH_TAC);;
	    e (REWRITE_TAC [APPEND]);;

let delet_ASSOC_THM = top_thm ();;

(* ------------------------------------------------------------------------- *)
(*                             delet_LENGTH_THM                              *)
(* ------------------------------------------------------------------------- *)

g `!(x:num) (l:(((A) list) list)).
    (x < LENGTH l) ==> (LENGTH (delet l x) = LENGTH l - 1)`;;

e (INDUCT_TAC);;
e (SIMP_TAC [delet; LENGTH_TL]);;

e (REPEAT STRIP_TAC);;
e (SIMP_TAC [delet]);;
e (SUBGOAL_THEN `~NULL (l:(((A)list) list))` ASSUME_TAC);;
      e (SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ASM_SIMP_TAC [LENGTH_NOT_NULL]);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC [CONS_NOT_NULL]);;

e (ONCE_ASM_REWRITE_TAC []);;
e (REWRITE_TAC [LENGTH]);;
e (REWRITE_TAC [TL]);;
e (REWRITE_TAC [SUC_SUB1]);;
e (UNDISCH_TAC `!(l:(((A)list) list)). (x:num) < LENGTH l ==> LENGTH (delet l x) = LENGTH l - 1`);;
e (DISCH_THEN (MP_TAC o SPEC `TL (l:(((A)list) list))`));;
e (SUBGOAL_THEN `(x < (LENGTH (TL l:(((A) list) list))))` ASSUME_TAC);;
      e (ASM_SIMP_TAC [LENGTH_TL; LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (SIMP_TAC []);;
e (DISCH_TAC);;
e (REWRITE_TAC [ADD1]);;
e (REWRITE_TAC [GSYM REAL_OF_NUM_EQ]);;
e (REWRITE_TAC [GSYM REAL_OF_NUM_ADD]);;
e (REWRITE_TAC [REAL_ARITH `(((x + &1) = y) = (x = (y - &1)))`]);;
e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
e (ASM_ARITH_TAC);;

let delet_LENGTH_THM = top_thm ();;

(* ------------------------------------------------------------------------- *)
(*			      delet_MEM_THM        			                             *)
(* ------------------------------------------------------------------------- *)

g `!a (x:num) (l:(((A) list) list)).
    (x < LENGTH l) /\ MEM a (delet l x)
    ==> (MEM a l)`;;

e (GEN_TAC);;
e (INDUCT_TAC);;
e (SIMP_TAC []);;
e (LIST_INDUCT_TAC);;
e (REWRITE_TAC [LENGTH]);;
e (ARITH_TAC);;
e (SIMP_TAC [LENGTH; delet; HD; MEM; TL]);;
e (REPEAT STRIP_TAC);;
e (UNDISCH_TAC `!l. x < LENGTH (l:(((A)list) list)) /\ MEM a (delet l x) ==> MEM a l`);;
e (DISCH_THEN (MP_TAC o SPEC `TL (l:(((A)list) list))`));;
e (DISCH_TAC);;
e (SUBGOAL_THEN `~NULL (l:(((A)list) list))` ASSUME_TAC);;
      e (SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ASM_SIMP_TAC [LENGTH_NOT_NULL]);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC [CONS_NOT_NULL]);;

e (ONCE_ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `(x < (LENGTH (TL l:(((A) list) list))))` ASSUME_TAC);;
      e (ASM_SIMP_TAC [LENGTH_TL; LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (UNDISCH_TAC `x < LENGTH (TL l:(((A) list) list)) /\ MEM a (delet (TL l) x) ==> MEM a (TL l)`);;
e (ASM_REWRITE_TAC []);;
e (DISCH_TAC);;
e (UNDISCH_TAC `MEM (a:(A)list) (delet (l:(((A) list) list)) (SUC x))`);;
e (REWRITE_TAC [delet]);;
e (DISCH_TAC);;
e (ASM_CASES_TAC `a = HD (l:((A)list)list)`);;
e (ASM_SIMP_TAC [MEM; HD; TL]);;
e (UNDISCH_TAC `MEM a (CONS (HD (l:(((A) list) list))) (delet (TL l) x))`);;
e (ASM_SIMP_TAC [MEM]);;

let delet_MEM_THM = top_thm ();;

(* ------------------------------------------------------------------------- *)
(*			        delet_EL_THM             	                      		 *)
(* ------------------------------------------------------------------------- *)

g `!(x:num) (y:num) (l:(((A)list) list)).
     x < y /\ y < LENGTH l /\ 1 < LENGTH l
     ==> (EL x l = EL x (delet l y))`;;

e (INDUCT_TAC);;

e (INDUCT_TAC);;
e (ARITH_TAC);;
e (SIMP_TAC [HD; EL; delet]);;

e (REWRITE_TAC [EL]);;
e (SUBGOAL_THEN `!y x l. (SUC x < y /\ y < LENGTH l /\ 1 < LENGTH l) 
       ==> ((TL (delet (l:(((A) list) list)) y)) =(delet (TL l) (y - 1)))` ASSUME_TAC);;
      e (INDUCT_TAC);;
      e (ARITH_TAC);;

      e (REWRITE_TAC [LT_SUC]);;
      e (REPEAT STRIP_TAC);;
      e (REWRITE_TAC [delet; HD; TL]);;
      e (REWRITE_TAC [SUC_SUB1]);;

e (REPEAT STRIP_TAC);;
e  (UNDISCH_TAC `!y x l.
          SUC x < y /\ y < LENGTH l /\ 1 < LENGTH l
          ==> TL (delet (l:(((A)list) list)) y) = delet (TL l) (y - 1)`);;
e (DISCH_THEN (MP_TAC o SPEC `(y:num)`));;
e (DISCH_THEN (MP_TAC o SPEC `(x:num)`));;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (ASM_REWRITE_TAC []);;
e (DISCH_TAC);;
e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (UNDISCH_TAC `!(y:num) (l:(((A)list) list)). x < y /\ y < LENGTH l /\ 1 < LENGTH l ==> EL x l = EL x (delet l y)`);;
e (DISCH_THEN (MP_TAC o SPEC `((y:num) - 1)`));;
e (DISCH_THEN (MP_TAC o SPEC `TL (l:(((A)list) list))`));;
e (SIMP_TAC [LENGTH_TL]);;

e (SUBGOAL_THEN `0 < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
      e (MATCH_MP_TAC LT_TRANS);;
      e (EXISTS_TAC `1`);;
      e (ASM_REWRITE_TAC []);;
      e (ARITH_TAC);;

e (SUBGOAL_THEN `LENGTH (TL l) = LENGTH (l:(((A)list) list)) - 1` ASSUME_TAC);;
      e (MATCH_MP_TAC LENGTH_TL);;
      e (ASM_REWRITE_TAC []);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `x < y - 1` ASSUME_TAC);;
      e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      e (SUBGOAL_THEN `&(y - 1) = &y - &1` ASSUME_TAC);;
            e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    e (MATCH_MP_TAC LT_IMP_LE);;
	    e (MATCH_MP_TAC LET_TRANS);;
	    e (EXISTS_TAC `SUC x`);;
      	    e (ASM_REWRITE_TAC []);;
      	    e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (REWRITE_TAC [REAL_ARITH `(&x < &y - &1) = (&x + &1 < &y)`]);;
      e (REWRITE_TAC [REAL_OF_NUM_ADD]);;
      e (REWRITE_TAC [REAL_OF_NUM_LT]);;
      e (ASM_REWRITE_TAC [GSYM ADD1]);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `y - 1 < LENGTH (l:(((A)list) list)) - 1` ASSUME_TAC);;
      e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      e (SUBGOAL_THEN `&(y - 1) = &y - &1` ASSUME_TAC);;
            e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    e (MATCH_MP_TAC LT_IMP_LE);;
	    e (MATCH_MP_TAC LET_TRANS);;
	    e (EXISTS_TAC `SUC x`);;
      	    e (ASM_REWRITE_TAC []);;
      	    e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (SUBGOAL_THEN `&(LENGTH (l:(((A)list) list)) - 1) = &(LENGTH l) - &1` ASSUME_TAC);;
            e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    e (MATCH_MP_TAC LT_IMP_LE);;
      	    e (ASM_REWRITE_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (REWRITE_TAC [REAL_ARITH `(&y - &1 < &(LENGTH (l:(((A)list) list))) - &1) = (&y < &(LENGTH l))`]);;
      e (ASM_REWRITE_TAC [REAL_OF_NUM_LT]);;

e (ASM_REWRITE_TAC []);;


e (SUBGOAL_THEN `1 < LENGTH (l:(((A)list) list)) - 1` ASSUME_TAC);;
      e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      e (SUBGOAL_THEN `&(LENGTH (l:(((A)list) list)) - 1) = &(LENGTH l) - &1` ASSUME_TAC);;
            e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    e (MATCH_MP_TAC LT_IMP_LE);;
      	    e (ASM_REWRITE_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (REWRITE_TAC [REAL_ARITH `(&1 < &(LENGTH (l:(((A)list) list))) - &1) = (&2 < &(LENGTH l))`]);;
      e (REWRITE_TAC [REAL_OF_NUM_LT]);;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;

let delet_EL_THM = top_thm ();;

(* ------------------------------------------------------------------------- *)
(*				delet_DISTINCT_THM			                                 *)
(* ------------------------------------------------------------------------- *)

g `!(y:num) (l:(((A)list) list)).
     y < LENGTH l /\ ALL_DISTINCT l
     ==> ALL_DISTINCT (delet l y)`;;

e (INDUCT_TAC);;
e (REWRITE_TAC [delet]);;
e (REPEAT STRIP_TAC);;
e (SUBGOAL_THEN `~NULL (l:(((A)list) list))` ASSUME_TAC);;
      e (SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ASM_SIMP_TAC [LENGTH_NOT_NULL]);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC [CONS_NOT_NULL]);;

e (ONCE_ASM_REWRITE_TAC []);;
e (SUBGOAL_THEN `(ALL_DISTINCT (l:(((A)list) list)) = (ALL_DISTINCT (CONS (HD l) (TL l))))` ASSUME_TAC);;
      e (ONCE_ASM_REWRITE_TAC[]);;
      e (REWRITE_TAC [HD; TL; LENGTH_NOT_NULL]);;
      e (POP_ASSUM MP_TAC);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC []);;

e (UNDISCH_TAC `ALL_DISTINCT (l:(((A)list) list))`);;
e (ASM_REWRITE_TAC []);;
e (SIMP_TAC [ALL_DISTINCT]);;
e (ASM_MESON_TAC []);;


e (REWRITE_TAC [delet]);;
e (REPEAT STRIP_TAC);;
e (SIMP_TAC [ALL_DISTINCT]);;
e (STRIP_TAC);;

r (1);;

e (UNDISCH_TAC `!(l:(((A)list) list)). y < LENGTH l /\ ALL_DISTINCT l ==> ALL_DISTINCT (delet l y)`);;
e (DISCH_THEN (MP_TAC o SPEC `TL (l:(((A)list) list))`));;
e (STRIP_TAC);;

e (SUBGOAL_THEN `~NULL (l:(((A)list) list))` ASSUME_TAC);;
      e (SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ASM_SIMP_TAC [LENGTH_NOT_NULL]);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC [CONS_NOT_NULL]);;

e (ONCE_ASM_REWRITE_TAC[]);;
e (SUBGOAL_THEN `(ALL_DISTINCT (l:(((A)list) list)) = (ALL_DISTINCT (CONS (HD l) (TL l))))` ASSUME_TAC);;
      e (ONCE_ASM_REWRITE_TAC[]);;
      e (REWRITE_TAC [HD; TL; LENGTH_NOT_NULL]);;
      e (POP_ASSUM MP_TAC);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC []);;

e (POP_ASSUM MP_TAC);;
e (SIMP_TAC [ALL_DISTINCT]);;
e (DISCH_TAC);;
e (UNDISCH_TAC `ALL_DISTINCT (l:(((A)list) list))`);;
e (ASM_REWRITE_TAC []);;
e (STRIP_TAC);;
e (SIMP_TAC [TL]);;
e (UNDISCH_TAC `y < LENGTH (TL (l:(((A)list) list))) /\ ALL_DISTINCT (TL l)
      ==> ALL_DISTINCT (delet (TL l) y)`);;
e (ASM_REWRITE_TAC []);;
e (SUBGOAL_THEN `y < LENGTH (TL (l:(((A)list) list)))` ASSUME_TAC);;
      e (SUBGOAL_THEN `LENGTH (TL l) = LENGTH (l:(((A)list) list)) - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
      	    e (MATCH_MP_TAC LT_TRANS);;
	    e (EXISTS_TAC `SUC y`);;
      	    e (ASM_REWRITE_TAC []);;
	    e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;

      e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      e (SUBGOAL_THEN `&(LENGTH (l:(((A)list) list)) - 1) = &(LENGTH l) - &1` ASSUME_TAC);;
            e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    e (MATCH_MP_TAC LT_IMP_LE);;
	    e (MATCH_MP_TAC LET_TRANS);;
	    e (EXISTS_TAC `SUC y`);;
      	    e (ASM_SIMP_TAC []);;
      	    e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (REWRITE_TAC [REAL_ARITH `(&y < &(LENGTH (l:(((A)list) list))) - &1) = (&y + &1 < &(LENGTH l))`]);;
      e (REWRITE_TAC [REAL_OF_NUM_ADD]);;
      e (ASM_REWRITE_TAC [REAL_OF_NUM_LT]);;
      e (ASM_REWRITE_TAC [GSYM ADD1]);;

e (ASM_REWRITE_TAC []);;


e (SUBGOAL_THEN `ALL_DISTINCT (l:(((A)list) list))` ASSUME_TAC);;
      e (ASM_REWRITE_TAC []);;

e (POP_ASSUM MP_TAC);;
e (ONCE_REWRITE_TAC [GSYM CONTRAPOS_THM]);;
e (SIMP_TAC []);;
e (DISCH_TAC);;

e (SUBGOAL_THEN `MEM (HD l) (TL(l:(((A)list) list)))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_MEM_THM);;
      e (EXISTS_TAC `y:num`);;
      e (ASM_SIMP_TAC []);;

      e (SUBGOAL_THEN `LENGTH (TL l) = LENGTH (l:(((A)list) list)) - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
      	    e (MATCH_MP_TAC LT_TRANS);;
	    e (EXISTS_TAC `SUC y`);;
      	    e (ASM_REWRITE_TAC []);;
	    e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;

      e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      e (SUBGOAL_THEN `&(LENGTH (l:(((A)list) list)) - 1) = &(LENGTH l) - &1` ASSUME_TAC);;
            e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    e (MATCH_MP_TAC LT_IMP_LE);;
	    e (MATCH_MP_TAC LET_TRANS);;
	    e (EXISTS_TAC `SUC y`);;
      	    e (ASM_SIMP_TAC []);;
      	    e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (REWRITE_TAC [REAL_ARITH `(&y < &(LENGTH (l:(((A)list) list))) - &1) = (&y + &1 < &(LENGTH l))`]);;
      e (REWRITE_TAC [REAL_OF_NUM_ADD]);;
      e (ASM_REWRITE_TAC [REAL_OF_NUM_LT]);;
      e (ASM_REWRITE_TAC [GSYM ADD1]);;

e (SUBGOAL_THEN `~NULL (l:(((A)list) list))` ASSUME_TAC);;
      e (SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ASM_SIMP_TAC [LENGTH_NOT_NULL]);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC [CONS_NOT_NULL]);;

e (SUBGOAL_THEN `(ALL_DISTINCT (l:(((A)list) list)) = (ALL_DISTINCT (CONS (HD l) (TL l))))` ASSUME_TAC);;
      e (ONCE_ASM_REWRITE_TAC[]);;
      e (REWRITE_TAC [HD; TL; LENGTH_NOT_NULL]);;
      e (POP_ASSUM MP_TAC);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC []);;

e (POP_ASSUM MP_TAC);;
e (REWRITE_TAC [ALL_DISTINCT]);;
e (SIMP_TAC []);;
e (DISCH_TAC);;
e (REWRITE_TAC [DE_MORGAN_THM]);;
e (DISJ1_TAC);;
e (ASM_REWRITE_TAC []);;

let delet_DISTINCT_THM = top_thm ();;

(* ------------------------------------------------------------------------- *)
(*			       delet_NOT_MEM_THM			                             *)
(* ------------------------------------------------------------------------- *)

g `!(x:num) (l:(((A)list) list)).
     ALL_DISTINCT l /\ x < LENGTH l
     ==> (~MEM (EL x l) (delet l x))`;;

e (INDUCT_TAC);;
e (REWRITE_TAC [EL; delet]);;
e (GEN_TAC);;
e (STRIP_TAC);;

e (SUBGOAL_THEN `~NULL (l:(((A)list) list))` ASSUME_TAC);;
      e (SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ASM_SIMP_TAC [LENGTH_NOT_NULL]);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC [CONS_NOT_NULL]);;

e (SUBGOAL_THEN `(ALL_DISTINCT (l:(((A)list) list)) = (ALL_DISTINCT (CONS (HD l) (TL l))))` ASSUME_TAC);;
      e (ONCE_ASM_REWRITE_TAC[]);;
      e (REWRITE_TAC [HD; TL; LENGTH_NOT_NULL]);;
      e (POP_ASSUM MP_TAC);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC []);;

e (POP_ASSUM MP_TAC);;
e (REWRITE_TAC [ALL_DISTINCT]);;
e (DISCH_TAC);;
e (UNDISCH_TAC `ALL_DISTINCT (l:(((A)list) list))`);;
e (ASM_REWRITE_TAC []);;
e (SIMP_TAC []);;

e (SIMP_TAC [MEM; delet]);;
e (GEN_TAC);;
e (STRIP_TAC);;
e (REWRITE_TAC [DE_MORGAN_THM]);;
e (STRIP_TAC);;
e (STRIP_TAC);;
e (SUBGOAL_THEN `(EL (SUC x) l = EL 0 (l:(((A)list) list))) <=> (SUC x = 0)` ASSUME_TAC);;
      e (MATCH_MP_TAC ALL_DISTINCT_EL_IMP);;
      e (ASM_SIMP_TAC []);;
      e (ASM_ARITH_TAC);;

e (POP_ASSUM MP_TAC);;
e (PURE_REWRITE_TAC [HD; EL]);;
e (POP_ASSUM MP_TAC);;
e (PURE_REWRITE_TAC [EL]);;
e (REPEAT DISCH_TAC);;
e (UNDISCH_TAC `EL x (TL (l:(((A)list) list))) = HD l`);;
e (ASM_SIMP_TAC []);;
e (ARITH_TAC);;

e (REWRITE_TAC [EL]);;
e (UNDISCH_TAC `!l. ALL_DISTINCT (l:(((A)list) list)) /\ x < LENGTH l ==> ~MEM (EL x l) (delet l x)`);;
e (DISCH_THEN (MP_TAC o SPEC `TL (l:(((A)list) list))`));;
e (SUBGOAL_THEN `x < LENGTH (TL (l:(((A)list) list)))` ASSUME_TAC);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_TAC);;

e (SUBGOAL_THEN `~NULL (l:(((A)list) list))` ASSUME_TAC);;
      e (SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ASM_SIMP_TAC [LENGTH_NOT_NULL]);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC [CONS_NOT_NULL]);;

e (SUBGOAL_THEN `(ALL_DISTINCT (l:(((A)list) list)) = (ALL_DISTINCT (CONS (HD l) (TL l))))` ASSUME_TAC);;
      e (ONCE_ASM_REWRITE_TAC[]);;
      e (REWRITE_TAC [HD; TL; LENGTH_NOT_NULL]);;
      e (POP_ASSUM MP_TAC);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC []);;

e (POP_ASSUM MP_TAC);;
e (REWRITE_TAC [ALL_DISTINCT]);;
e (DISCH_TAC);;
e (UNDISCH_TAC `ALL_DISTINCT (L:(((A)list) list))`);;
e (ASM_REWRITE_TAC []);;
e (STRIP_TAC);;
e (ASM_MESON_TAC []);;

let delet_NOT_MEM_THM = top_thm();;

(*===========================================================================*)
(*     Theorems regarding Element Deletion of the Reactants 
                             Verification of the Properties of Zsyntax.      *)
(*===========================================================================*)

(* ========================================================================= *)
(* Theorems List			  			             						 *)
(*---------------------------------------------------------------------------*)
(*   zsyn_delet_LENGTH_THM;							                         *)
(*   zsyn_delet_MEM_THM;				                                     *)
(*   zsyn_delet_ASSOC_THM;							                         *)
(*   zsyn_delet_NOT_MEM_THM;							                     *)
(*---------------------------------------------------------------------------*)
 
(*---------------------------------------------------------------------------*)
(* 			      zsyn_delet_LENGTH_THM		    	                 	     *)
(*---------------------------------------------------------------------------*)

g `!(x:num) y (l:(((A)list) list)).
    (1 < LENGTH l) /\ (x < LENGTH l) /\ (y < LENGTH l) /\ ~(x = y)
    ==> (LENGTH (zsyn_delet l x y) = LENGTH l - 2)`;;

e (INDUCT_TAC);;
e (SIMP_TAC [zsyn_delet; delet]);;
e (REPEAT STRIP_TAC);;
e (COND_CASES_TAC);;

(*- BASE CASE--*)

e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(!y. (TL (delet (l:(((A)list) list)) y)) =(delet (TL l) (y - 1)))` ASSUME_TAC);;
      e (INDUCT_TAC);;
      e (ASM_SIMP_TAC [delet; TL]);;
      e (SUBGOAL_THEN `(0 - 1) = 0` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ASM_REWRITE_TAC [delet]);;

      e (REWRITE_TAC [delet; HD; TL]);;
      e (SUBGOAL_THEN `SUC y' - 1 = y'` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ASM_REWRITE_TAC [delet]);;

e (ASM_SIMP_TAC []);;
e (SUBGOAL_THEN `LENGTH (delet (TL (l:(((A)list) list))) (y - 1)) = (LENGTH (TL l) - 1)` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_LENGTH_THM);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (ASM_ARITH_TAC);;

e (ONCE_ASM_REWRITE_TAC []);;
e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
      e (MATCH_MP_TAC LENGTH_TL);;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (ASM_ARITH_TAC);;

(*- SUC CASE--*)

e (REPEAT STRIP_TAC);;
e (SIMP_TAC [zsyn_delet; delet]);;
e (COND_CASES_TAC);;
e (SUBGOAL_THEN `LENGTH (delet (CONS (HD l) (delet (TL (l:(((A)list) list))) x)) y) = (LENGTH (CONS (HD l) (delet (TL l) x)) - 1)` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_LENGTH_THM);;
      e (SIMP_TAC [LENGTH]);;
      e (SUBGOAL_THEN `LENGTH (delet (TL (l:(((A)list) list))) x) = (LENGTH (TL l) - 1)` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_LENGTH_THM);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (ONCE_ASM_REWRITE_TAC[]);;
e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
      e (MATCH_MP_TAC LENGTH_TL);;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (ASM_ARITH_TAC);;

e (ONCE_ASM_REWRITE_TAC []);;
e (POP_ASSUM MP_TAC);;
e (REWRITE_TAC [LENGTH]);;
e (SUBGOAL_THEN `(SUC (LENGTH (delet (TL (l:(((A)list) list))) x)) - 1) = (LENGTH (delet (TL l) x))` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (STRIP_TAC);;
e (SUBGOAL_THEN `~NULL (l:(((A)list) list))` ASSUME_TAC);;
      e (SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ASM_SIMP_TAC [LENGTH_NOT_NULL]);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (ASM_SIMP_TAC [CONS_NOT_NULL]);;

e (ONCE_ASM_REWRITE_TAC []);;
e (SIMP_TAC [LENGTH]);;
e (SIMP_TAC [TL]);;
e (SIMP_TAC [ADD1]);;
e (SUBGOAL_THEN `((LENGTH (TL (l:(((A)list) list))) + 1) - 2) = (LENGTH (TL l) - 1)` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (ONCE_ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (SIMP_TAC [TL]);;
e (MATCH_MP_TAC delet_LENGTH_THM);;
e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
      e (MATCH_MP_TAC LENGTH_TL);;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (ASM_ARITH_TAC);;
e (POP_ASSUM MP_TAC);;
e (SUBGOAL_THEN `~(SUC x > y) = (SUC x <= y)` ASSUME_TAC);;
      e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `(SUC x <= y) = ((SUC x < y) \/ (SUC x = y))` ASSUME_TAC);;
      e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_TAC);;
e (SIMP_TAC [GSYM delet]);;
e (SUBGOAL_THEN `LENGTH (delet (delet (l:(((A)list) list)) y) (SUC x)) = LENGTH (delet l y) - 1` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_LENGTH_THM);;
      e (SUBGOAL_THEN `LENGTH (delet l y) = LENGTH (l:(((A)list) list)) - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC delet_LENGTH_THM);;
	    e (ASM_REWRITE_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (ONCE_ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `LENGTH (delet (l:(((A)list) list)) y) = LENGTH l - 1` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_LENGTH_THM);;
      e (ASM_REWRITE_TAC []);;

e (ONCE_ASM_REWRITE_TAC []);;
e (ARITH_TAC);;

let zsyn_delet_LENGTH_THM = top_thm ();;

(*---------------------------------------------------------------------------*)
(*				zsyn_delet_MEM_THM				                             *)
(*---------------------------------------------------------------------------*)

g `!(x:num) a (y:num) (l:(((A)list) list)).
    1 < LENGTH l /\ (x < LENGTH l) /\ (y < LENGTH l) /\
    ~(x = y) /\ MEM a (zsyn_delet l x y) 
    ==> MEM a l`;;

e (INDUCT_TAC);;
e (SIMP_TAC [zsyn_delet; delet]);;
e (REPEAT STRIP_TAC);;
e (SUBGOAL_THEN `0 < y` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (UNDISCH_TAC `~(0 = y)`);;
e (DISCH_TAC);;
e (POP_ASSUM (K ALL_TAC));;
e (UNDISCH_TAC `MEM a (if 0 > y then delet (TL (l:(((A)list) list))) y else TL (delet l y))`);;
e (COND_CASES_TAC);;
e (ASM_ARITH_TAC);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `(!y. (TL (delet (l:(((A)list) list)) y)) =(delet (TL l) (y - 1)))` ASSUME_TAC);;
      e (INDUCT_TAC);;
      e (ASM_SIMP_TAC [delet; TL]);;
      e (SUBGOAL_THEN `(0 - 1) = 0` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ASM_REWRITE_TAC [delet]);;

      e (REWRITE_TAC [delet; HD; TL]);;
      e (SUBGOAL_THEN `SUC y' - 1 = y'` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ASM_REWRITE_TAC [delet]);;

e (ASM_SIMP_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_TAC);;
e (SUBGOAL_THEN `(y - 1) < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (MATCH_MP_TAC CONS_NOT_NULL);;
      e (ASM_SIMP_TAC [GSYM LENGTH_NOT_NULL]);;

e (ONCE_ASM_REWRITE_TAC []);;
e (ASM_CASES_TAC `a = HD (l:(((A)list) list))`);;
      e (REWRITE_TAC [MEM]);;
      e (DISJ1_TAC);;
      e (ASM_REWRITE_TAC []);;

      e (SIMP_TAC [MEM; HD; TL]);;
      e (DISJ2_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
      e (POP_ASSUM (K ALL_TAC));;
      e (MATCH_MP_TAC delet_MEM_THM);;
      e (EXISTS_TAC `y - 1`);;
      e (ASM_REWRITE_TAC []);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
      	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

(*---Step Case---*)

e (REPEAT STRIP_TAC);;
e (POP_ASSUM MP_TAC);;
e (UNDISCH_TAC `!a y (l:(((A)list) list)).
          1 < LENGTH l /\
          x < LENGTH l /\
          y < LENGTH l /\
          ~(x = y) /\
          MEM a (zsyn_delet l x y)
          ==> MEM a l`);;
e (SIMP_TAC [zsyn_delet; delet]);;
e (STRIP_TAC);;
e (COND_CASES_TAC);;
e (STRIP_TAC);;
e (SUBGOAL_THEN `MEM a (CONS (HD l) (delet (TL (l:(((A)list) list))) x))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_MEM_THM);;
      e (EXISTS_TAC `y:num`);;
      e (ASM_REWRITE_TAC [LENGTH]);;
      e (SUBGOAL_THEN `(LENGTH (delet (TL (l:(((A)list) list))) x)) = LENGTH (TL l) - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC delet_LENGTH_THM);;
	    e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
	          e (MATCH_MP_TAC LENGTH_TL);;
      		  e (ASM_ARITH_TAC);;

            e (ASM_REWRITE_TAC []);;
	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
      	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `~NULL (l:(((A)list) list))` ASSUME_TAC);;
      e (SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (MATCH_MP_TAC CONS_NOT_NULL);;
      e (ASM_SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (ONCE_ASM_REWRITE_TAC []);;
e (UNDISCH_TAC `MEM a (CONS (HD (l:(((A)list) list))) (delet (TL l) x))`);;
e (ASM_SIMP_TAC [MEM]);;
e (STRIP_TAC);;
e (DISJ1_TAC);;
e (ASM_REWRITE_TAC []);;

e (ASM_CASES_TAC `a = HD (l:(((A)list) list))`);;
      e (DISJ1_TAC);;
      e (ASM_REWRITE_TAC []);;

      e (DISJ2_TAC);;
      e (MATCH_MP_TAC delet_MEM_THM);;
      e (EXISTS_TAC `x:num`);;
      e (ASM_REWRITE_TAC []);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
      	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;


e (DISCH_TAC);;
e (UNDISCH_TAC `~(SUC x > y)`);;
e (SUBGOAL_THEN `~(SUC x > y) = (SUC x <= y)` ASSUME_TAC);;
      e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `(SUC x <= y) = ((SUC x < y) \/ (SUC x = y))` ASSUME_TAC);;
      e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM MP_TAC);;
e (SIMP_TAC [MEM]);;
e (STRIP_TAC);;
e (DISCH_TAC);;
e (ASM_REWRITE_TAC []);;
e (MATCH_MP_TAC delet_MEM_THM);;
e (EXISTS_TAC `y:num`);;
e (SUBGOAL_THEN `(LENGTH (delet ((l:(((A)list) list))) y)) = LENGTH l - 1` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_LENGTH_THM);;
      e (ASM_REWRITE_TAC []);;

e (SUBGOAL_THEN `~NULL (delet (l:(((A)list) list)) y)` ASSUME_TAC);;
      e (ASM_SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(delet (l:(((A)list) list)) y = (CONS (HD (delet l y)) (TL (delet l y))))` ASSUME_TAC);;
      e (SIMP_TAC []);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (MATCH_MP_TAC NOT_NULL_IMP_CONS);;
      e (ASM_REWRITE_TAC []);;

e (ONCE_ASM_REWRITE_TAC []);;
e (ASM_SIMP_TAC [MEM; HD; TL]);;
e (DISCH_TAC);;


e (SUBGOAL_THEN `(!y. (TL (delet (l:(((A)list) list)) y)) =(delet (TL l) (y - 1)))` ASSUME_TAC);;
      e (INDUCT_TAC);;
      e (ASM_SIMP_TAC [delet; TL]);;
      e (SUBGOAL_THEN `(0 - 1) = 0` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ASM_REWRITE_TAC [delet]);;

      e (REWRITE_TAC [delet; HD; TL]);;
      e (SUBGOAL_THEN `SUC y' - 1 = y'` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ASM_REWRITE_TAC [delet]);;

e (UNDISCH_TAC `MEM a (delet (TL (delet (l:(((A)list) list)) y)) x)`);;
e (ASM_SIMP_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_TAC);;
e (SUBGOAL_THEN `MEM a (delet (TL (l:(((A)list) list))) (y - 1))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_MEM_THM);;
      e (EXISTS_TAC `x:num`);;
      e (ASM_REWRITE_TAC []);;
      e (SUBGOAL_THEN `(LENGTH (delet (TL (l:(((A)list) list))) (y - 1))) = LENGTH (TL l) - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC delet_LENGTH_THM);;
	    e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
	          e (MATCH_MP_TAC LENGTH_TL);;
      		  e (ASM_ARITH_TAC);;

            e (ASM_REWRITE_TAC []);;
	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
      	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `~NULL (l:(((A)list) list))` ASSUME_TAC);;
      e (SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      e (MATCH_MP_TAC CONS_NOT_NULL);;
      e (ASM_SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (ONCE_ASM_REWRITE_TAC []);;
e (SIMP_TAC [MEM]);;
e (ASM_CASES_TAC `a = HD (l:(((A)list) list))`);;
      e (DISJ1_TAC);;
      e (ASM_REWRITE_TAC []);;

      e (DISJ2_TAC);;
      e (MATCH_MP_TAC delet_MEM_THM);;
      e (EXISTS_TAC `y - 1`);;
      e (ASM_REWRITE_TAC []);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
      	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

let zsyn_delet_MEM_THM = top_thm ();;

(*---------------------------------------------------------------------------*)
(*				zsyn_delet_ASSOC_THM				                         *)
(*---------------------------------------------------------------------------*)

g `!x (e:(((A)list) list)) (y:num) (l:(((A)list) list)).
     1 < LENGTH l /\ (x < LENGTH l) /\ (y < LENGTH l) /\ ~(x = y)
     ==> (zsyn_delet (APPEND l e) x y = (APPEND (zsyn_delet l x y) e))`;;

e (INDUCT_TAC);;
e (REPEAT STRIP_TAC);;
e (ASM_SIMP_TAC [zsyn_delet; delet]);;
e (COND_CASES_TAC);;
e (ASM_ARITH_TAC);;
e (COND_CASES_TAC);;
e (ASM_ARITH_TAC);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `(delet (APPEND l e) y) = (APPEND (delet (l:(((A)list) list)) y) (e:(((A)list) list)))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_ASSOC_THM);;
      e (ASM_REWRITE_TAC []);;

e (ASM_REWRITE_TAC []);;
e (SUBGOAL_THEN `!L M. (0 < LENGTH L) ==> ((TL (APPEND (L:(((A)list) list)) M)) = (APPEND (TL L) (M:(((A)list) list))))` ASSUME_TAC);;
      e (LIST_INDUCT_TAC);;
      e (ASM_SIMP_TAC [LENGTH]);;
      e (ARITH_TAC);;

      e (REPEAT STRIP_TAC);;
      e (ASM_SIMP_TAC [APPEND; TL]);;

e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `(delet (l:(((A)list) list)) y)`));;
e (DISCH_THEN (MP_TAC o SPEC `(e:(((A)list) list))`));;
e (SUBGOAL_THEN `0 < LENGTH (delet (l:(((A)list) list)) y)` ASSUME_TAC);;
      e (SUBGOAL_THEN `(LENGTH (delet (l:(((A)list) list)) y)) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC delet_LENGTH_THM);;
            e (ASM_REWRITE_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;

(*----SUC CASE-----*)

e (REPEAT STRIP_TAC);;
e (UNDISCH_TAC `!(e:(((A)list) list)) y (l:(((A)list) list)).
          1 < LENGTH l /\ x < LENGTH l /\ y < LENGTH l /\ ~(x = y)
          ==> zsyn_delet (APPEND l e) x y = APPEND (zsyn_delet l x y) e`);;
e (SIMP_TAC [zsyn_delet; delet]);;
e (DISCH_TAC);;
e (COND_CASES_TAC);;
e (COND_CASES_TAC);;

r (1);;
e (ASM_ARITH_TAC);;
e (COND_CASES_TAC);;
e (ASM_ARITH_TAC);;
e (POP_ASSUM (K ALL_TAC));;
r (1);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `!L M. (0 < LENGTH L) ==> (HD (APPEND (L:(((A)list) list)) M) = HD L)` ASSUME_TAC);;
      e (LIST_INDUCT_TAC);;
      e (SIMP_TAC [LENGTH]);;
      e (ARITH_TAC);;

      e (REPEAT STRIP_TAC);;
      e (ASM_SIMP_TAC [APPEND; HD]);;

e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `(e:(((A)list) list))`));;
e (SUBGOAL_THEN `0 < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (ASM_SIMP_TAC []);;
e (DISCH_TAC);;

e (UNDISCH_TAC `!(e:(((A)list) list)) y (l:(((A)list) list)).
          1 < LENGTH l /\ x < LENGTH l /\ y < LENGTH l /\ ~(x = y)
          ==> (if x > y
               then delet (delet (APPEND l e) x) y
               else delet (delet (APPEND l e) y) x) =
              APPEND (if x > y then delet (delet l x) y else delet (delet l y) x) e`);;
e (DISCH_THEN (MP_TAC o SPEC `(e:(((A)list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `y:num`));;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (SUBGOAL_THEN `(1 < LENGTH l /\ x < LENGTH l /\ y < LENGTH l /\  ~(x = y)
          ==> (if x > y
               then delet (delet (APPEND l (e:(((A)list) list))) x) y
               else delet (delet (APPEND (l:(((A)list) list)) e) y) x) =
              APPEND (if x > y then delet (delet l x) y else delet (delet l y) x) e) = 
	      (1 < LENGTH l /\ x < LENGTH l /\ y < LENGTH l /\  ~(x = y) 
	      ==> ((delet (delet (APPEND l e) x) y) = (APPEND (delet (delet l x) y) e)))` ASSUME_TAC);;

e (EQ_TAC);;
e (REPEAT STRIP_TAC);;
e (UNDISCH_TAC `1 < LENGTH l /\ x < LENGTH l /\ y < LENGTH l /\ ~(x = y)
          ==> (if x > y
               then delet (delet (APPEND l (e:(((A)list) list))) x) y
               else delet (delet (APPEND (l:(((A)list) list)) e) y) x) =
              APPEND (if x > y then delet (delet l x) y else delet (delet l y) x) e`);;
e (COND_CASES_TAC);;
e (COND_CASES_TAC);;
e (ASM_REWRITE_TAC []);;
e (ASM_ARITH_TAC);;
e (COND_CASES_TAC);;
e (ASM_ARITH_TAC);;
e (UNDISCH_TAC `~(x = y:num)`);;
e (SIMP_TAC []);;
e (REWRITE_TAC [GSYM LE_ANTISYM]);;
e (REWRITE_TAC [DE_MORGAN_THM]);;
e (REWRITE_TAC [NOT_LE]);;
e (STRIP_TAC);;
e (ASM_ARITH_TAC);;
e (ASM_ARITH_TAC);;

e (REPEAT STRIP_TAC);;
e (COND_CASES_TAC);;
e (COND_CASES_TAC);;
e (UNDISCH_TAC `1 < LENGTH l /\ x < LENGTH l /\ y < LENGTH l /\ ~(x = y) ==> delet (delet (APPEND (l:(((A)list) list)) (e:(((A)list) list))) x) y = APPEND (delet (delet l x) y) e`);;
e (ASM_REWRITE_TAC []);;
e (ASM_ARITH_TAC);;
e (COND_CASES_TAC);;
e (ASM_ARITH_TAC);;
e (UNDISCH_TAC `~(x = y:num)`);;
e (REWRITE_TAC [GSYM LE_ANTISYM]);;
e (REWRITE_TAC [DE_MORGAN_THM]);;
e (REWRITE_TAC [NOT_LE]);;
e (STRIP_TAC);;
e (ASM_ARITH_TAC);;
e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_TAC);;

e (SUBGOAL_THEN	`!L M. (0 < LENGTH L) ==> ((TL (APPEND (L:(((A)list) list)) M)) = (APPEND (TL L) (M:(((A)list) list))))` ASSUME_TAC);;
      e (LIST_INDUCT_TAC);;
      e (SIMP_TAC [LENGTH]);;
      e (ARITH_TAC);;

      e (REPEAT STRIP_TAC);;
      e (REWRITE_TAC [APPEND]);;
      e (REWRITE_TAC [TL]);;

e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `(e:(((A)list) list))`));;
e (SUBGOAL_THEN `0 < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (ASM_SIMP_TAC []);;
e (DISCH_TAC);;
e (SUBGOAL_THEN	`(delet (APPEND (TL l) e) x) = (APPEND (delet ((TL l:(((A)list) list))) x) (e:(((A)list) list)))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_ASSOC_THM);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
      	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (ONCE_ASM_REWRITE_TAC []);;

e (SUBGOAL_THEN `!y. (SUC x > y) /\ (y < LENGTH l) /\  
  (1 < LENGTH l /\ x < LENGTH l /\ y < LENGTH l /\ ~(x = y)
      ==> delet (delet (APPEND l e) x) y = APPEND (delet (delet l x) y) e)
  		==>
       (delet (CONS (HD l) (APPEND (delet (TL (l:(((A)list) list))) x) e)) y =
 APPEND (delet (CONS (HD l) (delet (TL l) x)) y) (e:(((A)list) list)))` ASSUME_TAC);;
      e (INDUCT_TAC);;
      e (SIMP_TAC [delet]);;
      e (ASM_SIMP_TAC [TL]);;

      e (UNDISCH_TAC `~(SUC x = y)`);;
      e (UNDISCH_TAC `y < LENGTH (l:(((A)list) list))`);;
      e (UNDISCH_TAC `SUC x > y`);;
      e (UNDISCH_TAC `x < LENGTH l /\ ~(x = y)
      ==> delet (delet (APPEND (l:(((A)list) list)) (e:(((A)list) list))) x) y = APPEND (delet (delet l x) y) e`);;
      e (DISCH_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
      e (DISCH_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
      e (DISCH_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
      e (DISCH_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
    
      e (REPEAT STRIP_TAC);;

      e (ASM_SIMP_TAC [delet]);;
      e (ASM_SIMP_TAC [HD; TL]);;
      e (SUBGOAL_THEN `(delet (APPEND (delet (TL l) x) e) y') = (APPEND (delet (delet (TL l:(((A)list) list)) x) y') (e:(((A)list) list)))` ASSUME_TAC);;
	    e (MATCH_MP_TAC delet_ASSOC_THM);;
	    e (SUBGOAL_THEN `(LENGTH (delet (TL (l:(((A)list) list))) x)) = LENGTH (TL l) - 1` ASSUME_TAC);;
                  e (MATCH_MP_TAC delet_LENGTH_THM);;
	    	  e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
	                e (MATCH_MP_TAC LENGTH_TL);;
      		        e (ASM_ARITH_TAC);;

                  e (ASM_REWRITE_TAC []);;
	          e (ASM_ARITH_TAC);;

            e (ASM_REWRITE_TAC []);;
      	    e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
                  e (MATCH_MP_TAC LENGTH_TL);;
      	          e (ASM_ARITH_TAC);;

            e (ASM_REWRITE_TAC []);;
            e (ASM_ARITH_TAC);;

e (ASM_SIMP_TAC [APPEND]);;
e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `y:num`));;
e (ASM_SIMP_TAC []);;


e (SUBGOAL_THEN	`(delet (APPEND l e) y) = (APPEND (delet ((l:(((A)list) list))) y) (e:(((A)list) list)))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_ASSOC_THM);;
      e (ASM_REWRITE_TAC []);;

e (ONCE_ASM_REWRITE_TAC []);;
e (SUBGOAL_THEN	`!L M. (0 < LENGTH L) ==> (HD (APPEND (L:(((A)list) list)) M) = HD L)` ASSUME_TAC);;
      e (LIST_INDUCT_TAC);;
      e (SIMP_TAC [LENGTH]);;
      e (ARITH_TAC);;

      e (REPEAT STRIP_TAC);;
      e (ASM_SIMP_TAC [APPEND; HD]);;

e (SUBGOAL_THEN `0 < LENGTH (delet (l:(((A)list) list)) y)` ASSUME_TAC);;
      e (SUBGOAL_THEN `(LENGTH (delet (l:(((A)list) list)) y)) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC delet_LENGTH_THM);;
            e (ASM_REWRITE_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (UNDISCH_TAC `!L M. 0 < LENGTH (L:(((A)list) list)) ==> HD (APPEND L (M:(((A)list) list))) = HD L`);;
e (DISCH_THEN (MP_TAC o SPEC `delet (l:(((A)list) list)) y`));;
e (DISCH_THEN (MP_TAC o SPEC `(e:(((A)list) list))`));;
e (ASM_SIMP_TAC []);;
e (DISCH_TAC);;

e (SUBGOAL_THEN	`!L M. (0 < LENGTH L) ==> ((TL (APPEND (L:(((A)list) list)) M)) = (APPEND (TL L) (M:(((A)list) list))))` ASSUME_TAC);;
      e (LIST_INDUCT_TAC);;
      e (SIMP_TAC [LENGTH]);;
      e (ARITH_TAC);;

      e (REPEAT STRIP_TAC);;
      e (REWRITE_TAC [APPEND]);;
      e (REWRITE_TAC [TL]);;

e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `delet (l:(((A)list) list)) y`));;
e (DISCH_THEN (MP_TAC o SPEC `(e:(((A)list) list))`));;
e (ASM_SIMP_TAC []);;
e (DISCH_TAC);;
e (SUBGOAL_THEN	`(delet (APPEND (TL (delet l y)) e) x) = (APPEND (delet (TL (delet (l:(((A)list) list)) y)) x) (e:(((A)list) list)))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_ASSOC_THM);;

e (SUBGOAL_THEN `!y. (y < LENGTH l) /\ ~(SUC x = y) /\ ~(SUC x > y) /\
    		(delet (APPEND l e) y = APPEND (delet l y) (e:(((A)list) list))) /\
		(0 < LENGTH (delet l y)) /\ (HD (APPEND (delet l y) e) = HD (delet l y)) /\
		(TL (APPEND (delet l y) e) = APPEND (TL (delet l y)) e)
  		==>
       ((TL (delet (l:(((A)list) list)) y)) = (delet (TL l) (y - 1)))` ASSUME_TAC);;
      e (INDUCT_TAC);;
      e (SUBGOAL_THEN `(0 - 1) = 0` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (SIMP_TAC [delet]);;

      e (UNDISCH_TAC `~(SUC x = y)`);;
      e (UNDISCH_TAC `y < LENGTH (l:(((A)list) list))`);;
      e (UNDISCH_TAC `~(SUC x > y)`);;
      e (DISCH_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
      e (DISCH_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
      e (DISCH_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
      e (POP_ASSUM MP_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
      e (POP_ASSUM (K ALL_TAC));;
      e (POP_ASSUM (K ALL_TAC));;
      e (POP_ASSUM (K ALL_TAC));;
      e (DISCH_TAC);;
      e (REPEAT STRIP_TAC);;
      e (ASM_SIMP_TAC [delet]);;
      e (ASM_SIMP_TAC [HD; TL]);;
      e (SUBGOAL_THEN `(SUC y' - 1) = y'` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;

e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `y:num`));;
e (ASM_SIMP_TAC []);;
e (DISCH_TAC);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `LENGTH (delet (TL (l:(((A)list) list))) (y - 1)) = LENGTH (TL l) - 1` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_LENGTH_THM);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;

e (ASM_ARITH_TAC);;
e (ASM_SIMP_TAC []);;
e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
      e (MATCH_MP_TAC LENGTH_TL);;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (ASM_ARITH_TAC);;

e (ASM_SIMP_TAC [APPEND]);;

let zsyn_delet_ASSOC_THM = top_thm();;

(*------------------------------------------------------------------------------*)
(*				   zsyn_delet_THM					                            *)
(*------------------------------------------------------------------------------*)

g `!x (e:((((A)list) # ((A)list) list) list)) (y:num) z (l:(((A)list) list)).
     ALL_DISTINCT (APPEND l (SND (EL z e))) /\ 1 < LENGTH l /\ x < LENGTH l /\ y < LENGTH l /\ ~(x = y)
     ==> (~MEM (EL x l) (zsyn_delet (APPEND l (SND (EL z e))) x y))`;;

e (INDUCT_TAC);;
e (REPEAT GEN_TAC);;
e (STRIP_TAC);;
e (ASM_SIMP_TAC [zsyn_delet]);;
e (SUBGOAL_THEN `0 < y` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (COND_CASES_TAC);;
e (ASM_ARITH_TAC);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `(delet (APPEND l (SND (EL z e))) y) = (APPEND (delet ((l:(((A)list) list))) y) (SND (EL z (e:((((A)list) # ((A)list) list) list)))))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_ASSOC_THM);;
      e (ASM_REWRITE_TAC []);;

e (ONCE_ASM_REWRITE_TAC []);;
e (SUBGOAL_THEN `(delet (APPEND (delet l y) (SND (EL z e))) 0) = (APPEND (delet (delet (l:(((A)list) list)) y) 0) (SND (EL z (e:((((A)list) # ((A)list) list) list)))))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_ASSOC_THM);;
      e (SUBGOAL_THEN `LENGTH (delet (l:(((A)list) list)) y) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC delet_LENGTH_THM);;
      	    e (ASM_REWRITE_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (ONCE_ASM_REWRITE_TAC []);;
e (SIMP_TAC [delet]);;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM MP_TAC);;
e (POP_ASSUM MP_TAC);;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_TAC);;
e (DISCH_TAC);;
e (SUBGOAL_THEN `!y. (y < LENGTH l) /\ ~(0 = y) ==>
           ((TL (delet (l:(((A)list) list)) y)) =(delet (TL l) (y - 1)))` ASSUME_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
      e (POP_ASSUM (K ALL_TAC));;
      e (INDUCT_TAC);;
      e (ASM_ARITH_TAC);;

      e (REPEAT STRIP_TAC);;
      e (REWRITE_TAC [delet; HD; TL]);;
      e (SUBGOAL_THEN `SUC y - 1 = y` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;

e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `y:num`));;
e (ASM_REWRITE_TAC []);;
e (SIMP_TAC []);;
e (DISCH_TAC);;
e (UNDISCH_TAC `ALL_DISTINCT (APPEND (l:(((A)list) list)) (SND (EL z (e:((((A)list) # ((A)list) list) list)))))`);;
e (REWRITE_TAC [ALL_DISTINCT_APPEND_1]);;
e (STRIP_TAC);;
e (SUBGOAL_THEN `~NULL (l:(((A)list) list))` ASSUME_TAC);;
      e (SIMP_TAC [GSYM LENGTH_NOT_NULL]);;
      e (ASM_ARITH_TAC);;

e (REWRITE_TAC [MEM_APPEND]);;
e (REWRITE_TAC [DE_MORGAN_THM]);;
e (STRIP_TAC);;

r (1);;

e (SUBGOAL_THEN `MEM (HD l) (l:(((A)list) list))` ASSUME_TAC);;
      e (SUBGOAL_THEN `(l:(((A)list) list) = (CONS (HD l) (TL l)))` ASSUME_TAC);;
            e (ASM_SIMP_TAC [LENGTH_NOT_NULL]);;
      	    e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
      	    e (ASM_SIMP_TAC [CONS_NOT_NULL]);;

      e (ONCE_ASM_REWRITE_TAC []);;
      e (SIMP_TAC [HD; MEM]);;

e (SIMP_TAC [EL; HD; MEM]);;
e (UNDISCH_TAC `!a. MEM a (l:(((A)list) list)) ==> ~MEM a (SND (EL z (e:((((A)list) # ((A)list) list) list))))`);;
e (DISCH_THEN (MP_TAC o SPEC `(HD (l:(((A)list) list)))`));;
e (ASM_SIMP_TAC []);;

r (1);;

e (SIMP_TAC [EL; HD; MEM]);;
e (STRIP_TAC);;
e (SUBGOAL_THEN `MEM (HD l) (TL(l:(((A)list) list)))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_MEM_THM);;
      e (EXISTS_TAC `y - 1`);;
      e (ASM_REWRITE_TAC []);;
      e (SUBGOAL_THEN `LENGTH (TL (l:(((A)list) list))) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC LENGTH_TL);;
      	    e (ASM_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(ALL_DISTINCT (l:(((A)list) list)) = ALL_DISTINCT (CONS (HD l) (TL l)))` ASSUME_TAC);;
      e (ONCE_ASM_REWRITE_TAC []);;
      e (SUBGOAL_THEN `CONS (HD l) (TL l) = (l:(((A)list) list))` ASSUME_TAC);;
            e (MATCH_MP_TAC NOT_NULL_IMP_CONS);;
	    e (ASM_REWRITE_TAC []);;

      e (ASM_SIMP_TAC []);;

e (UNDISCH_TAC `ALL_DISTINCT (l:(((A)list) list))`);;
e (ASM_SIMP_TAC []);;
e (REWRITE_TAC [ALL_DISTINCT]);;
e (REWRITE_TAC [DE_MORGAN_THM]);;
e (DISJ1_TAC);;
e (ASM_SIMP_TAC []);;


(*** SUC CASE ***)

e (REPEAT STRIP_TAC);;
e (POP_ASSUM MP_TAC);;
e (SIMP_TAC [zsyn_delet]);;
e (COND_CASES_TAC);;
e (SUBGOAL_THEN `(delet (APPEND l (SND (EL z e))) (SUC x)) = (APPEND (delet ((l:(((A)list) list))) (SUC x)) (SND (EL z (e:((((A)list) # ((A)list) list) list)))))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_ASSOC_THM);;
      e (ASM_REWRITE_TAC []);;

e (ONCE_ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `(delet (APPEND (delet l (SUC x)) (SND (EL z e))) y) = (APPEND (delet (delet (l:(((A)list) list)) (SUC x)) y) (SND (EL z (e:((((A)list) # ((A)list) list) list)))))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_ASSOC_THM);;
      e (SUBGOAL_THEN `LENGTH (delet (l:(((A)list) list)) (SUC x)) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC delet_LENGTH_THM);;
      	    e (ASM_REWRITE_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (ONCE_ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (UNDISCH_TAC `!(e:((((A)list) # ((A)list) list) list)) y z (l:(((A)list) list)).
          ALL_DISTINCT (APPEND l (SND (EL z e))) /\
          1 < LENGTH l /\
          x < LENGTH l /\
          y < LENGTH l /\
          ~(x = y)
          ==> ~MEM (EL x l) (zsyn_delet (APPEND l (SND (EL z e))) x y)`);;
e (DISCH_THEN (MP_TAC o SPEC `(e:((((A)list) # ((A)list) list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `y:num`));;
e (DISCH_THEN (MP_TAC o SPEC `z:num`));;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (ASM_SIMP_TAC []);;
e (SUBGOAL_THEN `x < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (ASM_SIMP_TAC []);;
e (DISCH_TAC);;
e (UNDISCH_TAC `ALL_DISTINCT (APPEND (l:(((A)list) list)) (SND (EL z (e:((((A)list) # ((A)list) list) list)))))`);;
e (REWRITE_TAC [ALL_DISTINCT_APPEND_1]);;
e (STRIP_TAC);;


e (REWRITE_TAC [MEM_APPEND]);;
e (REWRITE_TAC [DE_MORGAN_THM]);;
e (STRIP_TAC);;

r (1);;

e (SUBGOAL_THEN `MEM (EL (SUC x) l) (l:(((A)list) list))` ASSUME_TAC);;
      e (POP_ASSUM MP_TAC);;
      e (UNDISCH_TAC `~(x = y) ==> ~MEM (EL x (l:(((A)list) list))) (zsyn_delet (APPEND l (SND (EL z (e:((((A)list) # ((A)list) list) list))))) x y)`);;
      e (REWRITE_TAC [MEM_EXISTS_EL]);;
      e (SUBGOAL_THEN `~(?i. i < LENGTH (zsyn_delet (APPEND l (SND (EL z e))) x y) /\  EL x (l:(((A)list) list)) = EL i (zsyn_delet (APPEND l (SND (EL z e))) x y)) 
              = (!i. ~(i < LENGTH (zsyn_delet (APPEND l (SND (EL z e))) x y)) \/ ~(EL x l = EL i (zsyn_delet (APPEND l (SND (EL z (e:((((A)list) # ((A)list) list) list))))) x y)))` ASSUME_TAC);;
            e (MESON_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (DISCH_TAC);;
      e (SUBGOAL_THEN `!(a:(A)list). ~(?i. i < LENGTH (SND (EL z e)) /\ a = EL i (SND (EL z (e:((((A)list) # ((A)list) list) list))))) 
              = (!i. ~(i < LENGTH (SND (EL z e))) \/ ~(a = EL i (SND (EL z e))))` ASSUME_TAC);;
            e (MESON_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (DISCH_TAC);;
      e (EXISTS_TAC `SUC x`);;
      e (ASM_REWRITE_TAC []);;
      e (UNDISCH_TAC `!a. MEM a (l:(((A)list) list)) ==> ~MEM a (SND (EL z (e:((((A)list) # ((A)list) list) list))))`);;
      e (DISCH_THEN (MP_TAC o SPEC `(EL (SUC x) (l:(((A)list) list)))`));;
      e (ASM_REWRITE_TAC []);;

r (1);;

e (STRIP_TAC);;
e (SUBGOAL_THEN `MEM (EL (SUC x) l) (delet (l:(((A)list) list)) (SUC x))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_MEM_THM);;
      e (EXISTS_TAC `y:num`);;
      e (SUBGOAL_THEN `LENGTH (delet (l:(((A)list) list)) (SUC x)) = LENGTH l - 1` ASSUME_TAC);;
            e (MATCH_MP_TAC delet_LENGTH_THM);;
	    e (ASM_REWRITE_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `!x. x < LENGTH l ==> (~MEM (EL x l) (delet (l:(((A)list) list)) x))` ASSUME_TAC);;

r (1);;

e (POP_ASSUM MP_TAC);;
e (DISCH_THEN (MP_TAC o SPEC `SUC x`));;
e (ASM_SIMP_TAC []);;

r (1);;

e (GEN_TAC);;
e (STRIP_TAC);;
e (MATCH_MP_TAC delet_NOT_MEM_THM);;
e (ASM_SIMP_TAC []);;

e (POP_ASSUM MP_TAC);;
e (SUBGOAL_THEN `(~(SUC x > y) <=> SUC x <= y)` ASSUME_TAC);;
      e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `(SUC x <= y <=> SUC x < y \/ (SUC x = y))` ASSUME_TAC);;
      e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_TAC);;
e (SUBGOAL_THEN `(delet (APPEND l (SND (EL z e))) y) = (APPEND (delet ((l:(((A)list) list))) y) (SND (EL z (e:((((A)list) # ((A)list) list) list)))))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_ASSOC_THM);;
      e (ASM_REWRITE_TAC []);;

e (ONCE_ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `(delet (APPEND (delet l y) (SND (EL z e))) (SUC x)) = (APPEND (delet (delet (l:(((A)list) list)) y) (SUC x)) (SND (EL z (e:((((A)list) # ((A)list) list) list)))))` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_ASSOC_THM);;
      e (SUBGOAL_THEN `LENGTH (delet (l:(((A)list) list)) y) = LENGTH l - 1` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_LENGTH_THM);;
      e (ASM_REWRITE_TAC []);;

e (ONCE_ASM_REWRITE_TAC []);;
e (ASM_ARITH_TAC);;
e (ONCE_ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (UNDISCH_TAC `!e y z l.
          ALL_DISTINCT (APPEND l (SND (EL z (e:((((A)list) # ((A)list) list) list))))) /\
          1 < LENGTH l /\
          x < LENGTH l /\
          y < LENGTH l /\
          ~(x = y)
          ==> ~MEM (EL x l) (zsyn_delet (APPEND (l:(((A)list) list)) (SND (EL z e))) x y)`);;
e (DISCH_THEN (MP_TAC o SPEC `(e:((((A)list) # ((A)list) list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `y:num`));;
e (DISCH_THEN (MP_TAC o SPEC `z:num`));;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (ASM_SIMP_TAC []);;
e (SUBGOAL_THEN `x < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (ASM_SIMP_TAC []);;
e (SUBGOAL_THEN `~(x = y:num)` ASSUME_TAC);;
      e (SUBGOAL_THEN `~(x = y:num) = ((x < y) \/ (y < x))` ASSUME_TAC);;
            e (ARITH_TAC);;
      
      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (DISJ1_TAC);;
      e (ASM_ARITH_TAC);;

e (ASM_SIMP_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (DISCH_TAC);;
e (UNDISCH_TAC `ALL_DISTINCT (APPEND (l:(((A)list) list)) (SND (EL z (e:((((A)list) # ((A)list) list) list)))))`);;
e (SIMP_TAC [ALL_DISTINCT_APPEND_1]);;
e (STRIP_TAC);;
e (SIMP_TAC [MEM_APPEND]);;
e (REWRITE_TAC [DE_MORGAN_THM]);;
e (STRIP_TAC);;

r (1);;

e (SUBGOAL_THEN `MEM (EL (SUC x) l) (l:(((A)list) list))` ASSUME_TAC);;
      e (POP_ASSUM MP_TAC);;
      e (UNDISCH_TAC `~MEM (EL x (l:(((A)list) list))) (zsyn_delet (APPEND l (SND (EL z (e:((((A)list) # ((A)list) list) list))))) x y)`);;
      e (REWRITE_TAC [MEM_EXISTS_EL]);;
      e (SUBGOAL_THEN `~(?i. i < LENGTH (zsyn_delet (APPEND l (SND (EL z e))) x y) /\  EL x (l:(((A)list) list)) = EL i (zsyn_delet (APPEND l (SND (EL z e))) x y)) 
              = (!i. ~(i < LENGTH (zsyn_delet (APPEND l (SND (EL z e))) x y)) \/ ~(EL x l = EL i (zsyn_delet (APPEND l (SND (EL z (e:((((A)list) # ((A)list) list) list))))) x y)))` ASSUME_TAC);;
            e (MESON_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (DISCH_TAC);;
      e (SUBGOAL_THEN `!(a:(A)list). ~(?i. i < LENGTH (SND (EL z e)) /\ a = EL i (SND (EL z (e:((((A)list) # ((A)list) list) list))))) 
              = (!i. ~(i < LENGTH (SND (EL z e))) \/ ~(a = EL i (SND (EL z e))))` ASSUME_TAC);;
            e (MESON_TAC []);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (DISCH_TAC);;
      e (EXISTS_TAC `SUC x`);;
      e (ASM_REWRITE_TAC []);;
      e (UNDISCH_TAC `!a. MEM a (l:(((A)list) list)) ==> ~MEM a (SND (EL z (e:((((A)list) # ((A)list) list) list))))`);;
      e (DISCH_THEN (MP_TAC o SPEC `(EL (SUC x) (l:(((A)list) list)))`));;
      e (ASM_REWRITE_TAC []);;

e (SUBGOAL_THEN `(EL (SUC x) (l:(((A)list) list))) = EL (SUC x) (delet l y)` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_EL_THM);;
      e (ASM_REWRITE_TAC []);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (MATCH_MP_TAC delet_NOT_MEM_THM);;
e (SUBGOAL_THEN `LENGTH (delet (l:(((A)list) list)) y) = LENGTH l - 1` ASSUME_TAC);;
      e (MATCH_MP_TAC delet_LENGTH_THM);;
      e (ASM_REWRITE_TAC []);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (STRIP_TAC);;
e (MATCH_MP_TAC delet_DISTINCT_THM);;
e (ASM_REWRITE_TAC []);;
e (ASM_ARITH_TAC);;

let zsyn_delet_THM = top_thm ();;

(*===========================================================================*)
(*        The property of Zsyntax Describing the No Reaction Scenario        *)
(*===========================================================================*)

(* ==========================================================================*)
(* Theorems List	                                                         *)
(*---------------------------------------------------------------------------*)
(*   EVF_GEN_THM; 		                             		                 *)
(*   RECUR1_GEN_THM;		                       			                 *)
(*   RECUR2_GEN_THM; 		                        		                 *)
(*   RECUR_DED_GEN_THM;							                             *)
(*   Z_NOMATCH_THM;							                                 *)
(*---------------------------------------------------------------------------*)


(*---------------------------------------------------------------------------*)
(* 			       z_EVF_NO_MATCH_THM 			                             *)
(*---------------------------------------------------------------------------*)

g `!p e l x y. ~NULL e /\ ~NULL l /\ (x < LENGTH l) /\ (y < LENGTH l) /\ (p < LENGTH e) /\ 
      	       (!a. (MEM a e) ==> ~(MEM (FST a) [HD l]))
      ==>  (zsyn_EVF (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) p x y = (F,TL l))`;;

e (SIMP_TAC [MEM; GSYM LENGTH_NOT_NULL]);;
e (INDUCT_TAC);;
e (REPEAT STRIP_TAC);;
e (REWRITE_TAC [zsyn_EVF; HD; TL; EL]);;

e (SUBGOAL_THEN `MEM (HD e) (e:(((A)list) # ((A)list) list) list)` ASSUME_TAC);;
      e (SIMP_TAC [MEM_EXISTS_EL]);;
      e (EXISTS_TAC `0`);;
      e (ASM_MESON_TAC [EL]);;

e (ASM_MESON_TAC []);;

e (REPEAT STRIP_TAC);;
e (REWRITE_TAC [zsyn_EVF; HD; TL; EL]);;
e (SUBGOAL_THEN `MEM (EL p (TL e)) (e:((((A)list) # ((A)list) list) list))` ASSUME_TAC);;
      e (SIMP_TAC [MEM_EXISTS_EL]);;
      e (EXISTS_TAC `SUC p`);;
      e (ASM_MESON_TAC [EL]);;

e (COND_CASES_TAC);;
e (ASM_MESON_TAC []);;
e (UNDISCH_TAC `!(e:((((A)list) # ((A)list) list) list)) (l:(((A)list) list)) x y.
          0 < LENGTH e /\
          0 < LENGTH l /\
          x < LENGTH l /\
          y < LENGTH l /\
          p < LENGTH e /\
          (!a. MEM a e ==> ~(FST a = HD l))
          ==> zsyn_EVF l e p x y = F,TL l`);;
e (DISCH_THEN (MP_TAC o SPEC `(e:((((A)list) # ((A)list) list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `x:num`));;
e (DISCH_THEN (MP_TAC o SPEC `y:num`));;
e (ASM_SIMP_TAC []);;
e (SUBGOAL_THEN `p < LENGTH (e:((((A)list) # ((A)list) list) list))` ASSUME_TAC);;
      e (MATCH_MP_TAC LT_TRANS);;
      e (EXISTS_TAC `SUC p`);;
      e (ASM_SIMP_TAC []);;
      e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;

let EVF_GEN_THM = top_thm ();;

(*---------------------------------------------------------------------------*)
(* 			     z_RECUR1_NO_MATCH_THM 	       		                         *)
(*---------------------------------------------------------------------------*)

g `!y e l x. ~NULL e /\ ~NULL l /\ (x < LENGTH l) /\ (y < LENGTH l) /\ 
      	       (!a y. (MEM a e) /\ (y < LENGTH l) ==> ~(MEM (FST a) [HD (zsyn_conjun_intro l x y)]))
      ==>  (zsyn_recurs1 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) x y = (F,l))`;;

e (REWRITE_TAC [zsyn_conjun_intro; HD; MEM]);;
e (INDUCT_TAC);;
e (REPEAT STRIP_TAC);;
e (REWRITE_TAC [zsyn_recurs1]);;
e (REWRITE_TAC [zsyn_conjun_intro]);;
e (SUBGOAL_THEN `zsyn_EVF (CONS (FLAT [EL x l; EL 0 l]) (l:(((A)list) list))) (e:((((A)list) # ((A)list) list) list)) (LENGTH e - 1) (x:num) 0 
                 = (F, TL (CONS (FLAT [EL x l; EL 0 l]) l))` ASSUME_TAC);;
      e (MATCH_MP_TAC EVF_GEN_THM);;
      e (ASM_SIMP_TAC [NULL; LENGTH; MEM; HD; LENGTH_NOT_NULL]);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;

      e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      e (SUBGOAL_THEN `&(LENGTH (e:((((A)list) # ((A)list) list) list)) - 1) = &(LENGTH e) - &1` ASSUME_TAC);;
            e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    e (UNDISCH_TAC `~NULL (e:((((A)list) # ((A)list) list) list))`);;
	    e (REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
      	    e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (REWRITE_TAC [REAL_ARITH `(&m - &1 < &m) = (&0 < &1)`]);;
      e (REAL_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (REWRITE_TAC [TL]);;
e (REPEAT STRIP_TAC);;
e (REWRITE_TAC [zsyn_recurs1]);;
e (REWRITE_TAC [zsyn_conjun_intro]);;


e (SUBGOAL_THEN `zsyn_EVF (CONS (FLAT [EL x l; EL (SUC y) l]) (l:(((A)list) list))) (e:((((A)list) # ((A)list) list) list)) (LENGTH e - 1) (x:num) ((SUC y)) 
                 = (F, TL (CONS (FLAT [EL x l; EL (SUC y) l]) l))` ASSUME_TAC);;
      e (MATCH_MP_TAC EVF_GEN_THM);;
      e (ASM_SIMP_TAC [NULL; LENGTH; MEM; HD; LENGTH_NOT_NULL]);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;

      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;

      e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      e (SUBGOAL_THEN `&(LENGTH (e:((((A)list) # ((A)list) list) list)) - 1) = &(LENGTH e) - &1` ASSUME_TAC);;
            e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    e (UNDISCH_TAC `~NULL (e:((((A)list) # ((A)list) list) list))`);;
	    e (REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
      	    e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (REWRITE_TAC [REAL_ARITH `(&m - &1 < &m) = (&0 < &1)`]);;
      e (REAL_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (UNDISCH_TAC `!(e:((((A)list) # ((A)list) list) list)) (l:(((A)list) list)) x.
          ~NULL e /\
          ~NULL l /\
          x < LENGTH l /\
          y < LENGTH l /\
          (!a y.
               MEM a e /\ y < LENGTH l ==> ~(FST a = FLAT [EL x l; EL y l]))
          ==> zsyn_recurs1 l e x y = F,l`);;
e (DISCH_THEN (MP_TAC o SPEC `(e:((((A)list) # ((A)list) list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `x:num`));;
e (ASM_SIMP_TAC []);;
e (SUBGOAL_THEN `y < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
      e (MATCH_MP_TAC LT_TRANS);;
      e (EXISTS_TAC `SUC y`);;
      e (ASM_SIMP_TAC []);;
      e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;

let RECUR1_GEN_THM = top_thm ();;

(*---------------------------------------------------------------------------*)
(* 			      RECUR2_NO_MATCH_THM 			                             *)
(*---------------------------------------------------------------------------*)

g `!x e l y. ~NULL e /\ ~NULL l /\ (x < LENGTH l) /\ (y < LENGTH l) /\ 
      	       (!a x y. (MEM a e) /\ (x < LENGTH l) /\ (y < LENGTH l) ==> ~(MEM (FST a) [HD (zsyn_conjun_intro l x y)]))
      ==>  (zsyn_recurs2 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) x y = (F,l))`;;

e (INDUCT_TAC);;
e (REWRITE_TAC [zsyn_conjun_intro; HD; MEM]);;
e (REPEAT STRIP_TAC);;
e (REWRITE_TAC [zsyn_recurs2]);;
e (SUBGOAL_THEN `(zsyn_recurs1 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) 0 (y:num) = (F, l))` ASSUME_TAC);;
      e (MATCH_MP_TAC RECUR1_GEN_THM);;
      e (ASM_SIMP_TAC [zsyn_conjun_intro; HD; MEM]);;

e (ASM_REWRITE_TAC []);;

e (POP_ASSUM MP_TAC);;
e (SIMP_TAC [zsyn_conjun_intro; LENGTH; MEM; HD]);;
e (REPEAT STRIP_TAC);;
e (REWRITE_TAC [zsyn_recurs2]);;
e (SUBGOAL_THEN `(zsyn_recurs1 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) (SUC x) (y:num) = (F, l))` ASSUME_TAC);;
      e (MATCH_MP_TAC RECUR1_GEN_THM);;
      e (ASM_SIMP_TAC [zsyn_conjun_intro; HD; MEM]);;


e (ASM_SIMP_TAC []);;
e (UNDISCH_TAC `!(e:((((A)list) # ((A)list) list) list)) (l:(((A)list) list)) y.
          ~NULL e /\
          ~NULL l /\
          x < LENGTH l /\
          y < LENGTH l /\
          (!a x y.
               MEM a e /\ x < LENGTH l /\ y < LENGTH l
               ==> ~(FST a = FLAT [EL x l; EL y l]))
          ==> zsyn_recurs2 l e x y = F,l`);;
e (DISCH_THEN (MP_TAC o SPEC `(e:((((A)list) # ((A)list) list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `LENGTH (l:(((A)list) list)) - 1`));;
e (ASM_SIMP_TAC []);;
e (SUBGOAL_THEN `x < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
      e (MATCH_MP_TAC LT_TRANS);;
      e (EXISTS_TAC `SUC x`);;
      e (ASM_SIMP_TAC []);;
      e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (SUBGOAL_THEN `LENGTH (l:(((A)list) list)) - 1 < LENGTH l` ASSUME_TAC);;
      e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      e (SUBGOAL_THEN `&(LENGTH (l:(((A)list) list)) - 1) = &(LENGTH l) - &1` ASSUME_TAC);;
            e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    e (UNDISCH_TAC `~NULL (l:(((A)list) list))`);;
	    e (REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
      	    e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (REWRITE_TAC [REAL_ARITH `(&m - &1 < &m) = (&0 < &1)`]);;
e (REAL_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;

let RECUR2_GEN_THM = top_thm ();;

(*---------------------------------------------------------------------------*)
(* 		       Z_DEDUCTION_RECUR_NO_MATCH_THM 	        	                 *)
(*---------------------------------------------------------------------------*)

g `!le e l x y. ~NULL e /\ ~NULL l /\ (x < LENGTH l) /\ (y < LENGTH l) /\ (le <= LENGTH e)/\
      	       (!a x y. (MEM a e) /\ (x < LENGTH l) /\ (y < LENGTH l) ==> ~(MEM (FST a) [HD (zsyn_conjun_intro l x y)]))
      ==>  (zsyn_deduct_recurs (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) x y le = (T,l))`;;

e (INDUCT_TAC);;
e (REWRITE_TAC [zsyn_conjun_intro; HD; MEM]);;
e (REPEAT STRIP_TAC);;
e (REWRITE_TAC [zsyn_deduct_recurs]);;

e (REWRITE_TAC [zsyn_deduct_recurs]);;
e (REPEAT STRIP_TAC);;
e (SUBGOAL_THEN `(zsyn_recurs2 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) x (y:num) = (F, l))` ASSUME_TAC);;
      e (MATCH_MP_TAC RECUR2_GEN_THM);;
      e (ASM_SIMP_TAC [zsyn_conjun_intro; HD; MEM]);;

e (ASM_REWRITE_TAC []);;
e (SUBGOAL_THEN `(zsyn_recurs2 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) (LENGTH l - 1) (LENGTH l - 1) = (F, l))` ASSUME_TAC);;
      e (MATCH_MP_TAC RECUR2_GEN_THM);;
      e (ASM_SIMP_TAC [zsyn_conjun_intro; HD; MEM]);;
      e (SUBGOAL_THEN `LENGTH (l:(((A)list) list)) - 1 < LENGTH l` ASSUME_TAC);;
            e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      	    e (SUBGOAL_THEN `&(LENGTH (l:(((A)list) list)) - 1) = &(LENGTH l) - &1` ASSUME_TAC);;
                  e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    	  e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    	  e (UNDISCH_TAC `~NULL (l:(((A)list) list))`);;
	    	  e (REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
      	    	  e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (REWRITE_TAC [REAL_ARITH `(&m - &1 < &m) = (&0 < &1)`]);;
e (REAL_ARITH_TAC);;
e (ASM_REWRITE_TAC []);;

e (ASM_REWRITE_TAC []);;

let RECUR_DED_GEN_THM = top_thm ();;

(*---------------------------------------------------------------------------*)
(* 			    z_DEDUCTION_NO_MATCH_THM    		                         *)
(*---------------------------------------------------------------------------*)

g `!e l. ~NULL e /\ ~NULL l /\
      	(!a x y. (MEM a e) /\ (x < LENGTH l) /\ (y < LENGTH l) ==> ~(MEM (FST a) [HD (zsyn_conjun_intro l x y)]))
   ==>  (zsyn_deduct (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) = l)`;;


e (REPEAT GEN_TAC);;
e (SIMP_TAC [zsyn_conjun_intro; HD; MEM]);;
e (REWRITE_TAC [zsyn_deduct]);;
e (REPEAT STRIP_TAC);;
e (SUBGOAL_THEN `(zsyn_deduct_recurs (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) (LENGTH l - 1) (LENGTH l - 1) (LENGTH e))  = (T,l)` ASSUME_TAC);;
      e (MATCH_MP_TAC RECUR_DED_GEN_THM);;
      e (ASM_SIMP_TAC [zsyn_conjun_intro; HD; MEM; LENGTH_NOT_NULL]);;
      e (CONJ_TAC);;
      e (SUBGOAL_THEN `LENGTH (l:(((A)list) list)) - 1 < LENGTH l` ASSUME_TAC);;
            e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      	    e (SUBGOAL_THEN `&(LENGTH (l:(((A)list) list)) - 1) = &(LENGTH l) - &1` ASSUME_TAC);;
                  e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    	  e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    	  e (UNDISCH_TAC `~NULL (l:(((A)list) list))`);;
	    	  e (REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
      	    	  e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (REWRITE_TAC [REAL_ARITH `(&m - &1 < &m) = (&0 < &1)`]);;
      e (REAL_ARITH_TAC);;
      e (ASM_REWRITE_TAC []);;

      e (CONJ_TAC);;
      e (SUBGOAL_THEN `LENGTH (l:(((A)list) list)) - 1 < LENGTH l` ASSUME_TAC);;
            e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      	    e (SUBGOAL_THEN `&(LENGTH (l:(((A)list) list)) - 1) = &(LENGTH l) - &1` ASSUME_TAC);;
                  e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    	  e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    	  e (UNDISCH_TAC `~NULL (l:(((A)list) list))`);;
	    	  e (REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
      	    	  e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (REWRITE_TAC [REAL_ARITH `(&m - &1 < &m) = (&0 < &1)`]);;
      e (REAL_ARITH_TAC);;
      e (ASM_REWRITE_TAC []);;

      e (ARITH_TAC);;

e (ASM_REWRITE_TAC []);;

let Z_NOMATCH_THM = top_thm ();;

(*===========================================================================*)
(*      The property of Zsyntax Describing the Single Reaction Scenario      *)
(*===========================================================================*)

(* ========================================================================= *)
(* Theorems List			                                                 *)
(*---------------------------------------------------------------------------*)
(*   Z_EVF_MATCH_THM;			                         	                 *)
(*   Z_recur1_MATCH_THM;						                             *)
(*   Z_recur2_MATCH_THM;				                                     *)
(*   Z_DED_MATCH_THM;							                             *)
(*   Z_DEDUCTION_THM;							                             *)
(*---------------------------------------------------------------------------*)

(*---------------------------------------------------------------------------*)
(* 			       z_EVF_MATCH_THM 				                             *)
(*---------------------------------------------------------------------------*)

g `!p (e:((((A)list) # (((A)list) list)) list)) (l:(((A)list) list)) x y z.
      ~NULL e /\ ~NULL l /\ (x < LENGTH l) /\ (y < LENGTH l) /\ (p < LENGTH e) /\
      (z <= p) /\ (HD l = FST (EL z e)) /\
      (!a b. ~(a = b)  ==> ~(FST (EL a e) = FST (EL b e)))
      ==> ((zsyn_EVF l e p x y) = (T,(zsyn_delet (APPEND (TL l) (SND (EL z e))) x y)))`;;

e (INDUCT_TAC);;
e (REPEAT STRIP_TAC);;
e (REWRITE_TAC [zsyn_EVF]);;
e (COND_CASES_TAC);;
e (UNDISCH_TAC `z <= 0`);;
e (REWRITE_TAC [LE]);;
e (SIMP_TAC []);;
e (UNDISCH_TAC `z <= 0`);;
e (REWRITE_TAC [LE]);;
e (DISCH_TAC);;
e (UNDISCH_TAC `HD (l:(((A)list) list)) = FST (EL z (e:((((A)list) # (((A)list) list)) list)))`);;
e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
e (ASM_SIMP_TAC []);;


e (REPEAT STRIP_TAC);;
e (REWRITE_TAC [zsyn_EVF]);;
e (SUBGOAL_THEN `p < LENGTH (e:((((A)list) # ((A)list) list) list))` ASSUME_TAC);;
      e (MATCH_MP_TAC LT_TRANS);;
      e (EXISTS_TAC `SUC p`);;
      e (ASM_REWRITE_TAC []);;
      e (ARITH_TAC);;

e (UNDISCH_TAC `!(e:((((A)list) # ((A)list) list) list)) (l:(((A)list) list)) x y z.
          ~NULL e /\
          ~NULL l /\
          x < LENGTH l /\
          y < LENGTH l /\
          p < LENGTH e /\
          z <= p /\
          HD l = FST (EL z e) /\
          (!a b. ~(a = b) ==> ~(FST (EL a e) = FST (EL b e)))
          ==> zsyn_EVF l e p x y = T,zsyn_delet (APPEND (TL l) (SND (EL z e))) x y`);;
e (DISCH_THEN (MP_TAC o SPEC `(e:((((A)list) # ((A)list) list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `x:num`));;
e (DISCH_THEN (MP_TAC o SPEC `y:num`));;
e (DISCH_THEN (MP_TAC o SPEC `z:num`));;
e (ASM_SIMP_TAC []);;
e (DISCH_TAC);;
e (UNDISCH_TAC `z <= SUC p`);;
e (REWRITE_TAC [LE]);;
e (STRIP_TAC);;
e (ASM_MESON_TAC []);;
e (UNDISCH_TAC `z <= p ==> zsyn_EVF (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) p x y = T,zsyn_delet (APPEND (TL l) (SND (EL z e))) x y`);;
e (ASM_SIMP_TAC []);;
e (DISCH_TAC);;
e (SUBGOAL_THEN `z < LENGTH (e:((((A)list) # (((A)list) list)) list))` ASSUME_TAC);;
      e (MATCH_MP_TAC LET_TRANS);;
      e (EXISTS_TAC `p:num`);;
      e (ASM_SIMP_TAC []);;

e (SUBGOAL_THEN `~((z:num) = (SUC p))` ASSUME_TAC);;
      e (MATCH_MP_TAC LESS_NOT_EQ);;
      e (ASM_ARITH_TAC);;

e (ASM_MESON_TAC []);;

let Z_EVF_MATCH_THM = top_thm();;

(*---------------------------------------------------------------------------*)
(* 			     z_RECUR1_MATCH_THM                                          *)
(*---------------------------------------------------------------------------*)

g `!y (e:((((A)list) # ((A)list) list) list)) (l:(((A)list) list)) x z y'.
      ~NULL e /\ ~NULL l /\ (x < LENGTH l) /\ (y < LENGTH l) /\
      ((z:num) < LENGTH e) /\ (y':num) <= y /\ ALL_DISTINCT l /\
      (!y. y < LENGTH l ==> 
      if ((EL y l = EL y' l)) then
      	 (HD (zsyn_conjun_intro l x y) = FST (EL z e))
      else
	 (!a. MEM a e ==> ~((FST a) = (HD (zsyn_conjun_intro l x y))))) /\
      (!a b. ~(a = b)  ==> ~((FST (EL a e)) = (FST (EL b e))))
      ==> ((zsyn_recurs1 l e x y) = (T,(zsyn_delet (APPEND l (SND (EL z e))) x y')))`;;

e (INDUCT_TAC);;
e (REPEAT STRIP_TAC);;
e (SUBGOAL_THEN `TL (zsyn_conjun_intro (l:(((A)list) list)) x y') = l` ASSUME_TAC);;
      e (REWRITE_TAC [zsyn_conjun_intro]);;
      e (ASM_SIMP_TAC [TL; FLAT; EL]);;

e (REWRITE_TAC [zsyn_recurs1]);;
e (SUBGOAL_THEN `((zsyn_EVF (zsyn_conjun_intro (l:(((A)list) list)) x 0) (e:((((A)list) # ((A)list) list) list)) (LENGTH e - 1) x 0) = 
  	    (T, zsyn_delet (APPEND (TL (zsyn_conjun_intro l x 0)) (SND (EL z e))) x 0))` ASSUME_TAC);;
      e (MATCH_MP_TAC Z_EVF_MATCH_THM);;
      e (ASM_SIMP_TAC []);;
      e (UNDISCH_TAC `y' <= 0`);;
      e (REWRITE_TAC [LE]);;
      e (STRIP_TAC);;
      e (REWRITE_TAC [zsyn_conjun_intro]);;
      e (REWRITE_TAC [LENGTH]);;
      e (SIMP_TAC [NULL]);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (UNDISCH_TAC `~NULL (l:(((A)list) list))`);;
      e (REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
      e (DISCH_TAC);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (SUBGOAL_THEN `LENGTH (e:((((A)list) # ((A)list) list) list)) - 1 < LENGTH e` ASSUME_TAC);;
            e (REWRITE_TAC [GSYM REAL_OF_NUM_LT]);;
      	    e (SUBGOAL_THEN `&(LENGTH (e:((((A)list) # ((A)list) list) list)) - 1) = &(LENGTH e) - &1` ASSUME_TAC);;
                  e (ONCE_REWRITE_TAC [EQ_SYM_EQ]);;
	    	  e (MATCH_MP_TAC REAL_OF_NUM_SUB);;
	    	  e (UNDISCH_TAC `~NULL (e:((((A)list) # ((A)list) list) list))`);;
	    	  e (REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
      	    	  e (ARITH_TAC);;

            e (ASM_REWRITE_TAC []);;
      	    e (POP_ASSUM (K ALL_TAC));;
      	    e (REWRITE_TAC [REAL_ARITH `(&m - &1 < &m) = (&0 < &1)`]);;
      	    e (REAL_ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;

      e (UNDISCH_TAC `!y. y < LENGTH (l:(((A)list) list))
          ==> (if EL y l = EL y' l
               then HD (zsyn_conjun_intro l x y) = FST (EL z (e:((((A)list) # ((A)list) list) list)))
               else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))`);;
      e (DISCH_THEN (MP_TAC o SPEC `0`));;
      e (ASM_SIMP_TAC [zsyn_conjun_intro]);;
      e (ASM_REWRITE_TAC []);;
      e (SUBGOAL_THEN `(TL (zsyn_conjun_intro (l:(((A)list) list)) x 0)) = (TL (zsyn_conjun_intro l x y'))` ASSUME_TAC);;
            e (UNDISCH_TAC `y' <= 0`);;
      	    e (REWRITE_TAC [LE]);;
      	    e (SIMP_TAC []);;

      e (POP_ASSUM MP_TAC);;
      e (SIMP_TAC []);;
      e (DISCH_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
      e (POP_ASSUM (K ALL_TAC));;
      e (ASM_REWRITE_TAC []);;
      e (UNDISCH_TAC `y' <= 0`);;
      e (REWRITE_TAC [LE]);;
      e (SIMP_TAC []);;

e (REPEAT STRIP_TAC);;
e (SUBGOAL_THEN `TL (zsyn_conjun_intro (l:(((A)list) list)) x y') = l` ASSUME_TAC);;
      e (REWRITE_TAC [zsyn_conjun_intro]);;
      e (ASM_SIMP_TAC [TL; FLAT; EL]);;

e (REWRITE_TAC [zsyn_recurs1]);;
e (SUBGOAL_THEN `y < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (UNDISCH_TAC `y' <= SUC y`);;
e (REWRITE_TAC [LE]);;
e (STRIP_TAC);;
e (ASM_REWRITE_TAC []);;
e (UNDISCH_TAC `TL (zsyn_conjun_intro (l:(((A)list) list)) x y') = l`);;
e (ASM_REWRITE_TAC []);;
e (STRIP_TAC);;
e (SUBGOAL_THEN `((zsyn_EVF (zsyn_conjun_intro (l:(((A)list) list)) x (SUC y)) (e:((((A)list) # ((A)list) list) list)) (LENGTH e - 1) x (SUC y)) = 
  	    (T, zsyn_delet (APPEND (TL (zsyn_conjun_intro l x (SUC y))) (SND (EL z e))) x (SUC y)))` ASSUME_TAC);;
      e (MATCH_MP_TAC Z_EVF_MATCH_THM);;
      e (REWRITE_TAC [zsyn_conjun_intro]);;
      e (REWRITE_TAC [LENGTH]);;
      e (ASM_SIMP_TAC [NULL]);;
      e (CONJ_TAC);;  
      e (ASM_ARITH_TAC);;
      e (CONJ_TAC);;  
      e (ASM_ARITH_TAC);;
      e (CONJ_TAC);;  
      e (ASM_ARITH_TAC);;
      e (CONJ_TAC);;  
      e (ASM_ARITH_TAC);;
      e (UNDISCH_TAC `!y. y < LENGTH l
          ==> (if EL y l = EL y' l
               then HD (zsyn_conjun_intro (l:(((A)list) list)) x y) = FST (EL z (e:((((A)list) # ((A)list) list) list)))
               else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))`);;
      e (DISCH_THEN (MP_TAC o SPEC `SUC y`));;
      e (ASM_SIMP_TAC [zsyn_conjun_intro]);;

      e (UNDISCH_TAC `!(e:((((A)list) # ((A)list) list) list)) (l:(((A)list) list)) x z y'.
          ~NULL e /\
          ~NULL l /\
          x < LENGTH l /\
          y < LENGTH l /\
          z < LENGTH e /\
          y' <= y /\
          ALL_DISTINCT l /\
          (!y. y < LENGTH l
               ==> (if EL y l = EL y' l
                    then HD (zsyn_conjun_intro l x y) = FST (EL z e)
                    else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))) /\
          (!a b. ~(a = b) ==> ~(FST (EL a e) = FST (EL b e)))
          ==> zsyn_recurs1 l e x y = T,zsyn_delet (APPEND l (SND (EL z e))) x y'`);;
      e (DISCH_THEN (MP_TAC o SPEC `(e:((((A)list) # ((A)list) list) list))`));;
      e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
      e (DISCH_THEN (MP_TAC o SPEC `x:num`));;
      e (DISCH_THEN (MP_TAC o SPEC `z:num`));;
      e (DISCH_THEN (MP_TAC o SPEC `y':num`));;
      e (ASM_SIMP_TAC []);;

e (SUBGOAL_THEN `~(y' = SUC y)` ASSUME_TAC);;
      e (MATCH_MP_TAC LESS_NOT_EQ);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `(zsyn_EVF (zsyn_conjun_intro (l:(((A)list) list)) x (SUC y)) (e:((((A)list) # ((A)list) list) list)) (LENGTH e - 1) x (SUC y)) =
  	    	 (F,TL (zsyn_conjun_intro l x (SUC y)))` ASSUME_TAC);;
      e (MATCH_MP_TAC EVF_GEN_THM);;
      e (ASM_SIMP_TAC [zsyn_conjun_intro; HD; LENGTH; MEM; NULL]);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (STRIP_TAC);;
      e (DISCH_TAC);;
      e (UNDISCH_TAC `!y. y < LENGTH (l:(((A)list) list))
          ==> (if EL y l = EL y' l
               then HD (zsyn_conjun_intro l x y) = FST (EL z (e:((((A)list) # ((A)list) list) list)))
               else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))`);;
      e (DISCH_THEN (MP_TAC o SPEC `SUC y`));;
      e (ASM_SIMP_TAC []);;
      e (REWRITE_TAC [zsyn_conjun_intro]);;
      e (REWRITE_TAC [HD]);;
      e (COND_CASES_TAC);;
      e (SIMP_TAC []);;
      e (STRIP_TAC);;
      e (SUBGOAL_THEN `(EL (SUC y) (l:(((A)list) list)) = EL (y':num) l) <=> ((SUC y) = y')` ASSUME_TAC);;
	    e (MATCH_MP_TAC ALL_DISTINCT_EL_IMP);;
      	    e (ASM_SIMP_TAC []);;
	    e (ASM_ARITH_TAC);;

      e (ASM_MESON_TAC []);;

      e (ASM_MESON_TAC []);;

e (UNDISCH_TAC `!(e:((((A)list) # ((A)list) list) list)) (l:(((A)list) list)) x z y'.
          ~NULL e /\
          ~NULL l /\
          x < LENGTH l /\
          y < LENGTH l /\
          z < LENGTH e /\
          y' <= y /\
          ALL_DISTINCT l /\
          (!y. y < LENGTH l
               ==> (if EL y l = EL y' l
                    then HD (zsyn_conjun_intro l x y) = FST (EL z e)
                    else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))) /\
          (!a b. ~(a = b) ==> ~(FST (EL a e) = FST (EL b e)))
          ==> zsyn_recurs1 l e x y = T,zsyn_delet (APPEND l (SND (EL z e))) x y'`);;
e (DISCH_THEN (MP_TAC o SPEC `(e:((((A)list) # ((A)list) list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `x:num`));;
e (DISCH_THEN (MP_TAC o SPEC `z:num`));;
e (DISCH_THEN (MP_TAC o SPEC `y':num`));;
e (ASM_SIMP_TAC []);;

let Z_recur1_MATCH_THM = top_thm();;

(*---------------------------------------------------------------------------*)
(* 			     z_RECUR2_MATCH_THM 	                                     *)
(*---------------------------------------------------------------------------*)

g `!x (e:((((A)list) # ((A)list) list) list)) (l:(((A)list) list)) y z x' y'.
      ~NULL e /\ ~NULL l /\ (x < LENGTH l) /\ ((y:num) < LENGTH l) /\
      ((z:num) < LENGTH e) /\ y' <= y /\ x' <= x /\ ALL_DISTINCT l /\
      (!x y. x < LENGTH l /\ y < LENGTH l ==>
      if ((EL x l = EL x' l) /\ (EL y l = EL y' l)) then
      	 (HD (zsyn_conjun_intro l x y) = FST (EL z e))
      else
	 (!a. MEM a e ==> ~((FST a) = (HD (zsyn_conjun_intro l x y))))) /\

      (!a b. ~(a = b)  ==> ~((FST (EL a e)) = (FST (EL b e))))
      ==> ((zsyn_recurs2 l e x y) = (T,(zsyn_delet (APPEND l (SND (EL z e))) x' y')))`;;

e (INDUCT_TAC);;
e (REPEAT STRIP_TAC);;
e (REWRITE_TAC [zsyn_recurs2]);;
e (SUBGOAL_THEN `zsyn_recurs1 (l:(((A)list) list)) (e:((((A)list) # (((A)list) list)) list)) 0 y = (T,(zsyn_delet (APPEND l (SND (EL z e))) 0 y'))` ASSUME_TAC);;
      e (MATCH_MP_TAC Z_recur1_MATCH_THM);;
      e (ASM_SIMP_TAC []);;
      e (SUBGOAL_THEN `x' = 0` ASSUME_TAC);;
            e (ASM_ARITH_TAC);;

      e (UNDISCH_TAC `x' <= 0`);;
      e (DISCH_TAC);;
      e (POP_ASSUM (K ALL_TAC));;
      e (UNDISCH_TAC `!x y.
          x < LENGTH l /\ y < LENGTH (l:(((A)list) list))
          ==> (if EL x l = EL x' l /\ EL y l = EL y' l
               then HD (zsyn_conjun_intro l x y) = FST (EL z (e:((((A)list) # ((A)list) list) list)))
               else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))`);;
      e (DISCH_THEN (MP_TAC o SPEC `0`));;
      e (ASM_SIMP_TAC []);;

e (ASM_SIMP_TAC [FST; SND]);;
e (SUBGOAL_THEN `x' = 0` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;


e (REPEAT STRIP_TAC);;
e (UNDISCH_TAC `!(e:((((A)list) # ((A)list) list) list)) l y z x' y'.
          ~NULL e /\
          ~NULL l /\
          x < LENGTH (l:(((A)list) list)) /\
          y < LENGTH l /\
          z < LENGTH e /\
          y' <= y /\
          x' <= x /\
          ALL_DISTINCT l /\
          (!x y.
               x < LENGTH l /\ y < LENGTH l
               ==> (if EL x l = EL x' l /\ EL y l = EL y' l
                    then HD (zsyn_conjun_intro l x y) = FST (EL z e)
                    else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))) /\
          (!a b. ~(a = b) ==> ~(FST (EL a e) = FST (EL b e)))
          ==> zsyn_recurs2 l e x y = T,zsyn_delet (APPEND l (SND (EL z e))) x' y'`);;
e (DISCH_THEN (MP_TAC o SPEC `(e:((((A)list) # ((A)list) list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `y:num`));;
e (DISCH_THEN (MP_TAC o SPEC `z:num`));;
e (DISCH_THEN (MP_TAC o SPEC `x':num`));;
e (DISCH_THEN (MP_TAC o SPEC `y':num`));;
e (ASM_SIMP_TAC []);;
e (DISCH_TAC);;
e (REWRITE_TAC [zsyn_recurs2]);;
e (SUBGOAL_THEN `x < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;

e (UNDISCH_TAC `x' <= SUC x`);;
e (SIMP_TAC [LE]);;
e (REPEAT STRIP_TAC);;
e (SUBGOAL_THEN `zsyn_recurs1 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) (SUC x) y = (T,(zsyn_delet (APPEND l (SND (EL z e))) (SUC x) y'))` ASSUME_TAC);;
      e (MATCH_MP_TAC Z_recur1_MATCH_THM);;
      e (ASM_SIMP_TAC []);;
      e (GEN_TAC);;
      e (UNDISCH_TAC `!x y.
          x < LENGTH l /\ y < LENGTH l
          ==> (if EL x l = EL x' l /\ EL y (l:(((A)list) list)) = EL y' l
               then HD (zsyn_conjun_intro l x y) = FST (EL z (e:((((A)list) # ((A)list) list) list)))
               else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))`);;
      e (DISCH_THEN (MP_TAC o SPEC `SUC x`));;
      e (ASM_SIMP_TAC []);;

e (ASM_SIMP_TAC [FST; SND]);;
e (SUBGOAL_THEN `~(x' = SUC x)` ASSUME_TAC);;
      e (MATCH_MP_TAC LESS_NOT_EQ);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `zsyn_recurs1 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) (SUC x) (y:num) = (F,l) ` ASSUME_TAC);;
      e (MATCH_MP_TAC RECUR1_GEN_THM);;
      e (ASM_SIMP_TAC []);;
      e (REWRITE_TAC [MEM]);;
      e (REPEAT GEN_TAC);;
      e (STRIP_TAC);;
      e (UNDISCH_TAC `!x y.
          x < LENGTH l /\ y < LENGTH (l:(((A)list) list))
          ==> (if EL x l = EL x' l /\ EL y l = EL y' l
               then HD (zsyn_conjun_intro l x y) = FST (EL z (e:((((A)list) # ((A)list) list) list)))
               else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))`);;
      e (DISCH_THEN (MP_TAC o SPEC `SUC x`));;
      e (ASM_SIMP_TAC []);;
      e (DISCH_TAC);;
      e (UNDISCH_TAC `x < LENGTH (l:(((A)list) list)) /\ x' <= x
      ==> zsyn_recurs2 l e x y = T,zsyn_delet (APPEND l (SND (EL z (e:((((A)list) # ((A)list) list) list))))) x' y'`);;
      e (ASM_SIMP_TAC []);;
      e (DISCH_TAC);;
      e (SUBGOAL_THEN `(~(x' = (SUC x))) ==> (~(EL (SUC x) (l:(((A)list) list)) = EL x' l))` ASSUME_TAC);;
            e (ASM_SIMP_TAC []);;
	    e (SUBGOAL_THEN `((EL (SUC x) (l:(((A)list) list)) = EL x' l)) <=> ((SUC x) = x')` ASSUME_TAC);;
	          e (MATCH_MP_TAC ALL_DISTINCT_EL_IMP);;
		  e (ASM_SIMP_TAC []);;
		  e (ASM_ARITH_TAC);;

            e (ASM_REWRITE_TAC []);;

      e (ASM_MESON_TAC []);;

e (ASM_SIMP_TAC [FST]);;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM (K ALL_TAC));;
e (UNDISCH_TAC `SUC x < LENGTH (l:(((A)list) list))`);;
e (DISCH_TAC);;
e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM MP_TAC);;
e (POP_ASSUM MP_TAC);;
e (POP_ASSUM (K ALL_TAC));;
e (REPEAT DISCH_TAC);;



e (SUBGOAL_THEN `!x. (x < LENGTH l) /\ (x' <= x) ==> (zsyn_recurs2 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) x (LENGTH l - 1) = T,zsyn_delet (APPEND l (SND (EL z e))) x' y')` ASSUME_TAC);;


e (POP_ASSUM (K ALL_TAC));;
e (POP_ASSUM (K ALL_TAC));;


      e (INDUCT_TAC);;
      e (STRIP_TAC);;
      e (REWRITE_TAC [zsyn_recurs2]);;
      e (SUBGOAL_THEN `zsyn_recurs1 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) 0 (LENGTH l - 1) = (T,(zsyn_delet (APPEND l (SND (EL z e))) 0 y'))` ASSUME_TAC);;
            e (MATCH_MP_TAC Z_recur1_MATCH_THM);;
	    e (ASM_SIMP_TAC []);;
	    e (CONJ_TAC);;
	    e (ASM_ARITH_TAC);;
 	    e (CONJ_TAC);;
	    e (ASM_ARITH_TAC);;
	    e (SIMP_TAC [zsyn_conjun_intro; HD; LENGTH; MEM]);;
	    e (UNDISCH_TAC `!x y.
          x < LENGTH l /\ y < LENGTH l
          ==> (if EL x l = EL x' l /\ EL y l = EL y' (l:(((A)list) list))
               then HD (zsyn_conjun_intro l x y) = FST (EL z (e:((((A)list) # ((A)list) list) list)))
               else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))`);;
	    e (SIMP_TAC [zsyn_conjun_intro; HD; LENGTH; MEM]);;
	    e (SUBGOAL_THEN `x' = 0` ASSUME_TAC);;
  	          e (ASM_ARITH_TAC);;

            e (POP_ASSUM MP_TAC);;
	    e (POP_ASSUM (K ALL_TAC));;
	    e (SIMP_TAC []);;
	    e (DISCH_TAC);;
	    e (DISCH_THEN (MP_TAC o SPEC `0`));;
	    e (ASM_SIMP_TAC []);;

      e (ASM_SIMP_TAC [FST]);;
      e (SUBGOAL_THEN `x' = 0` ASSUME_TAC);;
      e (ASM_ARITH_TAC);;
      e (ASM_SIMP_TAC []);;

      e (STRIP_TAC);;
      e (REWRITE_TAC [zsyn_recurs2]);;
      e (SUBGOAL_THEN `x < LENGTH (l:(((A)list) list))` ASSUME_TAC);;
            e (ASM_ARITH_TAC);;

e (UNDISCH_TAC `x' <= SUC x`);;
e (SIMP_TAC [LE]);;
e (REPEAT STRIP_TAC);;
e (SUBGOAL_THEN `zsyn_recurs1 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) (SUC x) (LENGTH l - 1) = (T,(zsyn_delet (APPEND l (SND (EL z e))) (SUC x) y'))` ASSUME_TAC);;
      e (MATCH_MP_TAC Z_recur1_MATCH_THM);;
      e (ASM_SIMP_TAC []);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (GEN_TAC);;
      e (UNDISCH_TAC `!x y.
          x < LENGTH l /\ y < LENGTH l
          ==> (if EL x l = EL x' l /\ EL y (l:(((A)list) list)) = EL y' l
               then HD (zsyn_conjun_intro l x y) = FST (EL z (e:((((A)list) # ((A)list) list) list)))
               else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))`);;
      e (DISCH_THEN (MP_TAC o SPEC `SUC x`));;
      e (ASM_SIMP_TAC []);;

e (ASM_SIMP_TAC [FST; SND]);;
e (SUBGOAL_THEN `~((x':num) = (SUC (x:num)))` ASSUME_TAC);;
      e (MATCH_MP_TAC LESS_NOT_EQ);;
      e (ASM_ARITH_TAC);;

e (SUBGOAL_THEN `zsyn_recurs1 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) (SUC x) (LENGTH l - 1) = (F,l) ` ASSUME_TAC);;
      e (MATCH_MP_TAC RECUR1_GEN_THM);;
      e (ASM_SIMP_TAC []);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (REWRITE_TAC [MEM]);;
      e (REPEAT GEN_TAC);;
      e (STRIP_TAC);;
      e (UNDISCH_TAC `!x y.
          x < LENGTH l /\ y < LENGTH (l:(((A)list) list))
          ==> (if EL x l = EL x' l /\ EL y l = EL y' l
               then HD (zsyn_conjun_intro l x y) = FST (EL z (e:((((A)list) # ((A)list) list) list)))
               else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro l x y)))`);;
      e (DISCH_THEN (MP_TAC o SPEC `SUC x`));;
      e (ASM_SIMP_TAC []);;
      e (DISCH_TAC);;
      e (UNDISCH_TAC `x < LENGTH (l:(((A)list) list)) /\ x' <= x
      ==> zsyn_recurs2 l e x (LENGTH l - 1) = T,zsyn_delet (APPEND l (SND (EL z (e:((((A)list) # ((A)list) list) list))))) x' y'`);;
      e (ASM_SIMP_TAC []);;
      e (DISCH_TAC);;
      e (SUBGOAL_THEN `(~(x' = (SUC x))) ==> (~(EL (SUC x) (l:(((A)list) list)) = EL x' l))` ASSUME_TAC);;
            e (ASM_SIMP_TAC []);;
	    e (SUBGOAL_THEN `((EL (SUC x) (l:(((A)list) list)) = EL x' l)) <=> ((SUC x) = x')` ASSUME_TAC);;
	          e (MATCH_MP_TAC ALL_DISTINCT_EL_IMP);;
		  e (ASM_SIMP_TAC []);;
		  e (ASM_ARITH_TAC);;

            e (ASM_REWRITE_TAC []);;

      e (ASM_MESON_TAC []);;

e (ASM_SIMP_TAC []);;
e (POP_ASSUM MP_TAC);;
e (ASM_MESON_TAC []);;

let Z_recur2_MATCH_THM = top_thm();;

(*---------------------------------------------------------------------------*)
(* 		           z_DEDUCTION_RECUR_MATCH_THM 	         	                 *)
(*---------------------------------------------------------------------------*)

g `!le (e:((((A)list) # ((A)list) list) list)) (l:(((A)list) list)) m n z m' n'.
      ~NULL e /\ (1 < LENGTH l) /\ (m < LENGTH l) /\ (n < LENGTH l) /\
      (z < LENGTH e) /\ n' <= n /\ m' <= m /\ (le <= LENGTH e) /\ ~(le = 0) /\
      ALL_DISTINCT (APPEND l (SND (EL z e))) /\ ~(m' = n') /\ ~NULL (SND (EL z e)) /\
      (!k x y. x < LENGTH k /\ y < LENGTH k /\ 
      (!j. MEM j k ==> MEM j l \/ ?q. (MEM q e /\ MEM j (SND q))) ==>
      
      if ((EL x (k:(((A)list) list)) = EL m' l) /\ (EL y k = EL n' l)) then
      	 (HD (zsyn_conjun_intro k x y) = FST (EL z e))
      else
	 (!a. MEM a e ==> ~((FST a) = (HD (zsyn_conjun_intro k x y))))) /\

      (!a b. ~(a = b)  ==> ~(FST (EL a e) = FST (EL b e))) 
      ==> ((zsyn_deduct_recurs l e m n le) = (T,(zsyn_delet (APPEND l (SND (EL z e))) m' n')))`;;

e (INDUCT_TAC);;
e (REPEAT STRIP_TAC);;
e (ASM_MESON_TAC []);;

e (REPEAT STRIP_TAC);;
e (UNDISCH_TAC `!(e:((((A)list) # ((A)list) list) list)) l m n z m' n'.
          ~NULL e /\
          1 < LENGTH (l:(((A)list) list)) /\
          m < LENGTH l /\
          n < LENGTH l /\
          z < LENGTH e /\
          n' <= n /\
          m' <= m /\
          le <= LENGTH e /\
          ~(le = 0) /\
          ALL_DISTINCT (APPEND l (SND (EL z e))) /\
          ~(m' = n') /\
          ~NULL (SND (EL z e)) /\
          (!k x y.
               x < LENGTH k /\
               y < LENGTH k /\
               (!j. MEM j k ==> MEM j l \/ (?q. MEM q e /\ MEM j (SND q)))
               ==> (if EL x k = EL m' l /\ EL y k = EL n' l
                    then HD (zsyn_conjun_intro k x y) = FST (EL z e)
                    else !a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro k x y)))) /\
          (!a b. ~(a = b) ==> ~(FST (EL a e) = FST (EL b e)))
          ==> zsyn_deduct_recurs l e m n le =
              T,zsyn_delet (APPEND l (SND (EL z e))) m' n'`);;
e (DISCH_THEN (MP_TAC o SPEC `(e:((((A)list) # ((A)list) list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `(l:(((A)list) list))`));;
e (DISCH_THEN (MP_TAC o SPEC `m:num`));;
e (DISCH_THEN (MP_TAC o SPEC `n:num`));;
e (DISCH_THEN (MP_TAC o SPEC `z:num`));;
e (DISCH_THEN (MP_TAC o SPEC `m':num`));;
e (DISCH_THEN (MP_TAC o SPEC `n':num`));;
e (ASM_REWRITE_TAC []);;
e (DISCH_TAC);;
e (REWRITE_TAC [zsyn_deduct_recurs]);;
e (SUBGOAL_THEN `zsyn_recurs2 (l:(((A)list) list)) (e:((((A)list) # ((A)list) list) list)) m n = 
  	    (T, zsyn_delet (APPEND l (SND (EL z e))) m' n')` ASSUME_TAC);;
      e (MATCH_MP_TAC Z_recur2_MATCH_THM);;
      e (ASM_SIMP_TAC []);;
      e (REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (UNDISCH_TAC `ALL_DISTINCT (APPEND (l:(((A)list) list)) (SND (EL z (e:((((A)list) # ((A)list) list) list)))))`);;
      e (REWRITE_TAC [ALL_DISTINCT_APPEND]);;
      e (SIMP_TAC []);;

e (ASM_SIMP_TAC [FST]);;
e (POP_ASSUM (K ALL_TAC));;
e (SUBGOAL_THEN `(zsyn_deduct_recurs (zsyn_delet (APPEND (l:(((A)list) list)) (SND (EL z e))) m' n') e 
(LENGTH (zsyn_delet (APPEND l (SND (EL z (e:((((A)list) # ((A)list) list) list))))) m' n') - 1) 
(LENGTH (zsyn_delet (APPEND l (SND (EL z e))) m' n') - 1) le 
= (T,(zsyn_delet (APPEND l (SND (EL z e))) m' n')))` ASSUME_TAC);;

r (1);;

e (ASM_SIMP_TAC []);;

e (POP_ASSUM (K ALL_TAC));;
e (MATCH_MP_TAC RECUR_DED_GEN_THM);;
e (ASM_SIMP_TAC []);;
e (ASM_SIMP_TAC [LENGTH]);;
e (ONCE_REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
e (SUBGOAL_THEN `(LENGTH (zsyn_delet (APPEND (l:(((A)list) list)) (SND (EL z (e:((((A)list) # ((A)list) list) list))))) m' n') - 1 <
 LENGTH (zsyn_delet (APPEND l (SND (EL z e))) m' n')) = (0 < LENGTH (zsyn_delet (APPEND l (SND (EL z e))) m' n'))` ASSUME_TAC);;
      e (ASM_MESON_TAC [NUM_MINUS_ONE_LT_NUM_EQ]);;

e (ASM_REWRITE_TAC []);;
e (POP_ASSUM (K ALL_TAC));;
e (UNDISCH_TAC `~NULL (SND (EL z (e:((((A)list) # ((A)list) list) list))))`);;
e (ONCE_REWRITE_TAC [GSYM LENGTH_NOT_NULL]);;
e (DISCH_TAC);;
e (SUBGOAL_THEN `(LENGTH (zsyn_delet (APPEND l (SND (EL z e))) m' n') = LENGTH (APPEND (l:(((A)list) list)) (SND (EL z (e:((((A)list) # ((A)list) list) list))))) - 2)` ASSUME_TAC);;
      e (MATCH_MP_TAC zsyn_delet_LENGTH_THM);;
      e (ASM_SIMP_TAC [LENGTH_APPEND]);;
      e (STRIP_TAC);;
      e (SUBGOAL_THEN `(1 = 1 + 0)` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ONCE_ASM_REWRITE_TAC []);;
      e (MATCH_MP_TAC LT_ADD2);;
      e (ASM_REWRITE_TAC []);;
      e (STRIP_TAC);;
      e (SUBGOAL_THEN `(m' = m' + 0)` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ONCE_ASM_REWRITE_TAC []);;
      e (MATCH_MP_TAC LT_ADD2);;
      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;
      e (SUBGOAL_THEN `(n' = n' + 0)` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ONCE_ASM_REWRITE_TAC []);;
      e (MATCH_MP_TAC LT_ADD2);;
      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (ASM_SIMP_TAC [LENGTH_APPEND]);;
e (SUBGOAL_THEN `0 < (LENGTH (l:(((A)list) list)) + LENGTH (SND (EL z (e:((((A)list) # ((A)list) list) list))))) - 2` ASSUME_TAC);;
      e (SUBGOAL_THEN `(0 < (LENGTH (l:(((A)list) list)) + LENGTH (SND (EL z (e:((((A)list) # ((A)list) list) list))))) - 2) = (1 + 1 < (LENGTH l + LENGTH (SND (EL z e))))` ASSUME_TAC);;
            e (ARITH_TAC);;

      e (ASM_REWRITE_TAC []);;
      e (POP_ASSUM (K ALL_TAC));;
      e (MATCH_MP_TAC LTE_ADD2);;
      e (ASM_REWRITE_TAC []);;
      e (ASM_ARITH_TAC);;

e (ASM_REWRITE_TAC []);;
e (STRIP_TAC);;
e (ASM_ARITH_TAC);;
e (REPEAT GEN_TAC);;
e (STRIP_TAC);;
e (SIMP_TAC [LENGTH_APPEND; MEM]);;
e (UNDISCH_TAC `!k x y.
          x < LENGTH (k:(((A)list) list)) /\
          y < LENGTH k /\
          (!j. MEM j k ==> MEM j l \/ (?q. MEM q e /\ MEM j (SND q)))
          ==> (if EL x k = EL m' l /\ EL y k = EL n' (l:(((A)list) list))
               then HD (zsyn_conjun_intro k x y) = FST (EL z e)
               else !a. MEM a (e:((((A)list) # ((A)list) list) list)) ==> ~(FST a = HD (zsyn_conjun_intro k x y)))`);;
e (DISCH_THEN (MP_TAC o SPEC `(zsyn_delet (APPEND (l:(((A)list) list)) (SND (EL z (e:((((A)list) # ((A)list) list) list))))) m' n')`));;
e (DISCH_THEN (MP_TAC o SPEC `x:num`));;
e (DISCH_THEN (MP_TAC o SPEC `y:num`));;
e (ASM_SIMP_TAC [LENGTH_APPEND]);;
e (DISCH_TAC);;
e (SUBGOAL_THEN `!j. MEM j (APPEND (zsyn_delet (l:(((A)list) list)) m' n') (SND (EL z (e:((((A)list) # ((A)list) list) list))))) 
==> MEM j l \/ ?q. (MEM q e /\ MEM j (SND q))` ASSUME_TAC);;

r (1);;

e (SUBGOAL_THEN `(zsyn_delet (APPEND l (SND (EL z e))) m' n') = (APPEND (zsyn_delet (l:(((A)list) list)) m' n') (SND (EL z (e:((((A)list) # ((A)list) list) list)))))` ASSUME_TAC);;
      e (MATCH_MP_TAC zsyn_delet_ASSOC_THM);;
      e (ASM_SIMP_TAC []);;
      e (STRIP_TAC);;
      e (ASM_ARITH_TAC);;
      e (ASM_ARITH_TAC);;

e (ASM_SIMP_TAC []);;
e (SUBGOAL_THEN `(~MEM (EL m' (l:(((A)list) list))) (zsyn_delet (APPEND l (SND (EL z (e:((((A)list) # ((A)list) list) list))))) m' n'))` ASSUME_TAC);;
      e (MATCH_MP_TAC zsyn_delet_THM);;
      e (ASM_SIMP_TAC []);;
      e (STRIP_TAC);;
      e (ASM_ARITH_TAC);;
      e (ASM_ARITH_TAC);;

e (UNDISCH_TAC `(!j. MEM j (zsyn_delet (APPEND (l:(((A)list) list)) (SND (EL z e))) m' n')
           ==> MEM j l \/ (?q. MEM q e /\ MEM j (SND q)))
      ==> (if EL x (zsyn_delet (APPEND l (SND (EL z e))) m' n') = EL m' l /\
              EL y (zsyn_delet (APPEND l (SND (EL z e))) m' n') = EL n' l
           then HD
                (zsyn_conjun_intro (zsyn_delet (APPEND l (SND (EL z (e:((((A)list) # ((A)list) list) list))))) m' n') x y) =
                FST (EL z e)
           else !a. MEM a e
                    ==> ~(FST a =
                          HD
                          (zsyn_conjun_intro (zsyn_delet (APPEND l (SND (EL z e))) m' n')
                           x
                          y)))`);;
e (COND_CASES_TAC);;
e (ASM_SIMP_TAC []);;

r (1);;

e (ASM_SIMP_TAC []);;

r (1);;

e (DISCH_TAC);;
e (SUBGOAL_THEN `(MEM (EL m' (l:(((A)list) list))) (zsyn_delet (APPEND l (SND (EL z (e:((((A)list) # ((A)list) list) list))))) m' n'))` ASSUME_TAC);;
      e (SIMP_TAC [MEM_EXISTS_EL]);;
      e (ASM_SIMP_TAC []);;
      e (SIMP_TAC [LENGTH_APPEND]);;
      e (EXISTS_TAC `x:num`);;
      e (ASM_SIMP_TAC []);;
      e (ASM_MESON_TAC []);;

e (ASM_MESON_TAC []);;

e (SIMP_TAC [MEM_APPEND]);;
e (REPEAT STRIP_TAC);;
e (SUBGOAL_THEN `MEM j (l:(((A)list) list))` ASSUME_TAC);;
      e (MATCH_MP_TAC zsyn_delet_MEM_THM);;
      e (EXISTS_TAC `m':num`);;
      e (EXISTS_TAC `n':num`);;
      e (ASM_SIMP_TAC []);;
      e (STRIP_TAC);;
      e (ASM_ARITH_TAC);;
      e (ASM_ARITH_TAC);;

e (DISJ1_TAC);;
e (ASM_SIMP_TAC []);;

e (SUBGOAL_THEN `~MEM j (l:(((A)list) list))` ASSUME_TAC);;
      e (UNDISCH_TAC `ALL_DISTINCT (APPEND (l:(((A)list) list)) (SND (EL z (e:((((A)list) # ((A)list) list) list)))))`);;
      e (SIMP_TAC [ALL_DISTINCT_APPEND]);;
      e (STRIP_TAC);;
      e (POP_ASSUM MP_TAC);;
      e (DISCH_THEN (MP_TAC o SPEC `(j:(A)list)`));;
      e (DISCH_TAC);;
      e (STRIP_TAC);;
      e (UNDISCH_TAC `MEM j (l:(((A)list) list)) ==> ~MEM j (SND (EL z (e:((((A)list) # ((A)list) list) list))))`);;
      e (ASM_REWRITE_TAC []);;

e (DISJ2_TAC);;
e (EXISTS_TAC `(EL z (e:((((A)list) # ((A)list) list) list)))`);;
e (ASM_REWRITE_TAC []);;
e (SIMP_TAC [MEM_EXISTS_EL]);;
e (EXISTS_TAC `z:num`);;
e (ASM_SIMP_TAC []);;

let Z_DED_MATCH_THM = top_thm ();;

(*---------------------------------------------------------------------------*)
(* 			   z_DEDUCTION_MATCH_THM 			                             *)
(*---------------------------------------------------------------------------*)

g `!(e:((((A)list) # ((A)list) list) list)) (l:(((A)list) list)) z x' y'.
      ~NULL e /\ 1 < LENGTH l /\ x' < LENGTH l /\ y' < LENGTH l /\
      ALL_DISTINCT (APPEND l (SND (EL z e))) /\ z < LENGTH e /\ ~(x' = y') /\
      (!a b. ~(a = b)  ==> ~(FST (EL a e) = FST (EL b e))) /\ ~NULL (SND (EL z e)) /\  
      (!k x y. x < LENGTH k /\ y < LENGTH k /\ (!j. MEM j k ==> MEM j l \/ ?q. (MEM q e /\ MEM j (SND q))) ==>
      if ((EL x (k:(((A)list) list)) = EL x' l) /\ (EL y k = EL y' l)) then
      	 (HD (zsyn_conjun_intro k x y) = FST (EL z e))
      else
	 (!a. MEM a e ==> ~(FST a = HD (zsyn_conjun_intro k x y))))
      ==> ((zsyn_deduct l e) = (zsyn_delet (APPEND l (SND (EL z e))) x' y'))`;;

e (REPEAT GEN_TAC);;
e (REPEAT STRIP_TAC);;
e (REWRITE_TAC [zsyn_deduct]);;
e (SUBGOAL_THEN `(zsyn_deduct_recurs l e (LENGTH l - 1) (LENGTH l - 1) 
  	    (LENGTH (e:((((A)list) # ((A)list) list) list))) = (T,(zsyn_delet (APPEND l (SND (EL z e))) x' y')))` ASSUME_TAC);;
      e (MATCH_MP_TAC Z_DED_MATCH_THM);;
      e (ASM_SIMP_TAC []);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (CONJ_TAC);;
      e (ASM_ARITH_TAC);;
      e (ASM_ARITH_TAC);;

e (ASM_SIMP_TAC []);;

let Z_DEDUCTION_THM = top_thm ();;

(*===========================================================================*)
(*                       The Simplifier Z_SYNTAX_SIMP                        *)
(*===========================================================================*)

let Z_SYNTAX_SIMP x =

REWRITE_TAC[zsyn_deduct;LENGTH] THEN NUM_REDUCE_TAC THEN

ONCE_REWRITE_TAC [zsyn_deduct_recurs; G1;G2;G3;G4;G5;G6;G7] THEN
ONCE_REWRITE_TAC [zsyn_deduct_recurs; G1;G2;G3;G4;G5;G6;G7] THEN
REWRITE_TAC[LENGTH] THEN NUM_REDUCE_TAC THEN
REWRITE_TAC [zsyn_recurs2; G1;G2;G3;G4;G5;G6;G7] THEN
REWRITE_TAC[LENGTH] THEN NUM_REDUCE_TAC THEN
REWRITE_TAC [zsyn_recurs1; G1;G2;G3;G4;G5;G6;G7] THEN
REWRITE_TAC [zsyn_conjun_intro;EL;FLAT;APPEND;HD;TL; G1;G2;G3;G4;G5;G6;G7] THEN
REWRITE_TAC[LENGTH] THEN NUM_REDUCE_TAC THEN
REWRITE_TAC [x; G1;G2;G3;G4;G5;G6;G7] THEN NUM_REDUCE_TAC THEN
REWRITE_TAC [EL;HD;APPEND;TL; G1;G2;G3;G4;G5;G6;G7] THEN
NUM_REDUCE_TAC THEN
REWRITE_TAC[injectivity "list"] THEN REWRITE_TAC[DE_MORGAN_THM] THEN
REWRITE_TAC[CONS_11; NOT_CONS_NIL] THEN
ONCE_SIMP_TAC [] THEN
ONCE_SIMP_TAC [MESON[] `if F /\ F then T else k = k`] THEN
REWRITE_TAC [zsyn_delet;delet;EL;FLAT;APPEND;HD;TL;G1;G2;G3;G4;G5;G6;G7] THEN
NUM_REDUCE_TAC THEN
REWRITE_TAC[LENGTH] THEN NUM_REDUCE_TAC ;;

(*===========================================================================*)
(*                 A Reaction Leading to TP53 Phosphorylation                *)
(*===========================================================================*)

(*---------------------------------------------------------------------------*)
(*                             CASE STUDY I                                  *)
(*---------------------------------------------------------------------------*)

g `DISTINCT [(TP53:num); ATP; Kinase; ADP; pTP53]
 ==> zsyn_conjun_elimin
     (zsyn_deduct 
     [[TP53]; [ATP]; [Kinase]]
     [[Kinase; ATP],[[ATP; Kinase]]; 
	  [ATP;Kinase; TP53],[[Kinase]; [pTP53];[ADP]]])
     [pTP53] =
     [[pTP53]]`;;


(* ------------------------------------------------------------------------- *)
(*                                 Proof:                                    *)
(* ------------------------------------------------------------------------- *)

e (SIMP_TAC [DISTINCT;UNIQ_MEM;MEM;DE_MORGAN_THM; MESON[]`(a /\ b) /\ c <=> a /\ b /\ c`]);;

e (Z_SYNTAX_SIMP zsyn_EVF);;
e (Z_SYNTAX_SIMP zsyn_EVF);;
e (Z_SYNTAX_SIMP zsyn_EVF);;
e (REWRITE_TAC [zsyn_conjun_elimin]);;
e (REWRITE_TAC [MEM]);;

let  TP53_THEOREM = top_thm ();;

(*===========================================================================*)
(*           A Reaction Leading to CSCs Death in Tumor Growth Model          *)
(*===========================================================================*)

(*---------------------------------------------------------------------------*)
(*                             CASE STUDY II                                 *)
(*---------------------------------------------------------------------------*)

g `DISTINCT [(CSC:num); P; D; M]
 ==> zsyn_conjun_elimin
     (zsyn_deduct [[CSC]; [P]; [D]]
     [[CSC],[[P; CSC]]; 
	  [P; CSC],[[M]] ]) [M] = [[M]]`;;


(* ------------------------------------------------------------------------- *)
(*                                 Proof:                                    *)
(* ------------------------------------------------------------------------- *)

e (SIMP_TAC [DISTINCT;UNIQ_MEM;MEM;DE_MORGAN_THM; MESON[]`(a /\ b) /\ c <=> a /\ b /\ c`]);;

e (Z_SYNTAX_SIMP zsyn_EVF);;
e (Z_SYNTAX_SIMP zsyn_EVF);;
e (REWRITE_TAC [zsyn_conjun_elimin]);;
e (REWRITE_TAC [MEM]);;

let  CSC_THEOREM = top_thm ();;


(*---------------------------------------------------------------------------*)
(*--------------------------------END_OF_FILE--------------------------------*)
(*---------------------------------------------------------------------------*)