theory Re1

  imports "Main" 

begin

section {* Sequential Composition of Sets *}

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 {* Regular Expressions *}

datatype rexp =

  NULL

| EMPTY

| CHAR char

| SEQ rexp rexp

| ALT rexp rexp

fun SEQS :: "rexp \<Rightarrow> rexp list \<Rightarrow> rexp"

where

  "SEQS r [] = r"

| "SEQS r (r'#rs) = SEQ r (SEQS r' rs)"

section {* Semantics of Regular Expressions *}

fun

  L :: "rexp \<Rightarrow> string set"

where

  "L (NULL) = {}"

| "L (EMPTY) = {[]}"

| "L (CHAR c) = {[c]}"

| "L (SEQ r1 r2) = (L r1) ;; (L r2)"

| "L (ALT r1 r2) = (L r1) \<union> (L r2)"

fun

 nullable :: "rexp \<Rightarrow> bool"

where

  "nullable (NULL) = False"

| "nullable (EMPTY) = True"

| "nullable (CHAR c) = False"

| "nullable (ALT r1 r2) = (nullable r1 \<or> nullable r2)"

| "nullable (SEQ r1 r2) = (nullable r1 \<and> nullable r2)"

fun

 nullable_left :: "rexp \<Rightarrow> bool"

where

  "nullable_left (NULL) = False"

| "nullable_left (EMPTY) = True"

| "nullable_left (CHAR c) = False"

| "nullable_left (ALT r1 r2) = (nullable_left r1 \<or> nullable_left r2)"

| "nullable_left (SEQ r1 r2) = nullable_left r1"

lemma nullable_left:

  "nullable r \<Longrightarrow> nullable_left r"

apply(induct r)

apply(auto)

done

value "L(CHAR c)"

value "L(SEQ(CHAR c)(CHAR b))"

lemma nullable_correctness:

  shows "nullable r  \<longleftrightarrow> [] \<in> (L r)"

apply (induct r) 

apply(auto simp add: Sequ_def) 

done

section {* Values *}

datatype val = 

  Void

| Char char

| Seq val val

| Right val

| Left val

fun Seqs :: "val \<Rightarrow> val list \<Rightarrow> val"

where

  "Seqs v [] = v"

| "Seqs v (v'#vs) = Seq v (Seqs v' vs)"

section {* 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)"

fun flat_left :: "val \<Rightarrow> string"

where

  "flat_left(Void) = []"

| "flat_left(Char c) = [c]"

| "flat_left(Left v) = flat_left(v)"

| "flat_left(Right v) = flat_left(v)"

| "flat_left(Seq v1 v2) = flat_left(v1)"

fun flat_right :: "val \<Rightarrow> string"

where

  "flat_right(Void) = []"

| "flat_right(Char c) = [c]"

| "flat_right(Left v) = flat(v)"

| "flat_right(Right v) = flat(v)"

| "flat_right(Seq v1 v2) = flat(v2)"

fun head :: "val \<Rightarrow> string"

where

  "head(Void) = []"

| "head(Char c) = [c]"

| "head(Left v) = head(v)"

| "head(Right v) = head(v)"

| "head(Seq v1 v2) = head v1"

fun flats :: "val \<Rightarrow> string list"

where

  "flats(Void) = [[]]"

| "flats(Char c) = [[c]]"

| "flats(Left v) = flats(v)"

| "flats(Right v) = flats(v)"

| "flats(Seq v1 v2) = (flats v1) @ (flats v2)"

value "flats(Seq(Char c)(Char b))"

section {* Relation between values and regular expressions *}

inductive Prfs :: "string \<Rightarrow> val \<Rightarrow> rexp \<Rightarrow> bool" ("\<Turnstile>_ _ : _" [100, 100, 100] 100)

where

 "\<lbrakk>\<Turnstile>s1 v1 : r1; \<Turnstile>s2 v2 : r2\<rbrakk> \<Longrightarrow> \<Turnstile>(s1 @ s2) (Seq v1 v2) : SEQ r1 r2"

| "\<Turnstile>s v1 : r1 \<Longrightarrow> \<Turnstile>s (Left v1) : ALT r1 r2"

| "\<Turnstile>s v2 : r2 \<Longrightarrow> \<Turnstile>s (Right v2) : ALT r1 r2"

| "\<Turnstile>[] Void : EMPTY"

| "\<Turnstile>[c] (Char c) : CHAR c"

lemma Prfs_flat:

  "\<Turnstile>s v : r \<Longrightarrow> flat v = s"

apply(induct s v r rule: Prfs.induct)

apply(auto)

done

inductive Prfn :: "nat \<Rightarrow> val \<Rightarrow> rexp \<Rightarrow> bool" ("\<TTurnstile>_ _ : _" [100, 100, 100] 100)

where

 "\<lbrakk>\<TTurnstile>n1 v1 : r1; \<TTurnstile>n2 v2 : r2\<rbrakk> \<Longrightarrow> \<TTurnstile>(n1 + n2) (Seq v1 v2) : SEQ r1 r2"

| "\<TTurnstile>n v1 : r1 \<Longrightarrow> \<TTurnstile>n (Left v1) : ALT r1 r2"

| "\<TTurnstile>n v2 : r2 \<Longrightarrow> \<TTurnstile>n (Right v2) : ALT r1 r2"

| "\<TTurnstile>0 Void : EMPTY"

| "\<TTurnstile>1 (Char c) : CHAR c"

lemma Prfn_flat:

  "\<TTurnstile>n v : r \<Longrightarrow> length(flat v) = n"

apply(induct rule: Prfn.induct)

apply(auto)

done

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 : EMPTY"

| "\<turnstile> Char c : CHAR c"

lemma Prf_Prfn:

  shows "\<turnstile> v : r \<Longrightarrow> \<TTurnstile>(length (flat v)) v : r"

apply(induct v r rule: Prf.induct)

apply(auto intro: Prfn.intros)

by (metis One_nat_def Prfn.intros(5))

lemma Prfn_Prf:

  shows "\<TTurnstile>n v : r \<Longrightarrow> \<turnstile> v : r"

apply(induct n v r rule: Prfn.induct)

apply(auto intro: Prf.intros)

done

lemma Prf_Prfs:

  shows "\<turnstile> v : r \<Longrightarrow> \<Turnstile>(flat v) v : r"

apply(induct v r rule: Prf.induct)

apply(auto intro: Prfs.intros)

done

lemma Prfs_Prf:

  shows "\<Turnstile>s v : r \<Longrightarrow> \<turnstile> v : r"

apply(induct s v r rule: Prfs.induct)

apply(auto intro: Prf.intros)

done

fun mkeps :: "rexp \<Rightarrow> val"

where

  "mkeps(EMPTY) = 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))"

lemma mkeps_nullable:

  assumes "nullable(r)" shows "\<turnstile> mkeps r : r"

using assms

apply(induct rule: nullable.induct)

apply(auto intro: Prf.intros)

done

lemma mkeps_nullable_n:

  assumes "nullable(r)" shows "\<TTurnstile>0 (mkeps r) : r"

using assms

apply(induct rule: nullable.induct)

apply(auto intro: Prfn.intros)

apply(drule Prfn.intros(1))

apply(assumption)

apply(simp)

done

lemma mkeps_nullable_s:

  assumes "nullable(r)" shows "\<Turnstile>[] (mkeps r) : r"

using assms

apply(induct rule: nullable.induct)

apply(auto intro: Prfs.intros)

apply(drule Prfs.intros(1))

apply(assumption)

apply(simp)

done

lemma mkeps_flat:

  assumes "nullable(r)" shows "flat (mkeps r) = []"

using assms

apply(induct rule: nullable.induct)

apply(auto)

done

lemma mkeps_flat_left:

  assumes "nullable(r)" shows "flat_left (mkeps r) = []"

using assms

apply(induct rule: nullable.induct)

apply(auto)

done

text {*

  The value mkeps returns is always the correct POSIX

  value.

*}

lemma Prf_flat_L:

  assumes "\<turnstile> v : r" shows "flat v \<in> L r"

using assms

apply(induct v r rule: Prf.induct)

apply(auto simp add: Sequ_def)

done

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)

done

definition prefix :: "string \<Rightarrow> string \<Rightarrow> bool" ("_ \<sqsubset> _" [100, 100] 100)

where

  "s1 \<sqsubset> s2 \<equiv> \<exists>s3. s1 @ s3 = s2"

section {* Ordering of values *}

inductive ValOrd :: "val \<Rightarrow> rexp \<Rightarrow> val \<Rightarrow> bool" ("_ \<succ>_ _" [100, 100, 100] 100)

where

  "v2 \<succ>r2 v2' \<Longrightarrow> (Seq v1 v2) \<succ>(SEQ r1 r2) (Seq v1 v2')" 

| "\<lbrakk>v1 \<succ>r1 v1'; v1 \<noteq> v1'\<rbrakk> \<Longrightarrow> (Seq v1 v2) \<succ>(SEQ r1 r2) (Seq v1' v2')" 

| "length (flat v1) \<ge> length (flat v2) \<Longrightarrow> (Left v1) \<succ>(ALT r1 r2) (Right v2)"

| "length (flat v2) > length (flat v1) \<Longrightarrow> (Right v2) \<succ>(ALT r1 r2) (Left v1)"

| "v2 \<succ>r2 v2' \<Longrightarrow> (Right v2) \<succ>(ALT r1 r2) (Right v2')"

| "v1 \<succ>r1 v1' \<Longrightarrow> (Left v1) \<succ>(ALT r1 r2) (Left v1')"

| "Void \<succ>EMPTY Void"

| "(Char c) \<succ>(CHAR c) (Char c)"

inductive ValOrd2 :: "val \<Rightarrow> val \<Rightarrow> bool" ("_ 2\<succ> _" [100, 100] 100)

where

  "v2 2\<succ> v2' \<Longrightarrow> (Seq v1 v2) 2\<succ> (Seq v1 v2')" 

| "\<lbrakk>v1 2\<succ> v1'; v1 \<noteq> v1'\<rbrakk> \<Longrightarrow> (Seq v1 v2) 2\<succ> (Seq v1' v2')" 

| "length (flat v1) \<ge> length (flat v2) \<Longrightarrow> (Left v1) 2\<succ> (Right v2)"

| "length (flat v2) > length (flat v1) \<Longrightarrow> (Right v2) 2\<succ> (Left v1)"

| "v2 2\<succ> v2' \<Longrightarrow> (Right v2) 2\<succ> (Right v2')"

| "v1 2\<succ> v1' \<Longrightarrow> (Left v1) 2\<succ> (Left v1')"

| "Void 2\<succ> Void"

| "(Char c) 2\<succ> (Char c)"

lemma Ord1:

  "v1 \<succ>r v2 \<Longrightarrow> v1 2\<succ> v2"

apply(induct rule: ValOrd.induct)

apply(auto intro: ValOrd2.intros)

done

lemma Ord2:

  "v1 2\<succ> v2 \<Longrightarrow> \<exists>r. v1 \<succ>r v2"

apply(induct v1 v2 rule: ValOrd2.induct)

apply(auto intro: ValOrd.intros)

done

lemma Ord3:

  "\<lbrakk>v1 2\<succ> v2; \<turnstile> v1 : r\<rbrakk> \<Longrightarrow> v1 \<succ>r v2"

apply(induct v1 v2 arbitrary: r rule: ValOrd2.induct)

apply(auto intro: ValOrd.intros elim: Prf.cases)

done

lemma ValOrd_refl:

  assumes "\<turnstile> v : r"

  shows "v \<succ>r v"

using assms

apply(induct)

apply(auto intro: ValOrd.intros)

done

lemma 

  "flat Void = []"

  "flat (Seq Void Void) = []"

apply(simp_all)

done

lemma ValOrd_total:

  shows "\<lbrakk>\<turnstile> v1 : r; \<turnstile> v2 : r\<rbrakk>  \<Longrightarrow> v1 \<succ>r v2 \<or> v2 \<succ>r v1"

apply(induct r arbitrary: v1 v2)

apply(auto)

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply (metis ValOrd.intros(7))

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply (metis ValOrd.intros(8))

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply(clarify)

apply(case_tac "v1a = v1b")

apply(simp)

apply(rule ValOrd.intros(1))

apply (metis ValOrd.intros(1))

apply(rule ValOrd.intros(2))

apply(auto)[2]

apply(erule contrapos_np)

apply(rule ValOrd.intros(2))

apply(auto)

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply (metis Ord1 Ord3 Prf.intros(2) ValOrd2.intros(6))

apply(rule ValOrd.intros)

apply(erule contrapos_np)

apply(rule ValOrd.intros)

apply (metis le_eq_less_or_eq neq_iff)

apply(erule Prf.cases)

apply(simp_all)[5]

apply(rule ValOrd.intros)

apply(erule contrapos_np)

apply(rule ValOrd.intros)

apply (metis le_eq_less_or_eq neq_iff)

apply(rule ValOrd.intros)

apply(erule contrapos_np)

apply(rule ValOrd.intros)

by metis

lemma ValOrd_anti:

  shows "\<lbrakk>\<turnstile> v1 : r; \<turnstile> v2 : r; v1 \<succ>r v2; v2 \<succ>r v1\<rbrakk> \<Longrightarrow> v1 = v2"

apply(induct r arbitrary: v1 v2)

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule ValOrd.cases)

apply(simp_all)[8]

apply(erule ValOrd.cases)

apply(simp_all)[8]

apply(erule ValOrd.cases)

apply(simp_all)[8]

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule ValOrd.cases)

apply(simp_all)[8]

apply(erule ValOrd.cases)

apply(simp_all)[8]

apply(erule ValOrd.cases)

apply(simp_all)[8]

apply(erule ValOrd.cases)

apply(simp_all)[8]

apply(erule Prf.cases)

apply(simp_all)[5]

apply(erule ValOrd.cases)

apply(simp_all)[8]

apply(erule ValOrd.cases)

apply(simp_all)[8]

apply(erule ValOrd.cases)

apply(simp_all)[8]

apply(erule ValOrd.cases)

apply(simp_all)[8]

done

apply(rule impI)

apply(rule impI)

apply(rule conjI)

apply(rule allI)

apply(rule impI)

apply(erule conjE)

apply(rule conjI)

apply(rule allI)

apply(rule impI)

apply(erule conjE)

apply(erule Prf.cases)

apply(simp_all)[5]