theory ReStar imports "Main" beginsection {* Sequential Composition of Languages *}definition Sequ :: "string set \<Rightarrow> string set \<Rightarrow> string set" ("_ ;; _" [100,100] 100)where "A ;; B = {s1 @ s2 | s1 s2. s1 \<in> A \<and> s2 \<in> B}"text {* Two Simple Properties about Sequential Composition *}lemma seq_empty [simp]: shows "A ;; {[]} = A" and "{[]} ;; A = A"by (simp_all add: Sequ_def)lemma seq_null [simp]: shows "A ;; {} = {}" and "{} ;; A = {}"by (simp_all add: Sequ_def)section {* Semantic Derivative of Languages *}definition Der :: "char \<Rightarrow> string set \<Rightarrow> string set"where "Der c A \<equiv> {s. c # s \<in> A}"lemma Der_null [simp]: shows "Der c {} = {}"unfolding Der_defby autolemma Der_empty [simp]: shows "Der c {[]} = {}"unfolding Der_defby autolemma Der_char [simp]: shows "Der c {[d]} = (if c = d then {[]} else {})"unfolding Der_defby autolemma Der_union [simp]: shows "Der c (A \<union> B) = Der c A \<union> Der c B"unfolding Der_defby autolemma Der_Sequ [simp]: shows "Der c (A ;; B) = (Der c A) ;; B \<union> (if [] \<in> A then Der c B else {})"unfolding Der_def Sequ_defby (auto simp add: Cons_eq_append_conv)section {* Kleene Star for Languages *}inductive_set Star :: "string set \<Rightarrow> string set" ("_\<star>" [101] 102) for A :: "string set"where start[intro]: "[] \<in> A\<star>"| step[intro]: "\<lbrakk>s1 \<in> A; s2 \<in> A\<star>\<rbrakk> \<Longrightarrow> s1 @ s2 \<in> A\<star>"lemma star_cases: shows "A\<star> = {[]} \<union> A ;; A\<star>"unfolding Sequ_defby (auto) (metis Star.simps)lemma star_decomp: assumes a: "c # x \<in> A\<star>" shows "\<exists>a b. x = a @ b \<and> c # a \<in> A \<and> b \<in> A\<star>"using aby (induct x\<equiv>"c # x" rule: Star.induct) (auto simp add: append_eq_Cons_conv)lemma Der_star [simp]: shows "Der c (A\<star>) = (Der c A) ;; A\<star>"proof - have "Der c (A\<star>) = Der c ({[]} \<union> A ;; A\<star>)" by (simp only: star_cases[symmetric]) also have "... = Der c (A ;; A\<star>)" by (simp only: Der_union Der_empty) (simp) also have "... = (Der c A) ;; A\<star> \<union> (if [] \<in> A then Der c (A\<star>) else {})" by simp also have "... = (Der c A) ;; A\<star>" unfolding Sequ_def Der_def by (auto dest: star_decomp) finally show "Der c (A\<star>) = (Der c A) ;; A\<star>" .qedsection {* Regular Expressions *}datatype rexp = ZERO| ONE| CHAR char| SEQ rexp rexp| ALT rexp rexp| STAR rexpsection {* Semantics of Regular Expressions *}fun L :: "rexp \<Rightarrow> string set"where "L (ZERO) = {}"| "L (ONE) = {[]}"| "L (CHAR c) = {[c]}"| "L (SEQ r1 r2) = (L r1) ;; (L r2)"| "L (ALT r1 r2) = (L r1) \<union> (L r2)"| "L (STAR r) = (L r)\<star>"section {* Nullable, Derivatives *}fun nullable :: "rexp \<Rightarrow> bool"where "nullable (ZERO) = False"| "nullable (ONE) = True"| "nullable (CHAR c) = False"| "nullable (ALT r1 r2) = (nullable r1 \<or> nullable r2)"| "nullable (SEQ r1 r2) = (nullable r1 \<and> nullable r2)"| "nullable (STAR r) = True"fun der :: "char \<Rightarrow> rexp \<Rightarrow> rexp"where "der c (ZERO) = ZERO"| "der c (ONE) = ZERO"| "der c (CHAR d) = (if c = d then ONE else ZERO)"| "der c (ALT r1 r2) = ALT (der c r1) (der c r2)"| "der c (SEQ r1 r2) = (if nullable r1 then ALT (SEQ (der c r1) r2) (der c r2) else SEQ (der c r1) r2)"| "der c (STAR r) = SEQ (der c r) (STAR r)"fun ders :: "string \<Rightarrow> rexp \<Rightarrow> rexp"where "ders [] r = r"| "ders (c # s) r = ders s (der c r)"lemma nullable_correctness: shows "nullable r \<longleftrightarrow> [] \<in> (L r)"by (induct r) (auto simp add: Sequ_def) lemma der_correctness: shows "L (der c r) = Der c (L r)"apply(induct r) apply(simp_all add: nullable_correctness)donesection {* Values *}datatype val = Void| Char char| Seq val val| Right val| Left val| Stars "val list"datatype_compat valsection {* The string behind a value *}fun flat :: "val \<Rightarrow> string"where "flat (Void) = []"| "flat (Char c) = [c]"| "flat (Left v) = flat v"| "flat (Right v) = flat v"| "flat (Seq v1 v2) = (flat v1) @ (flat v2)"| "flat (Stars []) = []"| "flat (Stars (v#vs)) = (flat v) @ (flat (Stars vs))" lemma flat_Stars [simp]: "flat (Stars vs) = concat (map flat vs)"by (induct vs) (auto)section {* Relation between values and regular expressions *}inductive Prf :: "val \<Rightarrow> rexp \<Rightarrow> bool" ("\<turnstile> _ : _" [100, 100] 100)where "\<lbrakk>\<turnstile> v1 : r1; \<turnstile> v2 : r2\<rbrakk> \<Longrightarrow> \<turnstile> Seq v1 v2 : SEQ r1 r2"| "\<turnstile> v1 : r1 \<Longrightarrow> \<turnstile> Left v1 : ALT r1 r2"| "\<turnstile> v2 : r2 \<Longrightarrow> \<turnstile> Right v2 : ALT r1 r2"| "\<turnstile> Void : ONE"| "\<turnstile> Char c : CHAR c"| "\<turnstile> Stars [] : STAR r"| "\<lbrakk>\<turnstile> v : r; \<turnstile> Stars vs : STAR r\<rbrakk> \<Longrightarrow> \<turnstile> Stars (v # vs) : STAR r"lemma not_nullable_flat: assumes "\<turnstile> v : r" "\<not> nullable r" shows "flat v \<noteq> []"using assmsby (induct) (auto)lemma Prf_flat_L: assumes "\<turnstile> v : r" shows "flat v \<in> L r"using assmsapply(induct v r rule: Prf.induct)apply(auto simp add: Sequ_def)donelemma Prf_Stars: assumes "\<forall>v \<in> set vs. \<turnstile> v : r" shows "\<turnstile> Stars vs : STAR r"using assmsapply(induct vs)apply (metis Prf.intros(6))by (metis Prf.intros(7) insert_iff set_simps(2))lemma Star_string: assumes "s \<in> A\<star>" shows "\<exists>ss. concat ss = s \<and> (\<forall>s \<in> set ss. s \<in> A)"using assmsapply(induct rule: Star.induct)apply(auto)apply(rule_tac x="[]" in exI)apply(simp)apply(rule_tac x="s1#ss" in exI)apply(simp)donelemma Star_val: assumes "\<forall>s\<in>set ss. \<exists>v. s = flat v \<and> \<turnstile> v : r" shows "\<exists>vs. concat (map flat vs) = concat ss \<and> (\<forall>v\<in>set vs. \<turnstile> v : r)"using assmsapply(induct ss)apply(auto)apply (metis empty_iff list.set(1))by (metis concat.simps(2) list.simps(9) set_ConsD)lemma L_flat_Prf: "L(r) = {flat v | v. \<turnstile> v : r}"apply(induct r)apply(auto dest: Prf_flat_L simp add: Sequ_def)apply (metis Prf.intros(4) flat.simps(1))apply (metis Prf.intros(5) flat.simps(2))apply (metis Prf.intros(1) flat.simps(5))apply (metis Prf.intros(2) flat.simps(3))apply (metis Prf.intros(3) flat.simps(4))apply(erule Prf.cases)apply(auto)apply(subgoal_tac "\<exists>vs::val list. concat (map flat vs) = x \<and> (\<forall>v \<in> set vs. \<turnstile> v : r)")apply(auto)[1]apply(rule_tac x="Stars vs" in exI)apply(simp)apply(rule Prf_Stars)apply(simp)apply(drule Star_string)apply(auto)apply(rule Star_val)apply(simp)donesection {* Sulzmann functions *}fun mkeps :: "rexp \<Rightarrow> val"where "mkeps(ONE) = Void"| "mkeps(SEQ r1 r2) = Seq (mkeps r1) (mkeps r2)"| "mkeps(ALT r1 r2) = (if nullable(r1) then Left (mkeps r1) else Right (mkeps r2))"| "mkeps(STAR r) = Stars []"fun injval :: "rexp \<Rightarrow> char \<Rightarrow> val \<Rightarrow> val"where "injval (CHAR d) c Void = Char d"| "injval (ALT r1 r2) c (Left v1) = Left(injval r1 c v1)"| "injval (ALT r1 r2) c (Right v2) = Right(injval r2 c v2)"| "injval (SEQ r1 r2) c (Seq v1 v2) = Seq (injval r1 c v1) v2"| "injval (SEQ r1 r2) c (Left (Seq v1 v2)) = Seq (injval r1 c v1) v2"| "injval (SEQ r1 r2) c (Right v2) = Seq (mkeps r1) (injval r2 c v2)"| "injval (STAR r) c (Seq v (Stars vs)) = Stars ((injval r c v) # vs)" section {* Matcher *}fun matcher :: "rexp \<Rightarrow> string \<Rightarrow> val option"where "matcher r [] = (if nullable r then Some(mkeps r) else None)"| "matcher r (c#s) = (case (matcher (der c r) s) of None \<Rightarrow> None | Some(v) \<Rightarrow> Some(injval r c v))"fun matcher2 :: "rexp \<Rightarrow> string \<Rightarrow> val"where "matcher2 r [] = mkeps r"| "matcher2 r (c#s) = injval r c (matcher2 (der c r) s)"section {* Mkeps, injval *}lemma mkeps_nullable: assumes "nullable(r)" shows "\<turnstile> mkeps r : r"using assmsapply(induct rule: nullable.induct)apply(auto intro: Prf.intros)donelemma mkeps_flat: assumes "nullable(r)" shows "flat (mkeps r) = []"using assmsapply(induct rule: nullable.induct)apply(auto)donelemma Prf_injval: assumes "\<turnstile> v : der c r" shows "\<turnstile> (injval r c v) : r"using assmsapply(induct r arbitrary: c v rule: rexp.induct)apply(simp_all)(* ZERO *)apply(erule Prf.cases)apply(simp_all)[7](* ONE *)apply(erule Prf.cases)apply(simp_all)[7](* CHAR *)apply(case_tac "c = x")apply(simp)apply(erule Prf.cases)apply(simp_all)[7]apply(rule Prf.intros(5))apply(simp)apply(erule Prf.cases)apply(simp_all)[7](* SEQ *)apply(case_tac "nullable x1")apply(simp)apply(erule Prf.cases)apply(simp_all)[7]apply(auto)[1]apply(erule Prf.cases)apply(simp_all)[7]apply(auto)[1]apply(rule Prf.intros)apply(auto)[2]apply (metis Prf.intros(1) mkeps_nullable)apply(simp)apply(erule Prf.cases)apply(simp_all)[7]apply(auto)[1]apply(rule Prf.intros)apply(auto)[2](* ALT *)apply(erule Prf.cases)apply(simp_all)[7]apply(clarify)apply (metis Prf.intros(2))apply (metis Prf.intros(3))(* STAR *)apply(erule Prf.cases)apply(simp_all)[7]apply(clarify)apply(rotate_tac 2)apply(erule Prf.cases)apply(simp_all)[7]apply(auto)apply (metis Prf.intros(6) Prf.intros(7))by (metis Prf.intros(7))lemma Prf_injval_flat: assumes "\<turnstile> v : der c r" shows "flat (injval r c v) = c # (flat v)"using assmsapply(induct arbitrary: v rule: der.induct)apply(simp)apply(erule Prf.cases)apply(simp_all)[7]apply(simp)apply(erule Prf.cases)apply(simp_all)[7]apply(simp)apply(case_tac "c = d")apply(simp)apply(auto)[1]apply(erule Prf.cases)apply(simp_all)[7]apply(simp)apply(erule Prf.cases)apply(simp_all)[7]apply(simp)apply(erule Prf.cases)apply(simp_all)[7]apply(simp)apply(case_tac "nullable r1")apply(simp)apply(erule Prf.cases)apply(simp_all (no_asm_use))[7]apply(auto)[1]apply(erule Prf.cases)apply(simp_all)[7]apply(clarify)apply(simp only: injval.simps flat.simps)apply(auto)[1]apply (metis mkeps_flat)apply(simp)apply(erule Prf.cases)apply(simp_all)[7]apply(simp)apply(erule Prf.cases)apply(simp_all)[7]apply(auto)apply(rotate_tac 2)apply(erule Prf.cases)apply(simp_all)[7]donesection {* Our Alternative Posix definition *}inductive PMatch :: "string \<Rightarrow> rexp \<Rightarrow> val \<Rightarrow> bool" ("_ \<in> _ \<rightarrow> _" [100, 100, 100] 100)where "[] \<in> ONE \<rightarrow> Void"| "[c] \<in> (CHAR c) \<rightarrow> (Char c)"| "s \<in> r1 \<rightarrow> v \<Longrightarrow> s \<in> (ALT r1 r2) \<rightarrow> (Left v)"| "\<lbrakk>s \<in> r2 \<rightarrow> v; s \<notin> L(r1)\<rbrakk> \<Longrightarrow> s \<in> (ALT r1 r2) \<rightarrow> (Right v)"| "\<lbrakk>s1 \<in> r1 \<rightarrow> v1; s2 \<in> r2 \<rightarrow> v2; \<not>(\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> (s1 @ s\<^sub>3) \<in> L r1 \<and> s\<^sub>4 \<in> L r2)\<rbrakk> \<Longrightarrow> (s1 @ s2) \<in> (SEQ r1 r2) \<rightarrow> (Seq v1 v2)"| "\<lbrakk>s1 \<in> r \<rightarrow> v; s2 \<in> STAR r \<rightarrow> Stars vs; flat v \<noteq> []; \<not>(\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> (s1 @ s\<^sub>3) \<in> L r \<and> s\<^sub>4 \<in> L (STAR r))\<rbrakk> \<Longrightarrow> (s1 @ s2) \<in> STAR r \<rightarrow> Stars (v # vs)"| "[] \<in> STAR r \<rightarrow> Stars []"lemma PMatch1: assumes "s \<in> r \<rightarrow> v" shows "s \<in> L r" "flat v = s"using assmsapply(induct s r v rule: PMatch.induct)apply(auto simp add: Sequ_def)donelemma PMatch1a: assumes "s \<in> r \<rightarrow> v" shows "\<turnstile> v : r"using assmsapply(induct s r v rule: PMatch.induct)apply(auto intro: Prf.intros)donelemma PMatch_mkeps: assumes "nullable r" shows "[] \<in> r \<rightarrow> mkeps r"using assmsapply(induct r)apply(auto intro: PMatch.intros simp add: nullable_correctness Sequ_def)apply(subst append.simps(1)[symmetric])apply (rule PMatch.intros)apply(auto)donelemma PMatch_determ: assumes "s \<in> r \<rightarrow> v1" "s \<in> r \<rightarrow> v2" shows "v1 = v2"using assmsapply(induct s r v1 arbitrary: v2 rule: PMatch.induct)apply(erule PMatch.cases)apply(simp_all)[7]apply(erule PMatch.cases)apply(simp_all)[7]apply(rotate_tac 2)apply(erule PMatch.cases)apply(simp_all (no_asm_use))[7]apply(clarify)apply(force)apply(clarify)apply(drule PMatch1(1))apply(simp)apply(rotate_tac 3)apply(erule PMatch.cases)apply(simp_all (no_asm_use))[7]apply(drule PMatch1(1))+apply(simp)apply(simp)apply(rotate_tac 5)apply(erule PMatch.cases)apply(simp_all (no_asm_use))[7]apply(clarify)apply(subgoal_tac "s1 = s1a")apply(blast)apply(simp add: append_eq_append_conv2)apply(clarify)apply (metis PMatch1(1) append_self_conv)apply(rotate_tac 6)apply(erule PMatch.cases)apply(simp_all (no_asm_use))[7]apply(clarify)apply(subgoal_tac "s1 = s1a")apply(simp)apply(blast)apply(simp (no_asm_use) add: append_eq_append_conv2)apply(clarify)apply (metis L.simps(6) PMatch1(1) append_self_conv)apply(clarify)apply(rotate_tac 2)apply(erule PMatch.cases)apply(simp_all (no_asm_use))[7]using PMatch1(2) apply auto[1]using PMatch1(2) apply blastapply(erule PMatch.cases)apply(simp_all (no_asm_use))[7]apply(clarify)apply (simp add: PMatch1(2))apply(simp)done(* a proof that does not need proj *)lemma PMatch2_roy_version: assumes "s \<in> (der c r) \<rightarrow> v" shows "(c#s) \<in> r \<rightarrow> (injval r c v)"using assmsproof(induct r arbitrary: s v rule: rexp.induct) case ZERO have "s \<in> der c ZERO \<rightarrow> v" by fact then have "s \<in> ZERO \<rightarrow> v" by simp then have "False" by cases then show "(c#s) \<in> ZERO \<rightarrow> (injval ZERO c v)" by simpnext case ONE have "s \<in> der c ONE \<rightarrow> v" by fact then have "s \<in> ZERO \<rightarrow> v" by simp then have "False" by cases then show "(c#s) \<in> ONE \<rightarrow> (injval ONE c v)" by simpnext case (CHAR d) consider (eq) "c = d" | (ineq) "c \<noteq> d" by blast then show "(c#s) \<in> (CHAR d) \<rightarrow> (injval (CHAR d) c v)" proof (cases) case eq have "s \<in> der c (CHAR d) \<rightarrow> v" by fact then have "s \<in> ONE \<rightarrow> v" using eq by simp then have eqs: "s = [] \<and> v = Void" by cases simp show "(c # s) \<in> CHAR d \<rightarrow> injval (CHAR d) c v" using eq eqs by (auto intro: PMatch.intros) next case ineq have "s \<in> der c (CHAR d) \<rightarrow> v" by fact then have "s \<in> ZERO \<rightarrow> v" using ineq by simp then have "False" by cases then show "(c # s) \<in> CHAR d \<rightarrow> injval (CHAR d) c v" by simp qednext case (ALT r1 r2) have IH1: "\<And>s v. s \<in> der c r1 \<rightarrow> v \<Longrightarrow> (c # s) \<in> r1 \<rightarrow> injval r1 c v" by fact have IH2: "\<And>s v. s \<in> der c r2 \<rightarrow> v \<Longrightarrow> (c # s) \<in> r2 \<rightarrow> injval r2 c v" by fact have "s \<in> der c (ALT r1 r2) \<rightarrow> v" by fact then have "s \<in> ALT (der c r1) (der c r2) \<rightarrow> v" by simp then consider (left) v' where "v = Left v'" "s \<in> der c r1 \<rightarrow> v'" | (right) v' where "v = Right v'" "s \<notin> L (der c r1)" "s \<in> der c r2 \<rightarrow> v'" by cases auto then show "(c # s) \<in> ALT r1 r2 \<rightarrow> injval (ALT r1 r2) c v" proof (cases) case left have "s \<in> der c r1 \<rightarrow> v'" by fact then have "(c # s) \<in> r1 \<rightarrow> injval r1 c v'" using IH1 by simp then have "(c # s) \<in> ALT r1 r2 \<rightarrow> injval (ALT r1 r2) c (Left v')" by (auto intro: PMatch.intros) then show "(c # s) \<in> ALT r1 r2 \<rightarrow> injval (ALT r1 r2) c v" using left by simp next case right have "s \<notin> L (der c r1)" by fact then have "c # s \<notin> L r1" by (simp add: der_correctness Der_def) moreover have "s \<in> der c r2 \<rightarrow> v'" by fact then have "(c # s) \<in> r2 \<rightarrow> injval r2 c v'" using IH2 by simp ultimately have "(c # s) \<in> ALT r1 r2 \<rightarrow> injval (ALT r1 r2) c (Right v')" by (auto intro: PMatch.intros) then show "(c # s) \<in> ALT r1 r2 \<rightarrow> injval (ALT r1 r2) c v" using right by simp qednext case (SEQ r1 r2) have IH1: "\<And>s v. s \<in> der c r1 \<rightarrow> v \<Longrightarrow> (c # s) \<in> r1 \<rightarrow> injval r1 c v" by fact have IH2: "\<And>s v. s \<in> der c r2 \<rightarrow> v \<Longrightarrow> (c # s) \<in> r2 \<rightarrow> injval r2 c v" by fact have "s \<in> der c (SEQ r1 r2) \<rightarrow> v" by fact then consider (left_nullable) v1 v2 s1 s2 where "v = Left (Seq v1 v2)" "s = s1 @ s2" "s1 \<in> der c r1 \<rightarrow> v1" "s2 \<in> r2 \<rightarrow> v2" "nullable r1" "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r1) \<and> s\<^sub>4 \<in> L r2)" | (right_nullable) v1 s1 s2 where "v = Right v1" "s = s1 @ s2" "s \<in> der c r2 \<rightarrow> v1" "nullable r1" "s1 @ s2 \<notin> L (SEQ (der c r1) r2)" | (not_nullable) v1 v2 s1 s2 where "v = Seq v1 v2" "s = s1 @ s2" "s1 \<in> der c r1 \<rightarrow> v1" "s2 \<in> r2 \<rightarrow> v2" "\<not>nullable r1" "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r1) \<and> s\<^sub>4 \<in> L r2)" apply(auto split: if_splits simp add: Sequ_def) apply(erule PMatch.cases) apply(auto elim: PMatch.cases simp add: Sequ_def der_correctness Der_def) by fastforce then show "(c # s) \<in> SEQ r1 r2 \<rightarrow> injval (SEQ r1 r2) c v" proof (cases) case left_nullable have "s1 \<in> der c r1 \<rightarrow> v1" by fact then have "(c # s1) \<in> r1 \<rightarrow> injval r1 c v1" using IH1 by simp moreover have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r1) \<and> s\<^sub>4 \<in> L r2)" by fact then have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> (c # s1) @ s\<^sub>3 \<in> L r1 \<and> s\<^sub>4 \<in> L r2)" by (simp add: der_correctness Der_def) ultimately have "((c # s1) @ s2) \<in> SEQ r1 r2 \<rightarrow> Seq (injval r1 c v1) v2" using left_nullable by (rule_tac PMatch.intros) then show "(c # s) \<in> SEQ r1 r2 \<rightarrow> injval (SEQ r1 r2) c v" using left_nullable by simp next case right_nullable have "nullable r1" by fact then have "[] \<in> r1 \<rightarrow> (mkeps r1)" by (rule PMatch_mkeps) moreover have "s \<in> der c r2 \<rightarrow> v1" by fact then have "(c # s) \<in> r2 \<rightarrow> (injval r2 c v1)" using IH2 by simp moreover have "s1 @ s2 \<notin> L (SEQ (der c r1) r2)" by fact then have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = c # s \<and> [] @ s\<^sub>3 \<in> L r1 \<and> s\<^sub>4 \<in> L r2)" using right_nullable by(auto simp add: der_correctness Der_def append_eq_Cons_conv Sequ_def) ultimately have "([] @ (c # s)) \<in> SEQ r1 r2 \<rightarrow> Seq (mkeps r1) (injval r2 c v1)" by(rule PMatch.intros) then show "(c # s) \<in> SEQ r1 r2 \<rightarrow> injval (SEQ r1 r2) c v" using right_nullable by simp next case not_nullable have "s1 \<in> der c r1 \<rightarrow> v1" by fact then have "(c # s1) \<in> r1 \<rightarrow> injval r1 c v1" using IH1 by simp moreover have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r1) \<and> s\<^sub>4 \<in> L r2)" by fact then have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> (c # s1) @ s\<^sub>3 \<in> L r1 \<and> s\<^sub>4 \<in> L r2)" by (simp add: der_correctness Der_def) ultimately have "((c # s1) @ s2) \<in> SEQ r1 r2 \<rightarrow> Seq (injval r1 c v1) v2" using not_nullable by (rule_tac PMatch.intros) (simp_all) then show "(c # s) \<in> SEQ r1 r2 \<rightarrow> injval (SEQ r1 r2) c v" using not_nullable by simp qednext case (STAR r) have IH: "\<And>s v. s \<in> der c r \<rightarrow> v \<Longrightarrow> (c # s) \<in> r \<rightarrow> injval r c v" by fact have "s \<in> der c (STAR r) \<rightarrow> v" by fact then consider (cons) v1 vs s1 s2 where "v = Seq v1 (Stars vs)" "s = s1 @ s2" "s1 \<in> der c r \<rightarrow> v1" "s2 \<in> (STAR r) \<rightarrow> (Stars vs)" "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r) \<and> s\<^sub>4 \<in> L (STAR r))" apply(erule_tac PMatch.cases) apply(auto) apply(rotate_tac 4) apply(erule_tac PMatch.cases) apply(auto) apply (simp add: PMatch.intros(6)) using PMatch.intros(7) by blast then show "(c # s) \<in> STAR r \<rightarrow> injval (STAR r) c v" proof (cases) case cons have "s1 \<in> der c r \<rightarrow> v1" by fact then have "(c # s1) \<in> r \<rightarrow> injval r c v1" using IH by simp moreover have "s2 \<in> STAR r \<rightarrow> Stars vs" by fact moreover have "(c # s1) \<in> r \<rightarrow> injval r c v1" by fact then have "flat (injval r c v1) = (c # s1)" by (rule PMatch1) then have "flat (injval r c v1) \<noteq> []" by simp moreover have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> s1 @ s\<^sub>3 \<in> L (der c r) \<and> s\<^sub>4 \<in> L (STAR r))" by fact then have "\<not> (\<exists>s\<^sub>3 s\<^sub>4. s\<^sub>3 \<noteq> [] \<and> s\<^sub>3 @ s\<^sub>4 = s2 \<and> (c # s1) @ s\<^sub>3 \<in> L r \<and> s\<^sub>4 \<in> L (STAR r))" by (simp add: der_correctness Der_def) ultimately have "((c # s1) @ s2) \<in> STAR r \<rightarrow> Stars (injval r c v1 # vs)" by (rule PMatch.intros) then show "(c # s) \<in> STAR r \<rightarrow> injval (STAR r) c v" using cons by(simp) qedqedlemma lex_correct1: assumes "s \<notin> L r" shows "matcher r s = None"using assmsapply(induct s arbitrary: r)apply(simp)apply (metis nullable_correctness)apply(auto)apply(drule_tac x="der a r" in meta_spec)apply(drule meta_mp)apply(auto)apply(simp add: der_correctness Der_def)donelemma lex_correct1a: shows "s \<notin> L r \<longleftrightarrow> matcher r s = None"using assmsapply(induct s arbitrary: r)apply(simp)apply (metis nullable_correctness)apply(auto)apply(drule_tac x="der a r" in meta_spec)apply(auto)apply(simp add: der_correctness Der_def)apply(drule_tac x="der a r" in meta_spec)apply(auto)apply(simp add: der_correctness Der_def)donelemma lex_correct2: assumes "s \<in> L r" shows "\<exists>v. matcher r s = Some(v) \<and> \<turnstile> v : r \<and> flat v = s"using assmsapply(induct s arbitrary: r)apply(simp)apply (metis mkeps_flat mkeps_nullable nullable_correctness)apply(drule_tac x="der a r" in meta_spec)apply(drule meta_mp)apply(simp add: der_correctness Der_def)apply(auto)apply (metis Prf_injval)apply(rule Prf_injval_flat)by simplemma lex_correct3: assumes "s \<in> L r" shows "\<exists>v. matcher r s = Some(v) \<and> s \<in> r \<rightarrow> v"using assmsapply(induct s arbitrary: r)apply(simp)apply (metis PMatch_mkeps nullable_correctness)apply(drule_tac x="der a r" in meta_spec)apply(drule meta_mp)apply(simp add: der_correctness Der_def)apply(auto)by (metis PMatch2_roy_version)lemma lex_correct3a: shows "s \<in> L r \<longleftrightarrow> (\<exists>v. matcher r s = Some(v) \<and> s \<in> r \<rightarrow> v)"using assmsapply(induct s arbitrary: r)apply(simp)apply (metis PMatch_mkeps nullable_correctness)apply(drule_tac x="der a r" in meta_spec)apply(auto)apply(metis PMatch2_roy_version)apply(simp add: der_correctness Der_def)using lex_correct1a apply fastforceapply(simp add: der_correctness Der_def)by (simp add: lex_correct1a)lemma lex_correct3b: shows "s \<in> L r \<longleftrightarrow> (\<exists>!v. matcher r s = Some(v) \<and> s \<in> r \<rightarrow> v)"using assmsapply(induct s arbitrary: r)apply(simp)apply (metis PMatch_mkeps nullable_correctness)apply(drule_tac x="der a r" in meta_spec)apply(simp add: der_correctness Der_def)apply(case_tac "matcher (der a r) s = None")apply(simp)apply(simp)apply(clarify)apply(rule iffI)apply(auto)apply(rule PMatch2_roy_version)apply(simp)using PMatch1(1) by autolemma lex_correct5: assumes "s \<in> L r" shows "s \<in> r \<rightarrow> (matcher2 r s)"using assmsapply(induct s arbitrary: r)apply(simp)apply (metis PMatch_mkeps nullable_correctness)apply(simp)apply(rule PMatch2_roy_version)apply(drule_tac x="der a r" in meta_spec)apply(drule meta_mp)apply(simp add: der_correctness Der_def)apply(auto)donelemma "matcher2 (ALT (CHAR a) (ALT (CHAR b) (SEQ (CHAR a) (CHAR b)))) [a,b] = Right (Right (Seq (Char a) (Char b)))"apply(simp)donefun F_RIGHT where "F_RIGHT f v = Right (f v)"fun F_LEFT where "F_LEFT f v = Left (f v)"fun F_ALT where "F_ALT f\<^sub>1 f\<^sub>2 (Right v) = Right (f\<^sub>2 v)"| "F_ALT f\<^sub>1 f\<^sub>2 (Left v) = Left (f\<^sub>1 v)" fun F_SEQ1 where "F_SEQ1 f\<^sub>1 f\<^sub>2 v = Seq (f\<^sub>1 Void) (f\<^sub>2 v)"fun F_SEQ2 where "F_SEQ2 f\<^sub>1 f\<^sub>2 v = Seq (f\<^sub>1 v) (f\<^sub>2 Void)"fun F_SEQ where "F_SEQ f\<^sub>1 f\<^sub>2 (Seq v\<^sub>1 v\<^sub>2) = Seq (f\<^sub>1 v\<^sub>1) (f\<^sub>2 v\<^sub>2)"fun simp_ALT where "simp_ALT (ZERO, f\<^sub>1) (r\<^sub>2, f\<^sub>2) = (r\<^sub>2, F_RIGHT f\<^sub>2)"| "simp_ALT (r\<^sub>1, f\<^sub>1) (ZERO, f\<^sub>2) = (r\<^sub>1, F_LEFT f\<^sub>1)"| "simp_ALT (r\<^sub>1, f\<^sub>1) (r\<^sub>2, f\<^sub>2) = (ALT r\<^sub>1 r\<^sub>2, F_ALT f\<^sub>1 f\<^sub>2)"fun simp_SEQ where "simp_SEQ (ONE, f\<^sub>1) (r\<^sub>2, f\<^sub>2) = (r\<^sub>2, F_SEQ1 f\<^sub>1 f\<^sub>2)"| "simp_SEQ (r\<^sub>1, f\<^sub>1) (ONE, f\<^sub>2) = (r\<^sub>1, F_SEQ2 f\<^sub>1 f\<^sub>2)"| "simp_SEQ (r\<^sub>1, f\<^sub>1) (r\<^sub>2, f\<^sub>2) = (SEQ r\<^sub>1 r\<^sub>2, F_SEQ f\<^sub>1 f\<^sub>2)" fun simp :: "rexp \<Rightarrow> rexp * (val \<Rightarrow> val)"where "simp (ALT r1 r2) = simp_ALT (simp r1) (simp r2)" | "simp (SEQ r1 r2) = simp_SEQ (simp r1) (simp r2)" | "simp r = (r, id)"fun matcher3 :: "rexp \<Rightarrow> string \<Rightarrow> val option"where "matcher3 r [] = (if nullable r then Some(mkeps r) else None)"| "matcher3 r (c#s) = (let (rs, fr) = simp (der c r) in (case (matcher3 rs s) of None \<Rightarrow> None | Some(v) \<Rightarrow> Some(injval r c (fr v))))"end