(*<*) (* Author: Dmitriy Traytel *) section ‹A Codatatype of Formal Languages› theory Coinductive_Language imports Main begin hide_const (open) Inter (*>*) section ‹Introduction› text ‹ We define formal languages as a codataype of infinite trees branching over the alphabet @{typ 'a}. Each node in such a tree indicates whether the path to this node constitutes a word inside or outside of the language. › codatatype 'a language = Lang (𝔬: bool) (𝔡: "'a ⇒ 'a language") text ‹ This codatatype is isormorphic to the set of lists representation of languages, but caters for definitions by corecursion and proofs by coinduction. Regular operations on languages are then defined by primitive corecursion. A difficulty arises here, since the standard definitions of concatenation and iteration from the coalgebraic literature are not primitively corecursive---they require guardedness up-to union/concatenation. Without support for up-to corecursion, these operation must be defined as a composition of primitive ones (and proved being equal to the standard definitions). As an exercise in coinduction we also prove the axioms of Kleene algebra for the defined regular operations. Furthermore, a language for context-free grammars given by productions in Greibach normal form and an initial nonterminal is constructed by primitive corecursion, yielding an executable decision procedure for the word problem without further ado. › (*<*) (* custom coinduction theorem (getting rid of rel_fun) *) declare language.coinduct_strong[unfolded rel_fun_def, simplified, case_names Lang, coinduct pred] (*>*) section ‹Regular Languages› primcorec Zero :: "'a language" where "𝔬 Zero = False" | "𝔡 Zero = (λ_. Zero)" primcorec One :: "'a language" where "𝔬 One = True" | "𝔡 One = (λ_. Zero)" primcorec Atom :: "'a ⇒ 'a language" where "𝔬 (Atom a) = False" | "𝔡 (Atom a) = (λb. if a = b then One else Zero)" primcorec Plus :: "'a language ⇒ 'a language ⇒ 'a language" where "𝔬 (Plus r s) = (𝔬 r ∨ 𝔬 s)" | "𝔡 (Plus r s) = (λa. Plus (𝔡 r a) (𝔡 s a))" theorem Plus_ZeroL[simp]: "Plus Zero r = r" by (coinduction arbitrary: r) simp theorem Plus_ZeroR[simp]: "Plus r Zero = r" by (coinduction arbitrary: r) simp theorem Plus_assoc: "Plus (Plus r s) t = Plus r (Plus s t)" by (coinduction arbitrary: r s t) auto theorem Plus_comm: "Plus r s = Plus s r" by (coinduction arbitrary: r s) auto lemma Plus_rotate: "Plus r (Plus s t) = Plus s (Plus r t)" using Plus_assoc Plus_comm by metis theorem Plus_idem: "Plus r r = r" by (coinduction arbitrary: r) auto lemma Plus_idem_assoc: "Plus r (Plus r s) = Plus r s" by (metis Plus_assoc Plus_idem) lemmas Plus_ACI[simp] = Plus_rotate Plus_comm Plus_assoc Plus_idem_assoc Plus_idem lemma Plus_OneL[simp]: "𝔬 r ⟹ Plus One r = r" by (coinduction arbitrary: r) auto lemma Plus_OneR[simp]: "𝔬 r ⟹ Plus r One = r" by (coinduction arbitrary: r) auto text ‹ Concatenation is not primitively corecursive---the corecursive call of its derivative is guarded by @{term Plus}. However, it can be defined as a composition of two primitively corecursive functions. › primcorec TimesLR :: "'a language ⇒ 'a language ⇒ ('a × bool) language" where "𝔬 (TimesLR r s) = (𝔬 r ∧ 𝔬 s)" | "𝔡 (TimesLR r s) = (λ(a, b). if b then TimesLR (𝔡 r a) s else if 𝔬 r then TimesLR (𝔡 s a) One else Zero)" primcorec Times_Plus :: "('a × bool) language ⇒ 'a language" where "𝔬 (Times_Plus r) = 𝔬 r" | "𝔡 (Times_Plus r) = (λa. Times_Plus (Plus (𝔡 r (a, True)) (𝔡 r (a, False))))" lemma TimesLR_ZeroL[simp]: "TimesLR Zero r = Zero" by (coinduction arbitrary: r) auto lemma TimesLR_ZeroR[simp]: "TimesLR r Zero = Zero" by (coinduction arbitrary: r) (auto intro: exI[of _ Zero]) lemma TimesLR_PlusL[simp]: "TimesLR (Plus r s) t = Plus (TimesLR r t) (TimesLR s t)" by (coinduction arbitrary: r s t) auto lemma TimesLR_PlusR[simp]: "TimesLR r (Plus s t) = Plus (TimesLR r s) (TimesLR r t)" by (coinduction arbitrary: r s t) auto lemma Times_Plus_Zero[simp]: "Times_Plus Zero = Zero" by coinduction simp lemma Times_Plus_Plus[simp]: "Times_Plus (Plus r s) = Plus (Times_Plus r) (Times_Plus s)" proof (coinduction arbitrary: r s) case (Lang r s) then show ?case unfolding Times_Plus.sel Plus.sel by (intro conjI[OF refl]) (metis Plus_comm Plus_rotate) qed lemma Times_Plus_TimesLR_One[simp]: "Times_Plus (TimesLR r One) = r" by (coinduction arbitrary: r) simp lemma Times_Plus_TimesLR_PlusL[simp]: "Times_Plus (TimesLR (Plus r s) t) = Plus (Times_Plus (TimesLR r t)) (Times_Plus (TimesLR s t))" by (coinduction arbitrary: r s t) auto lemma Times_Plus_TimesLR_PlusR[simp]: "Times_Plus (TimesLR r (Plus s t)) = Plus (Times_Plus (TimesLR r s)) (Times_Plus (TimesLR r t))" by (coinduction arbitrary: r s t) auto definition Times :: "'a language ⇒ 'a language ⇒ 'a language" where "Times r s = Times_Plus (TimesLR r s)" lemma 𝔬_Times[simp]: "𝔬 (Times r s) = (𝔬 r ∧ 𝔬 s)" unfolding Times_def by simp lemma 𝔡_Times[simp]: "𝔡 (Times r s) = (λa. if 𝔬 r then Plus (Times (𝔡 r a) s) (𝔡 s a) else Times (𝔡 r a) s)" unfolding Times_def by auto theorem Times_ZeroL[simp]: "Times Zero r = Zero" by coinduction simp theorem Times_ZeroR[simp]: "Times r Zero = Zero" by (coinduction arbitrary: r) auto theorem Times_OneL[simp]: "Times One r = r" by (coinduction arbitrary: r rule: language.coinduct_strong) (simp add: rel_fun_def) theorem Times_OneR[simp]: "Times r One = r" by (coinduction arbitrary: r) simp text ‹ Coinduction up-to @{term Plus}--congruence relaxes the coinduction hypothesis by requiring membership in the congruence closure of the bisimulation rather than in the bisimulation itself. › inductive Plus_cong for R where Refl[intro]: "x = y ⟹ Plus_cong R x y" | Base[intro]: "R x y ⟹ Plus_cong R x y" | Sym: "Plus_cong R x y ⟹ Plus_cong R y x" | Trans[intro]: "Plus_cong R x y ⟹ Plus_cong R y z ⟹ Plus_cong R x z" | Plus[intro]: "⟦Plus_cong R x y; Plus_cong R x' y'⟧ ⟹ Plus_cong R (Plus x x') (Plus y y')" lemma language_coinduct_upto_Plus[unfolded rel_fun_def, simplified, case_names Lang, consumes 1]: assumes R: "R L K" and hyp: "(⋀L K. R L K ⟹ 𝔬 L = 𝔬 K ∧ rel_fun (=) (Plus_cong R) (𝔡 L) (𝔡 K))" shows "L = K" proof (coinduct rule: language.coinduct[of "Plus_cong R"]) fix L K assume "Plus_cong R L K" then show "𝔬 L = 𝔬 K ∧ rel_fun (=) (Plus_cong R) (𝔡 L) (𝔡 K)" by (induct rule: Plus_cong.induct) (auto simp: rel_fun_def intro: Sym dest: hyp) qed (intro Base R) theorem Times_PlusL[simp]: "Times (Plus r s) t = Plus (Times r t) (Times s t)" by (coinduction arbitrary: r s rule: language_coinduct_upto_Plus) auto theorem Times_PlusR[simp]: "Times r (Plus s t) = Plus (Times r s) (Times r t)" by (coinduction arbitrary: r s rule: language_coinduct_upto_Plus) fastforce theorem Times_assoc[simp]: "Times (Times r s) t = Times r (Times s t)" by (coinduction arbitrary: r s t rule: language_coinduct_upto_Plus) fastforce text ‹ Similarly to @{term Times}, iteration is not primitively corecursive (guardedness by @{term Times} is required). We apply a similar trick to obtain its definition. › primcorec StarLR :: "'a language ⇒ 'a language ⇒ 'a language" where "𝔬 (StarLR r s) = 𝔬 r" | "𝔡 (StarLR r s) = (λa. StarLR (𝔡 (Times r (Plus One s)) a) s)" lemma StarLR_Zero[simp]: "StarLR Zero r = Zero" by coinduction auto lemma StarLR_Plus[simp]: "StarLR (Plus r s) t = Plus (StarLR r t) (StarLR s t)" by (coinduction arbitrary: r s) (auto simp del: Plus_ACI Times_PlusR) lemma StarLR_Times_Plus_One[simp]: "StarLR (Times r (Plus One s)) s = StarLR r s" proof (coinduction arbitrary: r s) case Lang { fix a define L and R where "L = Plus (𝔡 r a) (Plus (Times (𝔡 r a) s) (𝔡 s a))" and "R = Times (Plus (𝔡 r a) (Plus (Times (𝔡 r a) s) (𝔡 s a))) s" have "Plus L (Plus R (𝔡 s a)) = Plus (Plus L (𝔡 s a)) R" by (metis Plus_assoc Plus_comm) also have "Plus L (𝔡 s a) = L" unfolding L_def by simp finally have "Plus L (Plus R (𝔡 s a)) = Plus L R" . } then show ?case by (auto simp del: StarLR_Plus Plus_assoc Times_PlusL) qed lemma StarLR_Times: "StarLR (Times r s) t = Times r (StarLR s t)" by (coinduction arbitrary: r s t rule: language_coinduct_upto_Plus) (fastforce simp del: Plus_ACI Times_PlusR) definition Star :: "'a language ⇒ 'a language" where "Star r = StarLR One r" lemma 𝔬_Star[simp]: "𝔬 (Star r)" unfolding Star_def by simp lemma 𝔡_Star[simp]: "𝔡 (Star r) = (λa. Times (𝔡 r a) (Star r))" unfolding Star_def by (auto simp add: Star_def StarLR_Times[symmetric]) lemma Star_Zero[simp]: "Star Zero = One" by coinduction auto lemma Star_One[simp]: "Star One = One" by coinduction auto lemma Star_unfoldL: "Star r = Plus One (Times r (Star r))" by coinduction auto primcorec Inter :: "'a language ⇒ 'a language ⇒ 'a language" where "𝔬 (Inter r s) = (𝔬 r ∧ 𝔬 s)" | "𝔡 (Inter r s) = (λa. Inter (𝔡 r a) (𝔡 s a))" primcorec Not :: "'a language ⇒ 'a language" where "𝔬 (Not r) = (¬ 𝔬 r)" | "𝔡 (Not r) = (λa. Not (𝔡 r a))" primcorec Full :: "'a language" ("Σ⇧^{*}") where "𝔬 Full = True" | "𝔡 Full = (λ_. Full)" text ‹ Shuffle product is not primitively corecursive---the corecursive call of its derivative is guarded by @{term Plus}. However, it can be defined as a composition of two primitively corecursive functions. › primcorec ShuffleLR :: "'a language ⇒ 'a language ⇒ ('a × bool) language" where "𝔬 (ShuffleLR r s) = (𝔬 r ∧ 𝔬 s)" | "𝔡 (ShuffleLR r s) = (λ(a, b). if b then ShuffleLR (𝔡 r a) s else ShuffleLR r (𝔡 s a))" lemma ShuffleLR_ZeroL[simp]: "ShuffleLR Zero r = Zero" by (coinduction arbitrary: r) auto lemma ShuffleLR_ZeroR[simp]: "ShuffleLR r Zero = Zero" by (coinduction arbitrary: r) (auto intro: exI[of _ Zero]) lemma ShuffleLR_PlusL[simp]: "ShuffleLR (Plus r s) t = Plus (ShuffleLR r t) (ShuffleLR s t)" by (coinduction arbitrary: r s t) auto lemma ShuffleLR_PlusR[simp]: "ShuffleLR r (Plus s t) = Plus (ShuffleLR r s) (ShuffleLR r t)" by (coinduction arbitrary: r s t) auto lemma Shuffle_Plus_ShuffleLR_One[simp]: "Times_Plus (ShuffleLR r One) = r" by (coinduction arbitrary: r) simp lemma Shuffle_Plus_ShuffleLR_PlusL[simp]: "Times_Plus (ShuffleLR (Plus r s) t) = Plus (Times_Plus (ShuffleLR r t)) (Times_Plus (ShuffleLR s t))" by (coinduction arbitrary: r s t) auto lemma Shuffle_Plus_ShuffleLR_PlusR[simp]: "Times_Plus (ShuffleLR r (Plus s t)) = Plus (Times_Plus (ShuffleLR r s)) (Times_Plus (ShuffleLR r t))" by (coinduction arbitrary: r s t) auto definition Shuffle :: "'a language ⇒ 'a language ⇒ 'a language" where "Shuffle r s = Times_Plus (ShuffleLR r s)" lemma 𝔬_Shuffle[simp]: "𝔬 (Shuffle r s) = (𝔬 r ∧ 𝔬 s)" unfolding Shuffle_def by simp lemma 𝔡_Shuffle[simp]: "𝔡 (Shuffle r s) = (λa. Plus (Shuffle (𝔡 r a) s) (Shuffle r (𝔡 s a)))" unfolding Shuffle_def by auto theorem Shuffle_ZeroL[simp]: "Shuffle Zero r = Zero" by (coinduction arbitrary: r rule: language_coinduct_upto_Plus) (auto 0 4) theorem Shuffle_ZeroR[simp]: "Shuffle r Zero = Zero" by (coinduction arbitrary: r rule: language_coinduct_upto_Plus) (auto 0 4) theorem Shuffle_OneL[simp]: "Shuffle One r = r" by (coinduction arbitrary: r) simp theorem Shuffle_OneR[simp]: "Shuffle r One = r" by (coinduction arbitrary: r) simp theorem Shuffle_PlusL[simp]: "Shuffle (Plus r s) t = Plus (Shuffle r t) (Shuffle s t)" by (coinduction arbitrary: r s t rule: language_coinduct_upto_Plus) (force intro!: Trans[OF Plus[OF Base Base] Refl]) theorem Shuffle_PlusR[simp]: "Shuffle r (Plus s t) = Plus (Shuffle r s) (Shuffle r t)" by (coinduction arbitrary: r s t rule: language_coinduct_upto_Plus) (force intro!: Trans[OF Plus[OF Base Base] Refl]) theorem Shuffle_assoc[simp]: "Shuffle (Shuffle r s) t = Shuffle r (Shuffle s t)" by (coinduction arbitrary: r s t rule: language_coinduct_upto_Plus) fastforce theorem Shuffle_comm[simp]: "Shuffle r s = Shuffle s r" by (coinduction arbitrary: r s rule: language_coinduct_upto_Plus) (auto intro!: Trans[OF Plus[OF Base Base] Refl]) text ‹ We generalize coinduction up-to @{term Plus} to coinduction up-to all previously defined concepts. › inductive regular_cong for R where Refl[intro]: "x = y ⟹ regular_cong R x y" | Sym[intro]: "regular_cong R x y ⟹ regular_cong R y x" | Trans[intro]: "⟦regular_cong R x y; regular_cong R y z⟧ ⟹ regular_cong R x z" | Base[intro]: "R x y ⟹ regular_cong R x y" | Plus[intro, simp]: "⟦regular_cong R x y; regular_cong R x' y'⟧ ⟹ regular_cong R (Plus x x') (Plus y y')" | Times[intro, simp]: "⟦regular_cong R x y; regular_cong R x' y'⟧ ⟹ regular_cong R (Times x x') (Times y y')" | Star[intro, simp]: "⟦regular_cong R x y⟧ ⟹ regular_cong R (Star x) (Star y)" | Inter[intro, simp]: "⟦regular_cong R x y; regular_cong R x' y'⟧ ⟹ regular_cong R (Inter x x') (Inter y y')" | Not[intro, simp]: "⟦regular_cong R x y⟧ ⟹ regular_cong R (Not x) (Not y)" | Shuffle[intro, simp]: "⟦regular_cong R x y; regular_cong R x' y'⟧ ⟹ regular_cong R (Shuffle x x') (Shuffle y y')" lemma language_coinduct_upto_regular[unfolded rel_fun_def, simplified, case_names Lang, consumes 1]: assumes R: "R L K" and hyp: "(⋀L K. R L K ⟹ 𝔬 L = 𝔬 K ∧ rel_fun (=) (regular_cong R) (𝔡 L) (𝔡 K))" shows "L = K" proof (coinduct rule: language.coinduct[of "regular_cong R"]) fix L K assume "regular_cong R L K" then show "𝔬 L = 𝔬 K ∧ rel_fun (=) (regular_cong R) (𝔡 L) (𝔡 K)" by (induct rule: regular_cong.induct) (auto dest: hyp simp: rel_fun_def) qed (intro Base R) lemma Star_unfoldR: "Star r = Plus One (Times (Star r) r)" proof (coinduction arbitrary: r rule: language_coinduct_upto_regular) case Lang { fix a have "Plus (Times (𝔡 r a) (Times (Star r) r)) (𝔡 r a) = Times (𝔡 r a) (Plus One (Times (Star r) r))" by simp } then show ?case by (auto simp del: Times_PlusR) qed lemma Star_Star[simp]: "Star (Star r) = Star r" by (subst Star_unfoldL, coinduction arbitrary: r rule: language_coinduct_upto_regular) auto lemma Times_Star[simp]: "Times (Star r) (Star r) = Star r" proof (coinduction arbitrary: r rule: language_coinduct_upto_regular) case Lang have *: "⋀r s. Plus (Times r s) r = Times r (Plus s One)" by simp show ?case by (auto simp del: Times_PlusR Plus_ACI simp: Times_PlusR[symmetric] *) qed instantiation language :: (type) "{semiring_1, order}" begin lemma Zero_One[simp]: "Zero ≠ One" by (metis One.simps(1) Zero.simps(1)) definition "zero_language = Zero" definition "one_language = One" definition "plus_language = Plus" definition "times_language = Times" definition "less_eq_language r s = (Plus r s = s)" definition "less_language r s = (Plus r s = s ∧ r ≠ s)" lemmas language_defs = zero_language_def one_language_def plus_language_def times_language_def less_eq_language_def less_language_def instance proof intro_classes fix x y z :: "'a language" assume "x ≤ y" "y ≤ z" then show "x ≤ z" unfolding language_defs by (metis Plus_assoc) next fix x y z :: "'a language" show "x + y + z = x + (y + z)" unfolding language_defs by (rule Plus_assoc) qed (auto simp: language_defs) end lemma 𝔬_mono[dest]: "r ≤ s ⟹ 𝔬 r ⟹ 𝔬 s" unfolding less_eq_language_def by (auto dest: arg_cong[of _ _ 𝔬]) lemma 𝔡_mono[dest]: "r ≤ s ⟹ 𝔡 r a ≤ 𝔡 s a" unfolding less_eq_language_def by (metis Plus.simps(2)) text ‹ For reasoning about @{term "(≤)"}, we prove a coinduction principle and generalize it to support up-to reasoning. › theorem language_simulation_coinduction[consumes 1, case_names Lang, coinduct pred]: assumes "R L K" and "(⋀L K. R L K ⟹ 𝔬 L ≤ 𝔬 K ∧ (∀x. R (𝔡 L x) (𝔡 K x)))" shows "L ≤ K" using ‹R L K› unfolding less_eq_language_def by (coinduction arbitrary: L K) (auto dest!: assms(2)) lemma le_PlusL[intro!, simp]: "r ≤ Plus r s" by (coinduction arbitrary: r s) auto lemma le_PlusR[intro!, simp]: "s ≤ Plus r s" by (coinduction arbitrary: r s) auto inductive Plus_Times_pre_cong for R where pre_Less[intro, simp]: "x ≤ y ⟹ Plus_Times_pre_cong R x y" | pre_Trans[intro]: "⟦Plus_Times_pre_cong R x y; Plus_Times_pre_cong R y z⟧ ⟹ Plus_Times_pre_cong R x z" | pre_Base[intro, simp]: "R x y ⟹ Plus_Times_pre_cong R x y" | pre_Plus[intro!, simp]: "⟦Plus_Times_pre_cong R x y; Plus_Times_pre_cong R x' y'⟧ ⟹ Plus_Times_pre_cong R (Plus x x') (Plus y y')" | pre_Times[intro!, simp]: "⟦Plus_Times_pre_cong R x y; Plus_Times_pre_cong R x' y'⟧ ⟹ Plus_Times_pre_cong R (Times x x') (Times y y')" theorem language_simulation_coinduction_upto_Plus_Times[consumes 1, case_names Lang, coinduct pred]: assumes R: "R L K" and hyp: "(⋀L K. R L K ⟹ 𝔬 L ≤ 𝔬 K ∧ (∀x. Plus_Times_pre_cong R (𝔡 L x) (𝔡 K x)))" shows "L ≤ K" proof (coinduct rule: language_simulation_coinduction[of "Plus_Times_pre_cong R"]) fix L K assume "Plus_Times_pre_cong R L K" then show "𝔬 L ≤ 𝔬 K ∧ (∀x. Plus_Times_pre_cong R (𝔡 L x) (𝔡 K x))" by (induct rule: Plus_Times_pre_cong.induct) (auto dest: hyp) qed (intro pre_Base R) lemma ge_One[simp]: "One ≤ r ⟷ 𝔬 r" unfolding less_eq_language_def by (metis One.sel(1) Plus.sel(1) Plus_OneL) lemma Plus_mono: "⟦r1 ≤ s1; r2 ≤ s2⟧ ⟹ Plus r1 r2 ≤ Plus s1 s2" by (coinduction arbitrary: r1 r2 s1 s2) (auto elim!: 𝔡_mono) lemma Plus_upper: "⟦r1 ≤ s; r2 ≤ s⟧ ⟹ Plus r1 r2 ≤ s" by (coinduction arbitrary: r1 r2 s) auto lemma Inter_mono: "⟦r1 ≤ s1; r2 ≤ s2⟧ ⟹ Inter r1 r2 ≤ Inter s1 s2" by (coinduction arbitrary: r1 r2 s1 s2) (force elim!: 𝔡_mono) lemma Times_mono: "⟦r1 ≤ s1; r2 ≤ s2⟧ ⟹ Times r1 r2 ≤ Times s1 s2" by (coinduction arbitrary: r1 r2 s1 s2) (auto 0 3 elim!: 𝔡_mono) text ‹ We prove the missing axioms of Kleene Algebras about @{term Star}, as well as monotonicity properties and three standard interesting rules: bisimulation, sliding, and denesting. › theorem le_StarL: "Plus One (Times r (Star r)) ≤ Star r" by coinduction auto theorem le_StarR: "Plus One (Times (Star r) r) ≤ Star r" by (rule order_eq_refl[OF Star_unfoldR[symmetric]]) lemma le_TimesL[intro, simp]: "𝔬 s ⟹ r ≤ Times r s" by (coinduction arbitrary: r) auto lemma le_TimesR[intro, simp]: "𝔬 r ⟹ s ≤ Times r s" by coinduction auto lemma Plus_le_iff: "Plus r s ≤ t ⟷ r ≤ t ∧ s ≤ t" unfolding less_eq_language_def by (metis Plus_assoc Plus_idem_assoc Plus_rotate) lemma Plus_Times_pre_cong_mono: "L' ≤ L ⟹ K ≤ K' ⟹ Plus_Times_pre_cong R L K ⟹ Plus_Times_pre_cong R L' K'" by (metis pre_Trans pre_Less) theorem ardenL: "Plus r (Times s x) ≤ x ⟹ Times (Star s) r ≤ x" proof (coinduction arbitrary: r s x) case Lang then show ?case by (subst Plus_Times_pre_cong_mono[OF order_refl 𝔡_mono[OF Lang]]) auto qed theorem ardenR: "Plus r (Times x s) ≤ x ⟹ Times r (Star s) ≤ x" proof (coinduction arbitrary: r s x) case Lang then have "Plus_Times_pre_cong (λL K. ∃r s. L = Times r (Star s) ∧ Plus r (Times K s) ≤ K) (𝔡 (Times r (Star s)) a) (𝔡 x a)" for a using 𝔡_mono[OF Lang, of a] by (auto 0 4 simp del: Times_PlusL simp: Times_PlusL[symmetric] Plus_le_iff split: if_splits) with Lang show ?case by auto qed lemma le_Star[intro!, simp]: "s ≤ Star s" by coinduction auto lemma Star_mono: "r ≤ s ⟹ Star r ≤ Star s" by coinduction auto lemma Not_antimono: "r ≤ s ⟹ Not s ≤ Not r" by (coinduction arbitrary: r s) auto lemma Not_Plus[simp]: "Not (Plus r s) = Inter (Not r) (Not s)" by (coinduction arbitrary: r s) auto lemma Not_Inter[simp]: "Not (Inter r s) = Plus (Not r) (Not s)" by (coinduction arbitrary: r s) auto lemma Inter_assoc[simp]: "Inter (Inter r s) t = Inter r (Inter s t)" by (coinduction arbitrary: r s t) auto lemma Inter_comm: "Inter r s = Inter s r" by (coinduction arbitrary: r s) auto lemma Inter_idem[simp]: "Inter r r = r" by (coinduction arbitrary: r) auto lemma Inter_ZeroL[simp]: "Inter Zero r = Zero" by (coinduction arbitrary: r) auto lemma Inter_ZeroR[simp]: "Inter r Zero = Zero" by (coinduction arbitrary: r) auto lemma Inter_FullL[simp]: "Inter Full r = r" by (coinduction arbitrary: r) auto lemma Inter_FullR[simp]: "Inter r Full = r" by (coinduction arbitrary: r) auto lemma Plus_FullL[simp]: "Plus Full r = Full" by (coinduction arbitrary: r) auto lemma Plus_FullR[simp]: "Plus r Full = Full" by (coinduction arbitrary: r) auto lemma Not_Not[simp]: "Not (Not r) = r" by (coinduction arbitrary: r) auto lemma Not_Zero[simp]: "Not Zero = Full" by coinduction simp lemma Not_Full[simp]: "Not Full = Zero" by coinduction simp lemma bisimulation: assumes "Times r s = Times s t" shows "Times (Star r) s = Times s (Star t)" proof (rule antisym[OF ardenL[OF Plus_upper[OF le_TimesL]] ardenR[OF Plus_upper[OF le_TimesR]]]) show "Times r (Times s (Star t)) ≤ Times s (Star t)" by (rule order_trans[OF _ Times_mono[OF order_refl ord_le_eq_trans[OF le_PlusR Star_unfoldL[symmetric]]]]) (simp only: assms Times_assoc[symmetric]) next show "Times (Times (Star r) s) t ≤ Times (Star r) s" by (rule order_trans[OF _ Times_mono[OF ord_le_eq_trans[OF le_PlusR Star_unfoldR[symmetric]] order_refl]]) (simp only: assms Times_assoc) qed simp_all lemma sliding: "Times (Star (Times r s)) r = Times r (Star (Times s r))" proof (rule antisym[OF ardenL[OF Plus_upper[OF le_TimesL]] ardenR[OF Plus_upper[OF le_TimesR]]]) show "Times (Times r s) (Times r (Star (Times s r))) ≤ Times r (Star (Times s r))" by (rule order_trans[OF _ Times_mono[OF order_refl ord_le_eq_trans[OF le_PlusR Star_unfoldL[symmetric]]]]) simp next show "Times (Times (Star (Times r s)) r) (Times s r) ≤ Times (Star (Times r s)) r" by (rule order_trans[OF _ Times_mono[OF ord_le_eq_trans[OF le_PlusR Star_unfoldR[symmetric]] order_refl]]) simp qed simp_all lemma denesting: "Star (Plus r s) = Times (Star r) (Star (Times s (Star r)))" proof (rule antisym[OF ord_eq_le_trans[OF Times_OneR[symmetric] ardenL[OF Plus_upper]] ardenR[OF Plus_upper[OF Star_mono[OF le_PlusL]]]]) show "Times (Plus r s) (Times (Star r) (Star (Times s (Star r)))) ≤ Times (Star r) (Star (Times s (Star r)))" (is "Times _ ?L ≤ ?R") unfolding Times_PlusL by (rule Plus_upper, metis Star_unfoldL Times_assoc Times_mono le_PlusR order_refl, metis Star_unfoldL Times_assoc 𝔬_Star le_PlusR le_TimesR order_trans) next show "Times (Star (Plus r s)) (Times s (Star r)) ≤ Star (Plus r s)" by (metis Plus_comm Star_unfoldL Times_PlusR Times_assoc ardenR bisimulation le_PlusR) qed simp text ‹ It is useful to lift binary operators @{term Plus} and @{term Times} to $n$-ary operators (that take a list as input). › definition PLUS :: "'a language list ⇒ 'a language" where "PLUS xs ≡ foldr Plus xs Zero" lemma 𝔬_foldr_Plus: "𝔬 (foldr Plus xs s) = (∃x∈set (s # xs). 𝔬 x)" by (induct xs arbitrary: s) auto lemma 𝔡_foldr_Plus: "𝔡 (foldr Plus xs s) a = foldr Plus (map (λr. 𝔡 r a) xs) (𝔡 s a)" by (induct xs arbitrary: s) simp_all lemma 𝔬_PLUS[simp]: "𝔬 (PLUS xs) = (∃x∈set xs. 𝔬 x)" unfolding PLUS_def 𝔬_foldr_Plus by simp lemma 𝔡_PLUS[simp]: "𝔡 (PLUS xs) a = PLUS (map (λr. 𝔡 r a) xs)" unfolding PLUS_def 𝔡_foldr_Plus by simp definition TIMES :: "'a language list ⇒ 'a language" where "TIMES xs ≡ foldr Times xs One" lemma 𝔬_foldr_Times: "𝔬 (foldr Times xs s) = (∀x∈set (s # xs). 𝔬 x)" by (induct xs) (auto simp: PLUS_def) primrec tails where "tails [] = [[]]" | "tails (x # xs) = (x # xs) # tails xs" lemma tails_snoc[simp]: "tails (xs @ [x]) = map (λys. ys @ [x]) (tails xs) @ [[]]" by (induct xs) auto lemma length_tails[simp]: "length (tails xs) = Suc (length xs)" by (induct xs) auto lemma 𝔡_foldr_Times: "𝔡 (foldr Times xs s) a = (let n = length (takeWhile 𝔬 xs) in PLUS (map (λzs. TIMES (𝔡 (hd zs) a # tl zs)) (take (Suc n) (tails (xs @ [s])))))" by (induct xs) (auto simp: TIMES_def PLUS_def Let_def foldr_map o_def) lemma 𝔬_TIMES[simp]: "𝔬 (TIMES xs) = (∀x∈set xs. 𝔬 x)" unfolding TIMES_def 𝔬_foldr_Times by simp lemma TIMES_snoc_One[simp]: "TIMES (xs @ [One]) = TIMES xs" by (induct xs) (auto simp: TIMES_def) lemma 𝔡_TIMES[simp]: "𝔡 (TIMES xs) a = (let n = length (takeWhile 𝔬 xs) in PLUS (map (λzs. TIMES (𝔡 (hd zs) a # tl zs)) (take (Suc n) (tails (xs @ [One])))))" unfolding TIMES_def 𝔡_foldr_Times by simp section ‹Word-theoretic Semantics of Languages› text ‹ We show our @{type language} codatatype being isomorphic to the standard language representation as a set of lists. › primrec in_language :: "'a language ⇒ 'a list ⇒ bool" where "in_language L [] = 𝔬 L" | "in_language L (x # xs) = in_language (𝔡 L x) xs" primcorec to_language :: "'a list set ⇒ 'a language" where "𝔬 (to_language L) = ([] ∈ L)" | "𝔡 (to_language L) = (λa. to_language {w. a # w ∈ L})" lemma in_language_to_language[simp]: "Collect (in_language (to_language L)) = L" proof (rule set_eqI, unfold mem_Collect_eq) fix w show "in_language (to_language L) w = (w ∈ L)" by (induct w arbitrary: L) auto qed lemma to_language_in_language[simp]: "to_language (Collect (in_language L)) = L" by (coinduction arbitrary: L) auto lemma in_language_bij: "bij (Collect o in_language)" proof (rule bijI', unfold o_apply, safe) fix L R :: "'a language" assume "Collect (in_language L) = Collect (in_language R)" then show "L = R" unfolding set_eq_iff mem_Collect_eq by (coinduction arbitrary: L R) (metis in_language.simps) next fix L :: "'a list set" have "L = Collect (in_language (to_language L))" by simp then show "∃K. L = Collect (in_language K)" by blast qed lemma to_language_bij: "bij to_language" by (rule o_bij[of "Collect o in_language"]) (simp_all add: fun_eq_iff) (*<*) hide_const (open) TimesLR Times_Plus StarLR ShuffleLR end (*>*)