lexing: thys/Re.thy@a8bcb5a0f9b9 (annotated)

82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	2	theory Re
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	3	imports "Main"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	4	begin
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	5
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	6
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	7	section {* Sequential Composition of Sets *}
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	8
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	9	definition
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	10	Sequ :: "string set \<Rightarrow> string set \<Rightarrow> string set" ("_ ;; _" [100,100] 100)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	11	where
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	12	"A ;; B = {s1 @ s2 \| s1 s2. s1 \<in> A \<and> s2 \<in> B}"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	13
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	14	text {* Two Simple Properties about Sequential Composition *}
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	15
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	16	lemma seq_empty [simp]:
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	17	shows "A ;; {[]} = A"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	18	and "{[]} ;; A = A"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	19	by (simp_all add: Sequ_def)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	20
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	21	lemma seq_null [simp]:
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	22	shows "A ;; {} = {}"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	23	and "{} ;; A = {}"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	24	by (simp_all add: Sequ_def)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	25
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	26	section {* Regular Expressions *}
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	27
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	28	datatype rexp =
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	29	NULL
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	30	\| EMPTY
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	31	\| CHAR char
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	32	\| SEQ rexp rexp
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	33	\| ALT rexp rexp
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	34
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	35	section {* Semantics of Regular Expressions *}
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	36
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	37	fun
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	38	L :: "rexp \<Rightarrow> string set"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	39	where
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	40	"L (NULL) = {}"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	41	\| "L (EMPTY) = {[]}"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	42	\| "L (CHAR c) = {[c]}"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	43	\| "L (SEQ r1 r2) = (L r1) ;; (L r2)"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	44	\| "L (ALT r1 r2) = (L r1) \<union> (L r2)"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	45
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	46	fun
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	47	nullable :: "rexp \<Rightarrow> bool"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	48	where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	49	"nullable (NULL) = False"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	50	\| "nullable (EMPTY) = True"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	51	\| "nullable (CHAR c) = False"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	52	\| "nullable (ALT r1 r2) = (nullable r1 \<or> nullable r2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	53	\| "nullable (SEQ r1 r2) = (nullable r1 \<and> nullable r2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	54
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	55	lemma nullable_correctness:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	56	shows "nullable r \<longleftrightarrow> [] \<in> (L r)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	57	apply (induct r)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	58	apply(auto simp add: Sequ_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	59	done
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	60
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	61	section {* Values *}
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	62
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	63	datatype val =
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	64	Void
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	65	\| Char char
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	66	\| Seq val val
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	67	\| Right val
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	68	\| Left val
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	69
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	70	section {* The string behind a value *}
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	71
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	72	fun
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	73	flat :: "val \<Rightarrow> string"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	74	where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	75	"flat(Void) = []"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	76	\| "flat(Char c) = [c]"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	77	\| "flat(Left v) = flat(v)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	78	\| "flat(Right v) = flat(v)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	79	\| "flat(Seq v1 v2) = flat(v1) @ flat(v2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	80
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	81	section {* Relation between values and regular expressions *}
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	82
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	83	inductive
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	84	Prf :: "val \<Rightarrow> rexp \<Rightarrow> bool" ("\<turnstile> _ : _" [100, 100] 100)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	85	where
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	86	"\<lbrakk>\<turnstile> v1 : r1; \<turnstile> v2 : r2\<rbrakk> \<Longrightarrow> \<turnstile> Seq v1 v2 : SEQ r1 r2"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	87	\| "\<turnstile> v1 : r1 \<Longrightarrow> \<turnstile> Left v1 : ALT r1 r2"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	88	\| "\<turnstile> v2 : r2 \<Longrightarrow> \<turnstile> Right v2 : ALT r1 r2"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	89	\| "\<turnstile> Void : EMPTY"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	90	\| "\<turnstile> Char c : CHAR c"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	91
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	92	lemma not_nullable_flat:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	93	assumes "\<turnstile> v : r" "\<not>nullable r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	94	shows "flat v \<noteq> []"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	95	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	96	apply(induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	97	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	98	done
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	99
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	100	lemma Prf_flat_L:
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	101	assumes "\<turnstile> v : r" shows "flat v \<in> L r"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	102	using assms
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	103	apply(induct v r rule: Prf.induct)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	104	apply(auto simp add: Sequ_def)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	105	done
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	106
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	107	lemma L_flat_Prf:
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	108	"L(r) = {flat v \| v. \<turnstile> v : r}"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	109	apply(induct r)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	110	apply(auto dest: Prf_flat_L simp add: Sequ_def)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	111	apply (metis Prf.intros(4) flat.simps(1))
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	112	apply (metis Prf.intros(5) flat.simps(2))
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	113	apply (metis Prf.intros(1) flat.simps(5))
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	114	apply (metis Prf.intros(2) flat.simps(3))
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	115	apply (metis Prf.intros(3) flat.simps(4))
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	116	apply(erule Prf.cases)
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	117	apply(auto)
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	118	done
6 87618dae0e04 getting back the original version by Sulzmann Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 5 diff changeset	119
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	120	section {* Greedy Ordering according to Frisch/Cardelli *}
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	121
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	122	inductive
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	123	GrOrd :: "val \<Rightarrow> val \<Rightarrow> bool" ("_ gr\<succ> _")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	124	where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	125	"v1 gr\<succ> v1' \<Longrightarrow> (Seq v1 v2) gr\<succ> (Seq v1' v2')"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	126	\| "v2 gr\<succ> v2' \<Longrightarrow> (Seq v1 v2) gr\<succ> (Seq v1 v2')"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	127	\| "v1 gr\<succ> v2 \<Longrightarrow> (Left v1) gr\<succ> (Left v2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	128	\| "v1 gr\<succ> v2 \<Longrightarrow> (Right v1) gr\<succ> (Right v2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	129	\| "(Left v2) gr\<succ>(Right v1)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	130	\| "(Char c) gr\<succ> (Char c)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	131	\| "(Void) gr\<succ> (Void)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	132
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	133	lemma Gr_refl:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	134	assumes "\<turnstile> v : r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	135	shows "v gr\<succ> v"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	136	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	137	apply(induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	138	apply(auto intro: GrOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	139	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	140
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	141	lemma Gr_total:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	142	assumes "\<turnstile> v1 : r" "\<turnstile> v2 : r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	143	shows "v1 gr\<succ> v2 \<or> v2 gr\<succ> v1"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	144	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	145	apply(induct v1 r arbitrary: v2 rule: Prf.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	146	apply(rotate_tac 4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	147	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	148	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	149	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	150	apply (metis GrOrd.intros(1) GrOrd.intros(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	151	apply(rotate_tac 2)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	152	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	153	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	154	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	155	apply (metis GrOrd.intros(3))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	156	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	157	apply (metis GrOrd.intros(5))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	158	apply(rotate_tac 2)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	159	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	160	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	161	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	162	apply (metis GrOrd.intros(5))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	163	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	164	apply (metis GrOrd.intros(4))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	165	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	166	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	167	apply (metis GrOrd.intros(7))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	168	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	169	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	170	apply (metis GrOrd.intros(6))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	171	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	172
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	173	lemma Gr_trans:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	174	assumes "v1 gr\<succ> v2" "v2 gr\<succ> v3"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	175	and "\<turnstile> v1 : r" "\<turnstile> v2 : r" "\<turnstile> v3 : r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	176	shows "v1 gr\<succ> v3"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	177	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	178	apply(induct r arbitrary: v1 v2 v3)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	179	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	180	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	181	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	182	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	183	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	184	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	185	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	186	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	187	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	188	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	189	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	190	(* ALT case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	191	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	192	apply(simp_all (no_asm_use))[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	193	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	194	apply(simp_all (no_asm_use))[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	195	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	196	apply(simp_all (no_asm_use))[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	197	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	198	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	199	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	200	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	201	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	202	apply (metis GrOrd.intros(3))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	203	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	204	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	205	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	206	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	207	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	208	apply (metis GrOrd.intros(5))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	209	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	210	apply(simp_all (no_asm_use))[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	211	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	212	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	213	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	214	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	215	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	216	apply (metis GrOrd.intros(5))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	217	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	218	apply(simp_all (no_asm_use))[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	219	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	220	apply(simp_all (no_asm_use))[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	221	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	222	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	223	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	224	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	225	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	226	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	227	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	228	apply(simp_all (no_asm_use))[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	229	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	230	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	231	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	232	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	233	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	234	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	235	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	236	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	237	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	238	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	239	apply (metis GrOrd.intros(4))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	240	(* SEQ case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	241	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	242	apply(simp_all (no_asm_use))[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	243	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	244	apply(simp_all (no_asm_use))[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	245	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	246	apply(simp_all (no_asm_use))[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	247	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	248	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	249	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	250	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	251	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	252	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	253	apply (metis GrOrd.intros(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	254	apply (metis GrOrd.intros(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	255	apply(erule GrOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	256	apply(simp_all (no_asm_use))[7]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	257	apply (metis GrOrd.intros(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	258	by (metis GrOrd.intros(1) Gr_refl)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	259
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	260
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	261	section {* Values Sets *}
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	262
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	263	definition prefix :: "string \<Rightarrow> string \<Rightarrow> bool" ("_ \<sqsubseteq> _" [100, 100] 100)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	264	where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	265	"s1 \<sqsubseteq> s2 \<equiv> \<exists>s3. s1 @ s3 = s2"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	266
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	267	definition sprefix :: "string \<Rightarrow> string \<Rightarrow> bool" ("_ \<sqsubset> _" [100, 100] 100)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	268	where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	269	"s1 \<sqsubset> s2 \<equiv> (s1 \<sqsubseteq> s2 \<and> s1 \<noteq> s2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	270
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	271	lemma length_sprefix:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	272	"s1 \<sqsubset> s2 \<Longrightarrow> length s1 < length s2"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	273	unfolding sprefix_def prefix_def
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	274	by (auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	275
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	276	definition Prefixes :: "string \<Rightarrow> string set" where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	277	"Prefixes s \<equiv> {sp. sp \<sqsubseteq> s}"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	278
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	279	definition Suffixes :: "string \<Rightarrow> string set" where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	280	"Suffixes s \<equiv> rev ` (Prefixes (rev s))"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	281
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	282	lemma Suffixes_in:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	283	"\<exists>s1. s1 @ s2 = s3 \<Longrightarrow> s2 \<in> Suffixes s3"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	284	unfolding Suffixes_def Prefixes_def prefix_def image_def
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	285	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	286	by (metis rev_rev_ident)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	287
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	288	lemma Prefixes_Cons:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	289	"Prefixes (c # s) = {[]} \<union> {c # sp \| sp. sp \<in> Prefixes s}"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	290	unfolding Prefixes_def prefix_def
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	291	apply(auto simp add: append_eq_Cons_conv)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	292	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	293
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	294	lemma finite_Prefixes:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	295	"finite (Prefixes s)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	296	apply(induct s)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	297	apply(auto simp add: Prefixes_def prefix_def)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	298	apply(simp add: Prefixes_Cons)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	299	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	300
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	301	lemma finite_Suffixes:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	302	"finite (Suffixes s)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	303	unfolding Suffixes_def
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	304	apply(rule finite_imageI)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	305	apply(rule finite_Prefixes)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	306	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	307
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	308	lemma prefix_Cons:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	309	"((c # s1) \<sqsubseteq> (c # s2)) = (s1 \<sqsubseteq> s2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	310	apply(auto simp add: prefix_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	311	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	312
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	313	lemma prefix_append:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	314	"((s @ s1) \<sqsubseteq> (s @ s2)) = (s1 \<sqsubseteq> s2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	315	apply(induct s)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	316	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	317	apply(simp add: prefix_Cons)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	318	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	319
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	320
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	321	definition Values :: "rexp \<Rightarrow> string \<Rightarrow> val set" where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	322	"Values r s \<equiv> {v. \<turnstile> v : r \<and> flat v \<sqsubseteq> s}"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	323
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	324	definition rest :: "val \<Rightarrow> string \<Rightarrow> string" where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	325	"rest v s \<equiv> drop (length (flat v)) s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	326
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	327	lemma rest_Suffixes:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	328	"rest v s \<in> Suffixes s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	329	unfolding rest_def
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	330	by (metis Suffixes_in append_take_drop_id)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	331
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	332
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	333	lemma Values_recs:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	334	"Values (NULL) s = {}"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	335	"Values (EMPTY) s = {Void}"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	336	"Values (CHAR c) s = (if [c] \<sqsubseteq> s then {Char c} else {})"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	337	"Values (ALT r1 r2) s = {Left v \| v. v \<in> Values r1 s} \<union> {Right v \| v. v \<in> Values r2 s}"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	338	"Values (SEQ r1 r2) s = {Seq v1 v2 \| v1 v2. v1 \<in> Values r1 s \<and> v2 \<in> Values r2 (rest v1 s)}"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	339	unfolding Values_def
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	340	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	341	(NULL)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	342	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	343	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	344	(EMPTY)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	345	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	346	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	347	apply(rule Prf.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	348	apply (metis append_Nil prefix_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	349	(CHAR)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	350	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	351	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	352	apply(rule Prf.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	353	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	354	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	355	(ALT)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	356	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	357	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	358	apply (metis Prf.intros(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	359	apply (metis Prf.intros(3))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	360	(SEQ)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	361	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	362	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	363	apply (simp add: append_eq_conv_conj prefix_def rest_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	364	apply (metis Prf.intros(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	365	apply (simp add: append_eq_conv_conj prefix_def rest_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	366	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	367
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	368	lemma Values_finite:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	369	"finite (Values r s)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	370	apply(induct r arbitrary: s)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	371	apply(simp_all add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	372	thm finite_surj
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	373	apply(rule_tac f="\<lambda>(x, y). Seq x y" and
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	374	A="{(v1, v2) \| v1 v2. v1 \<in> Values r1 s \<and> v2 \<in> Values r2 (rest v1 s)}" in finite_surj)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	375	prefer 2
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	376	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	377	apply(rule_tac B="\<Union>sp \<in> Suffixes s. {(v1, v2). v1 \<in> Values r1 s \<and> v2 \<in> Values r2 sp}" in finite_subset)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	378	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	379	apply (metis rest_Suffixes)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	380	apply(rule finite_UN_I)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	381	apply(rule finite_Suffixes)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	382	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	383	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	384
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	385	section {* Sulzmann functions *}
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	386
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	387	fun
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	388	mkeps :: "rexp \<Rightarrow> val"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	389	where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	390	"mkeps(EMPTY) = Void"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	391	\| "mkeps(SEQ r1 r2) = Seq (mkeps r1) (mkeps r2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	392	\| "mkeps(ALT r1 r2) = (if nullable(r1) then Left (mkeps r1) else Right (mkeps r2))"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	393
83 a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	394	section {* Derivatives *}
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	395
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	396	fun
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	397	der :: "char \<Rightarrow> rexp \<Rightarrow> rexp"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	398	where
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	399	"der c (NULL) = NULL"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	400	\| "der c (EMPTY) = NULL"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	401	\| "der c (CHAR c') = (if c = c' then EMPTY else NULL)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	402	\| "der c (ALT r1 r2) = ALT (der c r1) (der c r2)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	403	\| "der c (SEQ r1 r2) =
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	404	(if nullable r1
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	405	then ALT (SEQ (der c r1) r2) (der c r2)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	406	else SEQ (der c r1) r2)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	407
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	408	fun
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	409	ders :: "string \<Rightarrow> rexp \<Rightarrow> rexp"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	410	where
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	411	"ders [] r = r"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	412	\| "ders (c # s) r = ders s (der c r)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	413
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	414
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	415	section {* Injection function *}
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	416
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	417	fun injval :: "rexp \<Rightarrow> char \<Rightarrow> val \<Rightarrow> val"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	418	where
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	419	"injval (EMPTY) c Void = Char c"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	420	\| "injval (CHAR d) c Void = Char d"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	421	\| "injval (CHAR d) c (Char c') = Seq (Char d) (Char c')"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	422	\| "injval (ALT r1 r2) c (Left v1) = Left(injval r1 c v1)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	423	\| "injval (ALT r1 r2) c (Right v2) = Right(injval r2 c v2)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	424	\| "injval (SEQ r1 r2) c (Char c') = Seq (Char c) (Char c')"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	425	\| "injval (SEQ r1 r2) c (Seq v1 v2) = Seq (injval r1 c v1) v2"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	426	\| "injval (SEQ r1 r2) c (Left (Seq v1 v2)) = Seq (injval r1 c v1) v2"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	427	\| "injval (SEQ r1 r2) c (Right v2) = Seq (mkeps r1) (injval r2 c v2)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	428
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	429
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	430	section {* Projection function *}
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	431
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	432	fun projval :: "rexp \<Rightarrow> char \<Rightarrow> val \<Rightarrow> val"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	433	where
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	434	"projval (CHAR d) c _ = Void"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	435	\| "projval (ALT r1 r2) c (Left v1) = Left (projval r1 c v1)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	436	\| "projval (ALT r1 r2) c (Right v2) = Right (projval r2 c v2)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	437	\| "projval (SEQ r1 r2) c (Seq v1 v2) =
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	438	(if flat v1 = [] then Right(projval r2 c v2)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	439	else if nullable r1 then Left (Seq (projval r1 c v1) v2)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	440	else Seq (projval r1 c v1) v2)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	441
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	442
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	443
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	444	lemma mkeps_nullable:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	445	assumes "nullable(r)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	446	shows "\<turnstile> mkeps r : r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	447	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	448	apply(induct rule: nullable.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	449	apply(auto intro: Prf.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	450	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	451
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	452	lemma mkeps_flat:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	453	assumes "nullable(r)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	454	shows "flat (mkeps r) = []"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	455	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	456	apply(induct rule: nullable.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	457	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	458	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	459
83 a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	460	lemma v3:
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	461	assumes "\<turnstile> v : der c r"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	462	shows "\<turnstile> (injval r c v) : r"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	463	using assms
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	464	apply(induct arbitrary: v rule: der.induct)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	465	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	466	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	467	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	468	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	469	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	470	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	471	apply(case_tac "c = c'")
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	472	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	473	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	474	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	475	apply (metis Prf.intros(5))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	476	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	477	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	478	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	479	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	480	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	481	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	482	apply (metis Prf.intros(2))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	483	apply (metis Prf.intros(3))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	484	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	485	apply(case_tac "nullable r1")
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	486	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	487	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	488	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	489	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	490	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	491	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	492	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	493	apply (metis Prf.intros(1))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	494	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	495	apply (metis Prf.intros(1) mkeps_nullable)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	496	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	497	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	498	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	499	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	500	apply(rule Prf.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	501	apply(auto)[2]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	502	done
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	503
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	504	lemma v3_proj:
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	505	assumes "\<turnstile> v : r" and "\<exists>s. (flat v) = c # s"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	506	shows "\<turnstile> (projval r c v) : der c r"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	507	using assms
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	508	apply(induct rule: Prf.induct)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	509	prefer 4
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	510	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	511	prefer 4
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	512	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	513	apply (metis Prf.intros(4))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	514	prefer 2
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	515	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	516	apply (metis Prf.intros(2))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	517	prefer 2
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	518	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	519	apply (metis Prf.intros(3))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	520	apply(auto)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	521	apply(rule Prf.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	522	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	523	apply (metis Prf_flat_L nullable_correctness)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	524	apply(rule Prf.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	525	apply(rule Prf.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	526	apply (metis Cons_eq_append_conv)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	527	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	528	apply(rule Prf.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	529	apply (metis Cons_eq_append_conv)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	530	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	531	done
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	532
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	533	lemma v4:
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	534	assumes "\<turnstile> v : der c r"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	535	shows "flat (injval r c v) = c # (flat v)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	536	using assms
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	537	apply(induct arbitrary: v rule: der.induct)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	538	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	539	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	540	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	541	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	542	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	543	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	544	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	545	apply(case_tac "c = c'")
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	546	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	547	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	548	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	549	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	550	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	551	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	552	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	553	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	554	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	555	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	556	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	557	apply(case_tac "nullable r1")
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	558	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	559	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	560	apply(simp_all (no_asm_use))[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	561	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	562	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	563	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	564	apply(clarify)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	565	apply(simp only: injval.simps flat.simps)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	566	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	567	apply (metis mkeps_flat)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	568	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	569	apply(erule Prf.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	570	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	571	done
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	572
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	573	lemma v4_proj:
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	574	assumes "\<turnstile> v : r" and "\<exists>s. (flat v) = c # s"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	575	shows "c # flat (projval r c v) = flat v"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	576	using assms
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	577	apply(induct rule: Prf.induct)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	578	prefer 4
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	579	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	580	prefer 4
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	581	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	582	prefer 2
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	583	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	584	prefer 2
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	585	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	586	apply(auto)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	587	by (metis Cons_eq_append_conv)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	588
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	589	lemma v4_proj2:
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	590	assumes "\<turnstile> v : r" and "(flat v) = c # s"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	591	shows "flat (projval r c v) = s"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	592	using assms
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	593	by (metis list.inject v4_proj)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	594
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	595
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	596	section {* Alternative Posix definition *}
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	597
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	598	inductive
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	599	PMatch :: "string \<Rightarrow> rexp \<Rightarrow> val \<Rightarrow> bool" ("_ \<in> _ \<rightarrow> _" [100, 100, 100] 100)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	600	where
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	601	"[] \<in> EMPTY \<rightarrow> Void"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	602	\| "[c] \<in> (CHAR c) \<rightarrow> (Char c)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	603	\| "s \<in> r1 \<rightarrow> v \<Longrightarrow> s \<in> (ALT r1 r2) \<rightarrow> (Left v)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	604	\| "\<lbrakk>s \<in> r2 \<rightarrow> v; s \<notin> L(r1)\<rbrakk> \<Longrightarrow> s \<in> (ALT r1 r2) \<rightarrow> (Right v)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	605	\| "\<lbrakk>s1 \<in> r1 \<rightarrow> v1; s2 \<in> r2 \<rightarrow> v2;
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	606	\<not>(\<exists>s3 s4. s3 \<noteq> [] \<and> s3 @ s4 = s2 \<and> (s1 @ s2) \<in> L r1 \<and> s4 \<in> L r2)\<rbrakk> \<Longrightarrow>
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	607	(s1 @ s2) \<in> (SEQ r1 r2) \<rightarrow> (Seq v1 v2)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	608
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	609	lemma PMatch_mkeps:
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	610	assumes "nullable r"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	611	shows " [] \<in> r \<rightarrow> mkeps r"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	612	using assms
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	613	apply(induct r)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	614	apply(auto)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	615	apply (metis PMatch.intros(1))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	616	apply(subst append.simps(1)[symmetric])
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	617	apply (rule PMatch.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	618	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	619	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	620	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	621	apply (rule PMatch.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	622	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	623	apply (rule PMatch.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	624	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	625	apply (rule PMatch.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	626	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	627	by (metis nullable_correctness)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	628
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	629
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	630	lemma PMatch1:
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	631	assumes "s \<in> r \<rightarrow> v"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	632	shows "\<turnstile> v : r" "flat v = s"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	633	using assms
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	634	apply(induct s r v rule: PMatch.induct)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	635	apply(auto)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	636	apply (metis Prf.intros(4))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	637	apply (metis Prf.intros(5))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	638	apply (metis Prf.intros(2))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	639	apply (metis Prf.intros(3))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	640	apply (metis Prf.intros(1))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	641	by (metis Prf.intros(1))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	642
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	643	lemma PMAtch2:
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	644	assumes "s \<in> (der c r) \<rightarrow> v"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	645	shows "(c#s) \<in> r \<rightarrow> (injval r c v)"
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	646	using assms
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	647	apply(induct c r arbitrary: s v rule: der.induct)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	648	apply(auto)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	649	apply(erule PMatch.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	650	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	651	apply(erule PMatch.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	652	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	653	apply(case_tac "c = c'")
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	654	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	655	apply(erule PMatch.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	656	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	657	apply (metis PMatch.intros(2))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	658	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	659	apply(erule PMatch.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	660	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	661	apply(erule PMatch.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	662	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	663	apply (metis PMatch.intros(3))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	664	apply(clarify)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	665	apply(rule PMatch.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	666	apply metis
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	667	apply(simp add: L_flat_Prf)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	668	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	669	thm v3_proj
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	670	apply(frule_tac c="c" in v3_proj)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	671	apply metis
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	672	apply(drule_tac x="projval r1 c v" in spec)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	673	apply(drule mp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	674	apply (metis v4_proj2)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	675	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	676	apply(case_tac "nullable r1")
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	677	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	678	defer
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	679	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	680	apply(erule PMatch.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	681	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	682	apply(clarify)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	683	apply(subst append.simps(2)[symmetric])
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	684	apply(rule PMatch.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	685	apply metis
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	686	apply metis
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	687	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	688	apply(simp add: L_flat_Prf)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	689	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	690	apply(frule_tac c="c" in v3_proj)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	691	apply metis
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	692	apply(drule_tac x="projval r1 c v" in spec)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	693	apply(drule mp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	694	apply (metis v4_proj2)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	695	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	696	(* nullable case *)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	697	apply(erule PMatch.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	698	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	699	apply(clarify)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	700	apply(erule PMatch.cases)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	701	apply(simp_all)[5]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	702	apply(clarify)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	703	apply(subst append.simps(2)[symmetric])
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	704	apply(rule PMatch.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	705	apply metis
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	706	apply metis
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	707	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	708	apply(simp add: L_flat_Prf)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	709	apply(auto)[1]
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	710	apply(frule_tac c="c" in v3_proj)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	711	apply metis
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	712	apply(drule_tac x="projval r1 c v" in spec)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	713	apply(drule mp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	714	apply (metis v4_proj2)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	715	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	716	(* interesting case *)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	717	apply(clarify)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	718	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	719	thm L.simps
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	720	apply(subst (asm) L.simps(4)[symmetric])
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	721	apply(simp only: L_flat_Prf)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	722	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	723	apply(subst append.simps(1)[symmetric])
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	724	apply(rule PMatch.intros)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	725	apply (metis PMatch_mkeps)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	726	apply metis
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	727	apply(auto)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	728	apply(simp only: L_flat_Prf)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	729	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	730	apply(auto)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	731	apply(drule_tac x="projval r1 c v" in spec)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	732	apply(drule mp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	733	apply (metis v4_proj2)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	734	apply(rotate_tac 1)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	735	apply(drule_tac x="sa" in meta_spec)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	736	apply(drule_tac x="va" in meta_spec)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	737	apply(simp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	738	apply(rotate_tac 2)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	739	apply(drule_tac x="sa" in meta_spec)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	740	apply(drule_tac x="projval r1 c v" in meta_spec)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	741	apply(drule meta_mp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	742	apply(frule_tac c="c" in v3_proj)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	743	apply metis
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	744
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	745	apply(frule PMatch1(1))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	746	apply(drule PMatch1(2))
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	747	apply(clarify)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	748	apply(subst (asm) (2) not_def)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	749	apply(drule mp)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	750	thm v3_proj
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	751	apply(rule v3_proj)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	752	apply(rule conjI)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	753	apply (metis v4_proj2)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	754	apply (metis v3_proj)
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	755	v3_proj
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	756
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	757
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	758
a8bcb5a0f9b9 added POSIX relation from the Type-Inference paper Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 82 diff changeset	759
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	760
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	761	section {* Sulzmann's Ordering of values *}
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	762
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	763	inductive ValOrd :: "val \<Rightarrow> rexp \<Rightarrow> val \<Rightarrow> bool" ("_ \<succ>_ _" [100, 100, 100] 100)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	764	where
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	765	"v2 \<succ>r2 v2' \<Longrightarrow> (Seq v1 v2) \<succ>(SEQ r1 r2) (Seq v1 v2')"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	766	\| "\<lbrakk>v1 \<succ>r1 v1'; v1 \<noteq> v1'\<rbrakk> \<Longrightarrow> (Seq v1 v2) \<succ>(SEQ r1 r2) (Seq v1' v2')"
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	767	\| "length (flat v1) \<ge> length (flat v2) \<Longrightarrow> (Left v1) \<succ>(ALT r1 r2) (Right v2)"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	768	\| "length (flat v2) > length (flat v1) \<Longrightarrow> (Right v2) \<succ>(ALT r1 r2) (Left v1)"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	769	\| "v2 \<succ>r2 v2' \<Longrightarrow> (Right v2) \<succ>(ALT r1 r2) (Right v2')"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	770	\| "v1 \<succ>r1 v1' \<Longrightarrow> (Left v1) \<succ>(ALT r1 r2) (Left v1')"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	771	\| "Void \<succ>EMPTY Void"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	772	\| "(Char c) \<succ>(CHAR c) (Char c)"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	773
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	774	inductive ValOrd2 :: "val \<Rightarrow> val \<Rightarrow> bool" ("_ 2\<succ> _" [100, 100] 100)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	775	where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	776	"v2 2\<succ> v2' \<Longrightarrow> (Seq v1 v2) 2\<succ> (Seq v1 v2')"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	777	\| "\<lbrakk>v1 2\<succ> v1'; v1 \<noteq> v1'\<rbrakk> \<Longrightarrow> (Seq v1 v2) 2\<succ> (Seq v1' v2')"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	778	\| "length (flat v1) \<ge> length (flat v2) \<Longrightarrow> (Left v1) 2\<succ> (Right v2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	779	\| "length (flat v2) > length (flat v1) \<Longrightarrow> (Right v2) 2\<succ> (Left v1)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	780	\| "v2 2\<succ> v2' \<Longrightarrow> (Right v2) 2\<succ> (Right v2')"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	781	\| "v1 2\<succ> v1' \<Longrightarrow> (Left v1) 2\<succ> (Left v1')"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	782	\| "Void 2\<succ> Void"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	783	\| "(Char c) 2\<succ> (Char c)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	784
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	785	lemma Ord1:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	786	"v1 \<succ>r v2 \<Longrightarrow> v1 2\<succ> v2"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	787	apply(induct rule: ValOrd.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	788	apply(auto intro: ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	789	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	790
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	791	lemma Ord2:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	792	"v1 2\<succ> v2 \<Longrightarrow> \<exists>r. v1 \<succ>r v2"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	793	apply(induct v1 v2 rule: ValOrd2.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	794	apply(auto intro: ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	795	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	796
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	797	lemma Ord3:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	798	"\<lbrakk>v1 2\<succ> v2; \<turnstile> v1 : r\<rbrakk> \<Longrightarrow> v1 \<succ>r v2"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	799	apply(induct v1 v2 arbitrary: r rule: ValOrd2.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	800	apply(auto intro: ValOrd.intros elim: Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	801	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	802
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	803	lemma ValOrd_refl:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	804	assumes "\<turnstile> v : r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	805	shows "v \<succ>r v"
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	806	using assms
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	807	apply(induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	808	apply(auto intro: ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	809	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	810
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	811	lemma ValOrd_total:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	812	shows "\<lbrakk>\<turnstile> v1 : r; \<turnstile> v2 : r\<rbrakk> \<Longrightarrow> v1 \<succ>r v2 \<or> v2 \<succ>r v1"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	813	apply(induct r arbitrary: v1 v2)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	814	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	815	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	816	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	817	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	818	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	819	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	820	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	821	apply (metis ValOrd.intros(7))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	822	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	823	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	824	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	825	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	826	apply (metis ValOrd.intros(8))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	827	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	828	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	829	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	830	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	831	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	832	apply(case_tac "v1a = v1b")
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	833	apply(simp)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	834	apply(rule ValOrd.intros(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	835	apply (metis ValOrd.intros(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	836	apply(rule ValOrd.intros(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	837	apply(auto)[2]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	838	apply(erule contrapos_np)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	839	apply(rule ValOrd.intros(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	840	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	841	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	842	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	843	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	844	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	845	apply (metis Ord1 Ord3 Prf.intros(2) ValOrd2.intros(6))
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	846	apply(rule ValOrd.intros)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	847	apply(erule contrapos_np)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	848	apply(rule ValOrd.intros)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	849	apply (metis le_eq_less_or_eq neq_iff)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	850	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	851	apply(simp_all)[5]
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	852	apply(rule ValOrd.intros)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	853	apply(erule contrapos_np)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	854	apply(rule ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	855	apply (metis le_eq_less_or_eq neq_iff)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	856	apply(rule ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	857	apply(erule contrapos_np)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	858	apply(rule ValOrd.intros)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	859	by metis
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	860
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	861	lemma ValOrd_anti:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	862	shows "\<lbrakk>\<turnstile> v1 : r; \<turnstile> v2 : r; v1 \<succ>r v2; v2 \<succ>r v1\<rbrakk> \<Longrightarrow> v1 = v2"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	863	apply(induct r arbitrary: v1 v2)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	864	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	865	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	866	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	867	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	868	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	869	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	870	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	871	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	872	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	873	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	874	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	875	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	876	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	877	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	878	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	879	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	880	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	881	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	882	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	883	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	884	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	885	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	886	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	887	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	888	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	889	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	890	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	891	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	892	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	893	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	894	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	895	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	896	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	897	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	898	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	899	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	900	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	901	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	902	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	903	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	904	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	905	apply(simp_all)[8]
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	906	done
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	907
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	908	lemma refl_on_ValOrd:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	909	"refl_on (Values r s) {(v1, v2). v1 \<succ>r v2 \<and> v1 \<in> Values r s \<and> v2 \<in> Values r s}"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	910	unfolding refl_on_def
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	911	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	912	apply(rule ValOrd_refl)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	913	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	914	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	915
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	916
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	917	section {* Posix definition *}
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	918
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	919	definition POSIX :: "val \<Rightarrow> rexp \<Rightarrow> bool"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	920	where
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	921	"POSIX v r \<equiv> (\<turnstile> v : r \<and> (\<forall>v'. (\<turnstile> v' : r \<and> flat v = flat v') \<longrightarrow> v \<succ>r v'))"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	922
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	923	definition POSIX2 :: "val \<Rightarrow> rexp \<Rightarrow> bool"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	924	where
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	925	"POSIX2 v r \<equiv> (\<turnstile> v : r \<and> (\<forall>v'. (\<turnstile> v' : r \<and> flat v = flat v') \<longrightarrow> v 2\<succ> v'))"
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	926
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	927	lemma "POSIX v r = POSIX2 v r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	928	unfolding POSIX_def POSIX2_def
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	929	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	930	apply(rule Ord1)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	931	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	932	apply(rule Ord3)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	933	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	934	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	935
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	936	section {* POSIX for some constructors *}
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	937
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	938	lemma POSIX_SEQ1:
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	939	assumes "POSIX (Seq v1 v2) (SEQ r1 r2)" "\<turnstile> v1 : r1" "\<turnstile> v2 : r2"
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	940	shows "POSIX v1 r1"
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	941	using assms
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	942	unfolding POSIX_def
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	943	apply(auto)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	944	apply(drule_tac x="Seq v' v2" in spec)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	945	apply(simp)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	946	apply(erule impE)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	947	apply(rule Prf.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	948	apply(simp)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	949	apply(simp)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	950	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	951	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	952	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	953	by (metis ValOrd_refl)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	954
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	955	lemma POSIX_SEQ2:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	956	assumes "POSIX (Seq v1 v2) (SEQ r1 r2)" "\<turnstile> v1 : r1" "\<turnstile> v2 : r2"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	957	shows "POSIX v2 r2"
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	958	using assms
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	959	unfolding POSIX_def
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	960	apply(auto)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	961	apply(drule_tac x="Seq v1 v'" in spec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	962	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	963	apply(erule impE)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	964	apply(rule Prf.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	965	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	966	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	967	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	968	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	969	done
8 a605dda64267 started a few arguments for the ALT case Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 7 diff changeset	970
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	971	lemma POSIX_ALT2:
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	972	assumes "POSIX (Left v1) (ALT r1 r2)"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	973	shows "POSIX v1 r1"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	974	using assms
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	975	unfolding POSIX_def
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	976	apply(auto)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	977	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	978	apply(simp_all)[5]
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	979	apply(drule_tac x="Left v'" in spec)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	980	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	981	apply(drule mp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	982	apply(rule Prf.intros)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	983	apply(auto)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	984	apply(erule ValOrd.cases)
8 a605dda64267 started a few arguments for the ALT case Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 7 diff changeset	985	apply(simp_all)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	986	done
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	987
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	988	lemma POSIX_ALT1a:
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	989	assumes "POSIX (Right v2) (ALT r1 r2)"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	990	shows "POSIX v2 r2"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	991	using assms
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	992	unfolding POSIX_def
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	993	apply(auto)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	994	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	995	apply(simp_all)[5]
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	996	apply(drule_tac x="Right v'" in spec)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	997	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	998	apply(drule mp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	999	apply(rule Prf.intros)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1000	apply(auto)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1001	apply(erule ValOrd.cases)
8 a605dda64267 started a few arguments for the ALT case Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 7 diff changeset	1002	apply(simp_all)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1003	done
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1004
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1005	lemma POSIX_ALT1b:
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1006	assumes "POSIX (Right v2) (ALT r1 r2)"
8 a605dda64267 started a few arguments for the ALT case Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 7 diff changeset	1007	shows "(\<forall>v'. (\<turnstile> v' : r2 \<and> flat v' = flat v2) \<longrightarrow> v2 \<succ>r2 v')"
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1008	using assms
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1009	apply(drule_tac POSIX_ALT1a)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1010	unfolding POSIX_def
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1011	apply(auto)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1012	done
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1013
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1014	lemma POSIX_ALT_I1:
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1015	assumes "POSIX v1 r1"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1016	shows "POSIX (Left v1) (ALT r1 r2)"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1017	using assms
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1018	unfolding POSIX_def
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1019	apply(auto)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1020	apply (metis Prf.intros(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1021	apply(rotate_tac 2)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1022	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1023	apply(simp_all)[5]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1024	apply(auto)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1025	apply(rule ValOrd.intros)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1026	apply(auto)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1027	apply(rule ValOrd.intros)
8 a605dda64267 started a few arguments for the ALT case Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 7 diff changeset	1028	by simp
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1029
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1030	lemma POSIX_ALT_I2:
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1031	assumes "POSIX v2 r2" "\<forall>v'. \<turnstile> v' : r1 \<longrightarrow> length (flat v2) > length (flat v')"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1032	shows "POSIX (Right v2) (ALT r1 r2)"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1033	using assms
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1034	unfolding POSIX_def
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1035	apply(auto)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1036	apply (metis Prf.intros)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1037	apply(rotate_tac 3)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1038	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1039	apply(simp_all)[5]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1040	apply(auto)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1041	apply(rule ValOrd.intros)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1042	apply metis
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1043	done
8 a605dda64267 started a few arguments for the ALT case Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 7 diff changeset	1044
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1045	lemma mkeps_POSIX:
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1046	assumes "nullable r"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1047	shows "POSIX (mkeps r) r"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1048	using assms
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1049	apply(induct r)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1050	apply(auto)[1]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1051	apply(simp add: POSIX_def)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1052	apply(auto)[1]
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1053	apply (metis Prf.intros(4))
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1054	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1055	apply(simp_all)[5]
6 87618dae0e04 getting back the original version by Sulzmann Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 5 diff changeset	1056	apply (metis ValOrd.intros)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1057	apply(simp)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1058	apply(auto)[1]
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1059	apply(simp add: POSIX_def)
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1060	apply(auto)[1]
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1061	apply (metis mkeps.simps(2) mkeps_nullable nullable.simps(5))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1062	apply(rotate_tac 6)
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1063	apply(erule Prf.cases)
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1064	apply(simp_all)[5]
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1065	apply (simp add: mkeps_flat)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1066	apply(case_tac "mkeps r1a = v1")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1067	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1068	apply (metis ValOrd.intros(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1069	apply (rule ValOrd.intros(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1070	apply metis
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1071	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1072	(* ALT case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1073	thm mkeps.simps
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1074	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1075	apply(erule disjE)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1076	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1077	apply (metis POSIX_ALT_I1)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1078	(* *)
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1079	apply(auto)[1]
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1080	thm POSIX_ALT_I1
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1081	apply (metis POSIX_ALT_I1)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1082	apply(simp (no_asm) add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1083	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1084	apply(rule Prf.intros(3))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1085	apply(simp only: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1086	apply(rotate_tac 4)
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1087	apply(erule Prf.cases)
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1088	apply(simp_all)[5]
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1089	thm mkeps_flat
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1090	apply(simp add: mkeps_flat)
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1091	apply(auto)[1]
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1092	thm Prf_flat_L nullable_correctness
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1093	apply (metis Prf_flat_L nullable_correctness)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1094	apply(rule ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1095	apply(subst (asm) POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1096	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1097	apply(drule_tac x="v2" in spec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1098	by simp
6 87618dae0e04 getting back the original version by Sulzmann Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 5 diff changeset	1099
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1100
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1101
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1102	text {*
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1103	Injection value is related to r
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1104	*}
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1105
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1106
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1107
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1108	text {*
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1109	The string behind the injection value is an added c
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1110	*}
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1111
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1112
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1113	lemma injval_inj: "inj_on (injval r c) {v. \<turnstile> v : der c r}"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1114	apply(induct c r rule: der.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1115	unfolding inj_on_def
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1116	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1117	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1118	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1119	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1120	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1121	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1122	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1123	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1124	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1125	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1126	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1127	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1128	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1129	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1130	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1131	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1132	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1133	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1134	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1135	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1136	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1137	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1138	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1139	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1140	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1141	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1142	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1143	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1144	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1145	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1146	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1147	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1148	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1149	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1150	apply (metis list.distinct(1) mkeps_flat v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1151	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1152	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1153	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1154	apply(rotate_tac 6)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1155	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1156	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1157	apply (metis list.distinct(1) mkeps_flat v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1158	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1159	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1160	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1161	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1162	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1163
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1164	lemma Values_nullable:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1165	assumes "nullable r1"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1166	shows "mkeps r1 \<in> Values r1 s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1167	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1168	apply(induct r1 arbitrary: s)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1169	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1170	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1171	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1172	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1173	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1174	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1175
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1176	lemma Values_injval:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1177	assumes "v \<in> Values (der c r) s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1178	shows "injval r c v \<in> Values r (c#s)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1179	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1180	apply(induct c r arbitrary: v s rule: der.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1181	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1182	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1183	apply(case_tac "c = c'")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1184	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1185	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1186	apply(simp add: prefix_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1187	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1188	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1189	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1190	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1191	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1192	apply(case_tac "nullable r1")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1193	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1194	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1195	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1196	apply(simp add: rest_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1197	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1198	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1199	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1200	apply(rule Values_nullable)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1201	apply(assumption)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1202	apply(simp add: rest_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1203	apply(subst mkeps_flat)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1204	apply(assumption)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1205	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1206	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1207	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1208	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1209	apply(simp add: rest_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1210	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1211	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1212	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1213	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1214
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1215	lemma Values_projval:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1216	assumes "v \<in> Values r (c#s)" "\<exists>s. flat v = c # s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1217	shows "projval r c v \<in> Values (der c r) s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1218	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1219	apply(induct r arbitrary: v s c rule: rexp.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1220	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1221	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1222	apply(case_tac "c = char")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1223	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1224	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1225	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1226	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1227	apply(simp add: prefix_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1228	apply(case_tac "nullable rexp1")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1229	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1230	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1231	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1232	apply(simp add: rest_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1233	apply (metis hd_Cons_tl hd_append2 list.sel(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1234	apply(simp add: rest_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1235	apply(simp add: append_eq_Cons_conv)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1236	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1237	apply(subst v4_proj2)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1238	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1239	apply(assumption)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1240	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1241	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1242	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1243	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1244	apply(auto simp add: Values_def not_nullable_flat)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1245	apply(simp add: append_eq_Cons_conv)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1246	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1247	apply(simp add: append_eq_Cons_conv)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1248	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1249	apply(simp add: rest_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1250	apply(subst v4_proj2)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1251	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1252	apply(assumption)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1253	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1254	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1255	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1256	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1257
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1258
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1259	definition "MValue v r s \<equiv> (v \<in> Values r s \<and> (\<forall>v' \<in> Values r s. v 2\<succ> v'))"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1260
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1261	lemma MValue_ALTE:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1262	assumes "MValue v (ALT r1 r2) s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1263	shows "(\<exists>vl. v = Left vl \<and> MValue vl r1 s \<and> (\<forall>vr \<in> Values r2 s. length (flat vr) \<le> length (flat vl))) \<or>
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1264	(\<exists>vr. v = Right vr \<and> MValue vr r2 s \<and> (\<forall>vl \<in> Values r1 s. length (flat vl) < length (flat vr)))"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1265	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1266	apply(simp add: MValue_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1267	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1268	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1269	apply(drule_tac x="Left x" in bspec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1270	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1271	apply(erule ValOrd2.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1272	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1273	apply(drule_tac x="Right vr" in bspec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1274	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1275	apply(erule ValOrd2.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1276	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1277	apply(drule_tac x="Right x" in bspec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1278	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1279	apply(erule ValOrd2.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1280	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1281	apply(drule_tac x="Left vl" in bspec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1282	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1283	apply(erule ValOrd2.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1284	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1285	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1286
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1287	lemma MValue_ALTI1:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1288	assumes "MValue vl r1 s" "\<forall>vr \<in> Values r2 s. length (flat vr) \<le> length (flat vl)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1289	shows "MValue (Left vl) (ALT r1 r2) s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1290	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1291	apply(simp add: MValue_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1292	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1293	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1294	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1295	apply metis
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1296	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1297	apply metis
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1298	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1299
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1300	lemma MValue_ALTI2:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1301	assumes "MValue vr r2 s" "\<forall>vl \<in> Values r1 s. length (flat vl) < length (flat vr)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1302	shows "MValue (Right vr) (ALT r1 r2) s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1303	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1304	apply(simp add: MValue_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1305	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1306	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1307	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1308	apply metis
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1309	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1310	apply metis
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1311	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1312
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1313	lemma t: "(c#xs = c#ys) \<Longrightarrow> xs = ys"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1314	by (metis list.sel(3))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1315
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1316	lemma t2: "(xs = ys) \<Longrightarrow> (c#xs) = (c#ys)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1317	by (metis)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1318
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1319	lemma "\<not>(nullable r) \<Longrightarrow> \<not>(\<exists>v. \<turnstile> v : r \<and> flat v = [])"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1320	by (metis Prf_flat_L nullable_correctness)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1321
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1322
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1323	lemma LeftRight:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1324	assumes "(Left v1) \<succ>(der c (ALT r1 r2)) (Right v2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1325	and "\<turnstile> v1 : der c r1" "\<turnstile> v2 : der c r2"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1326	shows "(injval (ALT r1 r2) c (Left v1)) \<succ>(ALT r1 r2) (injval (ALT r1 r2) c (Right v2))"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1327	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1328	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1329	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1330	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1331	apply(rule ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1332	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1333	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1334	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1335	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1336	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1337	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1338	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1339
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1340	lemma RightLeft:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1341	assumes "(Right v1) \<succ>(der c (ALT r1 r2)) (Left v2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1342	and "\<turnstile> v1 : der c r2" "\<turnstile> v2 : der c r1"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1343	shows "(injval (ALT r1 r2) c (Right v1)) \<succ>(ALT r1 r2) (injval (ALT r1 r2) c (Left v2))"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1344	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1345	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1346	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1347	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1348	apply(rule ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1349	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1350	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1351	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1352	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1353	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1354	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1355	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1356
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1357	lemma h:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1358	assumes "nullable r1" "\<turnstile> v1 : der c r1"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1359	shows "injval r1 c v1 \<succ>r1 mkeps r1"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1360	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1361	apply(induct r1 arbitrary: v1 rule: der.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1362	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1363	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1364	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1365	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1366	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1367	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1368	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1369	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1370	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1371	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1372	apply (metis ValOrd.intros(6))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1373	apply (metis ValOrd.intros(6))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1374	apply (metis ValOrd.intros(3) le_add2 list.size(3) mkeps_flat monoid_add_class.add.right_neutral)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1375	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1376	apply (metis ValOrd.intros(4) length_greater_0_conv list.distinct(1) list.size(3) mkeps_flat v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1377	apply (metis ValOrd.intros(4) length_greater_0_conv list.distinct(1) list.size(3) mkeps_flat v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1378	apply (metis ValOrd.intros(5))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1379	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1380	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1381	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1382	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1383	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1384	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1385	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1386	apply (metis ValOrd.intros(2) list.distinct(1) mkeps_flat v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1387	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1388	by (metis ValOrd.intros(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1389
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1390	lemma LeftRightSeq:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1391	assumes "(Left (Seq v1 v2)) \<succ>(der c (SEQ r1 r2)) (Right v3)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1392	and "nullable r1" "\<turnstile> v1 : der c r1"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1393	shows "(injval (SEQ r1 r2) c (Seq v1 v2)) \<succ>(SEQ r1 r2) (injval (SEQ r1 r2) c (Right v2))"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1394	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1395	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1396	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1397	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1398	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1399	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1400	apply(rule ValOrd.intros(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1401	prefer 2
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1402	apply (metis list.distinct(1) mkeps_flat v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1403	by (metis h)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1404
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1405	lemma rr1:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1406	assumes "\<turnstile> v : r" "\<not>nullable r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1407	shows "flat v \<noteq> []"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1408	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1409	by (metis Prf_flat_L nullable_correctness)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1410
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1411	(* HERE *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1412
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1413	lemma Prf_inj_test:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1414	assumes "v1 \<succ>(der c r) v2"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1415	"v1 \<in> Values (der c r) s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1416	"v2 \<in> Values (der c r) s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1417	"injval r c v1 \<in> Values r (c#s)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1418	"injval r c v2 \<in> Values r (c#s)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1419	shows "(injval r c v1) 2\<succ> (injval r c v2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1420	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1421	apply(induct c r arbitrary: v1 v2 s rule: der.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1422	(* NULL case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1423	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1424	(* EMPTY case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1425	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1426	(* CHAR case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1427	apply(case_tac "c = c'")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1428	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1429	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1430	apply (metis ValOrd2.intros(8))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1431	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1432	(* ALT case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1433	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1434	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1435	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1436	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1437	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1438	apply (metis ValOrd2.intros(6))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1439	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1440	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1441	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1442	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1443	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1444	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1445	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1446	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1447	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1448	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1449	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1450	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1451	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1452	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1453	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1454	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1455	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1456	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1457	apply (metis ValOrd2.intros(5))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1458	(* SEQ case*)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1459	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1460	apply(case_tac "nullable r1")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1461	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1462	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1463	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1464	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1465	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1466	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1467	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1468	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1469	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1470	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1471	apply (metis Ord1)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1472	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1473	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1474	apply(subgoal_tac "rest v1 (flat v1 @ flat v2) = flat v2")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1475	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1476	apply(subgoal_tac "rest (injval r1 c v1) (c # flat v1 @ flat v2) = flat v2")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1477	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1478	oops
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1479
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1480	lemma Prf_inj_test:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1481	assumes "v1 \<succ>(der c r) v2"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1482	"v1 \<in> Values (der c r) s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1483	"v2 \<in> Values (der c r) s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1484	"injval r c v1 \<in> Values r (c#s)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1485	"injval r c v2 \<in> Values r (c#s)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1486	shows "(injval r c v1) 2\<succ> (injval r c v2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1487	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1488	apply(induct c r arbitrary: v1 v2 s rule: der.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1489	(* NULL case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1490	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1491	(* EMPTY case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1492	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1493	(* CHAR case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1494	apply(case_tac "c = c'")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1495	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1496	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1497	apply (metis ValOrd2.intros(8))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1498	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1499	(* ALT case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1500	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1501	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1502	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1503	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1504	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1505	apply (metis ValOrd2.intros(6))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1506	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1507	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1508	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1509	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1510	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1511	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1512	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1513	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1514	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1515	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1516	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1517	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1518	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1519	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1520	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1521	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1522	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1523	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1524	apply (metis ValOrd2.intros(5))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1525	(* SEQ case*)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1526	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1527	apply(case_tac "nullable r1")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1528	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1529	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1530	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1531	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1532	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1533	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1534	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1535	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1536	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1537	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1538	apply (metis Ord1)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1539	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1540	apply(rule ValOrd2.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1541	apply metis
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1542	using injval_inj
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1543	apply(simp add: Values_def inj_on_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1544	apply metis
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1545	apply(simp add: Values_recs)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1546	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1547	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1548	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1549	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1550	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1551	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1552	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1553	apply (metis Ord1 ValOrd2.intros(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1554	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1555	apply(rule ValOrd2.intros(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1556	apply metis
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1557	using injval_inj
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1558	apply(simp add: Values_def inj_on_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1559	apply metis
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1560	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1561	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1562	apply(rule ValOrd2.intros(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1563	thm h
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1564	apply(rule Ord1)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1565	apply(rule h)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1566	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1567	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1568	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1569	apply (metis list.distinct(1) mkeps_flat v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1570	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1571	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1572	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1573	apply(simp add: Values_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1574	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1575	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1576	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1577	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1578	apply(rule ValOrd2.intros(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1579	apply(rotate_tac 1)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1580	apply(drule_tac x="v2" in meta_spec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1581	apply(rotate_tac 8)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1582	apply(drule_tac x="v2'" in meta_spec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1583	apply(rotate_tac 8)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1584	oops
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1585
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1586	lemma POSIX_der:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1587	assumes "POSIX v (der c r)" "\<turnstile> v : der c r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1588	shows "POSIX (injval r c v) r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1589	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1590	unfolding POSIX_def
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1591	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1592	thm v3
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1593	apply (erule v3)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1594	thm v4
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1595	apply(subst (asm) v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1596	apply(assumption)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1597	apply(drule_tac x="projval r c v'" in spec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1598	apply(drule mp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1599	apply(rule conjI)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1600	thm v3_proj
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1601	apply(rule v3_proj)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1602	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1603	apply(rule_tac x="flat v" in exI)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1604	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1605	thm t
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1606	apply(rule_tac c="c" in t)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1607	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1608	thm v4_proj
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1609	apply(subst v4_proj)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1610	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1611	apply(rule_tac x="flat v" in exI)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1612	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1613	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1614	oops
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1615
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1616	lemma POSIX_der:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1617	assumes "POSIX v (der c r)" "\<turnstile> v : der c r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1618	shows "POSIX (injval r c v) r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1619	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1620	apply(induct c r arbitrary: v rule: der.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1621	(* null case*)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1622	apply(simp add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1623	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1624	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1625	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1626	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1627	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1628	(* empty case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1629	apply(simp add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1630	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1631	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1632	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1633	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1634	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1635	(* char case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1636	apply(simp add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1637	apply(case_tac "c = c'")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1638	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1639	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1640	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1641	apply (metis Prf.intros(5))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1642	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1643	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1644	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1645	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1646	apply (metis ValOrd.intros(8))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1647	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1648	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1649	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1650	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1651	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1652	(* alt case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1653	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1654	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1655	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1656	apply(simp (no_asm) add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1657	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1658	apply (metis Prf.intros(2) v3)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1659	apply(rotate_tac 4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1660	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1661	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1662	apply (metis POSIX_ALT2 POSIX_def ValOrd.intros(6))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1663	apply (metis ValOrd.intros(3) order_refl)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1664	apply(simp (no_asm) add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1665	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1666	apply (metis Prf.intros(3) v3)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1667	apply(rotate_tac 4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1668	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1669	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1670	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1671	apply (metis POSIX_ALT1a POSIX_def ValOrd.intros(5))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1672	prefer 2
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1673	apply(subst (asm) (5) POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1674	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1675	apply(rotate_tac 5)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1676	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1677	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1678	apply(rule ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1679	apply(subst (asm) v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1680	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1681	apply(drule_tac x="Left (projval r1a c v1)" in spec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1682	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1683	apply(drule mp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1684	apply(rule conjI)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1685	apply (metis Prf.intros(2) v3_proj)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1686	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1687	apply (metis v4_proj2)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1688	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1689	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1690	apply (metis less_not_refl v4_proj2)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1691	(* seq case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1692	apply(case_tac "nullable r1")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1693	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1694	apply(simp add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1695	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1696	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1697	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1698	apply (metis Prf.intros(1) v3)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1699	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1700	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1701	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1702	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1703	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1704	apply(subst (asm) (3) v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1705	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1706	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1707	apply(subgoal_tac "flat v1a \<noteq> []")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1708	prefer 2
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1709	apply (metis Prf_flat_L nullable_correctness)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1710	apply(subgoal_tac "\<exists>s. flat v1a = c # s")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1711	prefer 2
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1712	apply (metis append_eq_Cons_conv)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1713	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1714	oops
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1715
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1716
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1717	lemma POSIX_ex: "\<turnstile> v : r \<Longrightarrow> \<exists>v. POSIX v r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1718	apply(induct r arbitrary: v)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1719	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1720	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1721	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1722	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1723	apply(rule_tac x="Void" in exI)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1724	apply(simp add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1725	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1726	apply (metis Prf.intros(4))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1727	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1728	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1729	apply (metis ValOrd.intros(7))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1730	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1731	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1732	apply(rule_tac x="Char c" in exI)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1733	apply(simp add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1734	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1735	apply (metis Prf.intros(5))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1736	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1737	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1738	apply (metis ValOrd.intros(8))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1739	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1740	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1741	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1742	apply(drule_tac x="v1" in meta_spec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1743	apply(drule_tac x="v2" in meta_spec)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1744	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1745	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1746	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1747	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1748	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1749	apply (metis POSIX_ALT_I1)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1750	apply (metis POSIX_ALT_I1 POSIX_ALT_I2)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1751	apply(case_tac "nullable r1a")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1752	apply(rule_tac x="Seq (mkeps r1a) va" in exI)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1753	apply(auto simp add: POSIX_def)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1754	apply (metis Prf.intros(1) mkeps_nullable)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1755	apply(simp add: mkeps_flat)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1756	apply(rotate_tac 7)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1757	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1758	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1759	apply(case_tac "mkeps r1 = v1a")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1760	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1761	apply (rule ValOrd.intros(1))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1762	apply (metis append_Nil mkeps_flat)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1763	apply (rule ValOrd.intros(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1764	apply(drule mkeps_POSIX)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1765	apply(simp add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1766	oops
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1767
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1768	lemma POSIX_ex2: "\<turnstile> v : r \<Longrightarrow> \<exists>v. POSIX v r \<and> \<turnstile> v : r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1769	apply(induct r arbitrary: v)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1770	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1771	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1772	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1773	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1774	apply(rule_tac x="Void" in exI)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1775	apply(simp add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1776	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1777	oops
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1778
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1779	lemma POSIX_ALT_cases:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1780	assumes "\<turnstile> v : (ALT r1 r2)" "POSIX v (ALT r1 r2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1781	shows "(\<exists>v1. v = Left v1 \<and> POSIX v1 r1) \<or> (\<exists>v2. v = Right v2 \<and> POSIX v2 r2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1782	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1783	apply(erule_tac Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1784	apply(simp_all)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1785	unfolding POSIX_def
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1786	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1787	apply (metis POSIX_ALT2 POSIX_def assms(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1788	by (metis POSIX_ALT1b assms(2))
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1789
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1790	lemma POSIX_ALT_cases2:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1791	assumes "POSIX v (ALT r1 r2)" "\<turnstile> v : (ALT r1 r2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1792	shows "(\<exists>v1. v = Left v1 \<and> POSIX v1 r1) \<or> (\<exists>v2. v = Right v2 \<and> POSIX v2 r2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1793	using assms POSIX_ALT_cases by auto
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1794
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1795	lemma Prf_flat_empty:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1796	assumes "\<turnstile> v : r" "flat v = []"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1797	shows "nullable r"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1798	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1799	apply(induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1800	apply(auto)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1801	done
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1802
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1803	lemma POSIX_proj:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1804	assumes "POSIX v r" "\<turnstile> v : r" "\<exists>s. flat v = c#s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1805	shows "POSIX (projval r c v) (der c r)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1806	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1807	apply(induct r c v arbitrary: rule: projval.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1808	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1809	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1810	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1811	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1812	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1813	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1814	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1815	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1816	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1817	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1818	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1819	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1820	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1821	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1822	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1823	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1824	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1825	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1826	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1827	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1828	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1829	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1830	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1831	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1832	apply(simp add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1833	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1834	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1835	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1836	oops
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1837
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1838	lemma POSIX_proj:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1839	assumes "POSIX v r" "\<turnstile> v : r" "\<exists>s. flat v = c#s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1840	shows "POSIX (projval r c v) (der c r)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1841	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1842	apply(induct r arbitrary: c v rule: rexp.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1843	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1844	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1845	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1846	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1847	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1848	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1849	apply(simp add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1850	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1851	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1852	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1853	oops
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1854
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1855	lemma POSIX_proj:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1856	assumes "POSIX v r" "\<turnstile> v : r" "\<exists>s. flat v = c#s"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1857	shows "POSIX (projval r c v) (der c r)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1858	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1859	apply(induct r c v arbitrary: rule: projval.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1860	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1861	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1862	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1863	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1864	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1865	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1866	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1867	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1868	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1869	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1870	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1871	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1872	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1873	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1874	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1875	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1876	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1877	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1878	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1879	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1880	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1881	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1882	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1883	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1884	apply(simp add: POSIX_def)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1885	apply(auto)[1]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1886	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1887	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1888	oops
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1889
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1890	lemma Prf_inj:
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1891	assumes "v1 \<succ>(der c r) v2" "\<turnstile> v1 : der c r" "\<turnstile> v2 : der c r" "flat v1 = flat v2"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1892	shows "(injval r c v1) \<succ>r (injval r c v2)"
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1893	using assms
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1894	apply(induct arbitrary: v1 v2 rule: der.induct)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1895	(* NULL case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1896	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1897	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1898	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1899	(* EMPTY case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1900	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1901	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1902	(* CHAR case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1903	apply(case_tac "c = c'")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1904	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1905	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1906	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1907	apply(rule ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1908	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1909	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1910	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1911	(* ALT case *)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1912	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1913	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1914	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1915	apply(rule ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1916	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1917	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1918	apply(rotate_tac 3)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1919	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1920	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1921	apply(subst v4)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1922	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1923	apply(rotate_tac 2)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1924	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1925	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1926	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1927	apply(rule ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1928	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1929	apply(rotate_tac 3)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1930	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1931	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1932	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1933	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1934	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1935	apply(rule ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1936	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1937	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1938	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1939	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1940	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1941	(* SEQ case*)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1942	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1943	apply(case_tac "nullable r1")
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1944	defer
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1945	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1946	apply(erule ValOrd.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1947	apply(simp_all)[8]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1948	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1949	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1950	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1951	apply(erule Prf.cases)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1952	apply(simp_all)[5]
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1953	apply(clarify)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1954	apply(rule ValOrd.intros)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1955	apply(simp)
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1956	oops
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1957
26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	1958
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1959	text {*
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1960	Injection followed by projection is the identity.
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	1961	*}
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1962
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1963	lemma proj_inj_id:
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1964	assumes "\<turnstile> v : der c r"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1965	shows "projval r c (injval r c v) = v"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1966	using assms
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1967	apply(induct r arbitrary: c v rule: rexp.induct)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1968	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1969	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1970	apply(simp_all)[5]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1971	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1972	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1973	apply(simp_all)[5]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1974	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1975	apply(case_tac "c = char")
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1976	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1977	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1978	apply(simp_all)[5]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1979	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1980	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1981	apply(simp_all)[5]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1982	defer
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1983	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1984	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1985	apply(simp_all)[5]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1986	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1987	apply(case_tac "nullable rexp1")
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1988	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1989	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1990	apply(simp_all)[5]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1991	apply(auto)[1]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1992	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1993	apply(simp_all)[5]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1994	apply(auto)[1]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1995	apply (metis list.distinct(1) v4)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1996	apply(auto)[1]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1997	apply (metis mkeps_flat)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1998	apply(auto)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	1999	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2000	apply(simp_all)[5]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2001	apply(auto)[1]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2002	apply(simp add: v4)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2003	done
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2004
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	2005	text {*
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2006
7 b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	2007	HERE: Crucial lemma that does not go through in the sequence case.
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	2008
b409ecf47f64 cleaned up the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 6 diff changeset	2009	*}
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2010	lemma v5:
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2011	assumes "\<turnstile> v : der c r" "POSIX v (der c r)"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2012	shows "POSIX (injval r c v) r"
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2013	using assms
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2014	apply(induct arbitrary: v rule: der.induct)
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	2015	(* NULL case *)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2016	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2017	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2018	apply(simp_all)[5]
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	2019	(* EMPTY case *)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2020	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2021	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2022	apply(simp_all)[5]
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	2023	(* CHAR case *)
5 fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2024	apply(simp)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2025	apply(case_tac "c = c'")
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2026	apply(auto simp add: POSIX_def)[1]
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2027	apply(erule Prf.cases)
fe177dfc4697 initial version of the theory Christian Urban <christian dot urban at kcl dot ac dot uk> parents: diff changeset	2028	apply(simp_all)[5]
82 26202889f829 cleaned up version of Re1 Christian Urban <christian dot urban at kcl dot ac dot uk> parents: 10 diff changeset	2029	oops

author	Christian Urban <christian dot urban at kcl dot ac dot uk>
	Fri, 18 Dec 2015 00:37:35 +0000
changeset 83	a8bcb5a0f9b9
parent 82	26202889f829
child 84	f89372781a4c
permissions	-rw-r--r--