diff --git a/thys/LTL/Equivalence_Relations.thy b/thys/LTL/Equivalence_Relations.thy
--- a/thys/LTL/Equivalence_Relations.thy
+++ b/thys/LTL/Equivalence_Relations.thy
@@ -1,567 +1,561 @@
 (*
     Author:   Benedikt Seidl
     License:  BSD
 *)
 
 section \<open>Equivalence Relations for LTL formulas\<close>
 
 theory Equivalence_Relations
 imports
   LTL
 begin
 
 subsection \<open>Language Equivalence\<close>
 
 definition ltl_lang_equiv :: "'a ltln \<Rightarrow> 'a ltln \<Rightarrow> bool" (infix "\<sim>\<^sub>L" 75)
 where
   "\<phi> \<sim>\<^sub>L \<psi> \<equiv> \<forall>w. w \<Turnstile>\<^sub>n \<phi> \<longleftrightarrow> w \<Turnstile>\<^sub>n \<psi>"
 
 lemma ltl_lang_equiv_equivp:
   "equivp (\<sim>\<^sub>L)"
   unfolding ltl_lang_equiv_def
   by (simp add: equivpI reflp_def symp_def transp_def)
 
 lemma ltl_lang_equiv_and_true[simp]:
   "\<phi>\<^sub>1 and\<^sub>n \<phi>\<^sub>2 \<sim>\<^sub>L true\<^sub>n \<longleftrightarrow> \<phi>\<^sub>1 \<sim>\<^sub>L true\<^sub>n \<and> \<phi>\<^sub>2 \<sim>\<^sub>L true\<^sub>n"
   unfolding ltl_lang_equiv_def by auto
 
 lemma ltl_lang_equiv_and_false[intro, simp]:
   "\<phi>\<^sub>1 \<sim>\<^sub>L false\<^sub>n \<Longrightarrow> \<phi>\<^sub>1 and\<^sub>n \<phi>\<^sub>2 \<sim>\<^sub>L false\<^sub>n"
   "\<phi>\<^sub>2 \<sim>\<^sub>L false\<^sub>n \<Longrightarrow> \<phi>\<^sub>1 and\<^sub>n \<phi>\<^sub>2 \<sim>\<^sub>L false\<^sub>n"
   unfolding ltl_lang_equiv_def by auto
 
 lemma ltl_lang_equiv_or_false[simp]:
   "\<phi>\<^sub>1 or\<^sub>n \<phi>\<^sub>2 \<sim>\<^sub>L false\<^sub>n \<longleftrightarrow> \<phi>\<^sub>1 \<sim>\<^sub>L false\<^sub>n \<and> \<phi>\<^sub>2 \<sim>\<^sub>L false\<^sub>n"
   unfolding ltl_lang_equiv_def by auto
 
 lemma ltl_lang_equiv_or_const[intro, simp]:
   "\<phi>\<^sub>1 \<sim>\<^sub>L true\<^sub>n \<Longrightarrow> \<phi>\<^sub>1 or\<^sub>n \<phi>\<^sub>2 \<sim>\<^sub>L true\<^sub>n"
   "\<phi>\<^sub>2 \<sim>\<^sub>L true\<^sub>n \<Longrightarrow> \<phi>\<^sub>1 or\<^sub>n \<phi>\<^sub>2 \<sim>\<^sub>L true\<^sub>n"
   unfolding ltl_lang_equiv_def by auto
 
 
-
 subsection \<open>Propositional Equivalence\<close>
 
 fun ltl_prop_entailment :: "'a ltln set \<Rightarrow> 'a ltln \<Rightarrow> bool" (infix "\<Turnstile>\<^sub>P" 80)
 where
   "\<A> \<Turnstile>\<^sub>P true\<^sub>n = True"
 | "\<A> \<Turnstile>\<^sub>P false\<^sub>n = False"
 | "\<A> \<Turnstile>\<^sub>P \<phi> and\<^sub>n \<psi> = (\<A> \<Turnstile>\<^sub>P \<phi> \<and> \<A> \<Turnstile>\<^sub>P \<psi>)"
 | "\<A> \<Turnstile>\<^sub>P \<phi> or\<^sub>n \<psi> = (\<A> \<Turnstile>\<^sub>P \<phi> \<or> \<A> \<Turnstile>\<^sub>P \<psi>)"
 | "\<A> \<Turnstile>\<^sub>P \<phi> = (\<phi> \<in> \<A>)"
 
 lemma ltl_prop_entailment_monotonI[intro]:
   "S \<Turnstile>\<^sub>P \<phi> \<Longrightarrow> S \<subseteq> S' \<Longrightarrow> S' \<Turnstile>\<^sub>P \<phi>"
   by (induction \<phi>) auto
 
 lemma ltl_models_equiv_prop_entailment:
   "w \<Turnstile>\<^sub>n \<phi> \<longleftrightarrow> {\<psi>. w \<Turnstile>\<^sub>n \<psi>} \<Turnstile>\<^sub>P \<phi>"
   by (induction \<phi>) auto
 
-
 definition ltl_prop_equiv :: "'a ltln \<Rightarrow> 'a ltln \<Rightarrow> bool" (infix "\<sim>\<^sub>P" 75)
 where
   "\<phi> \<sim>\<^sub>P \<psi> \<equiv> \<forall>\<A>. \<A> \<Turnstile>\<^sub>P \<phi> \<longleftrightarrow> \<A> \<Turnstile>\<^sub>P \<psi>"
 
 definition ltl_prop_implies :: "'a ltln \<Rightarrow> 'a ltln \<Rightarrow> bool" (infix "\<longrightarrow>\<^sub>P" 75)
 where
   "\<phi> \<longrightarrow>\<^sub>P \<psi> \<equiv> \<forall>\<A>. \<A> \<Turnstile>\<^sub>P \<phi> \<longrightarrow> \<A> \<Turnstile>\<^sub>P \<psi>"
 
 lemma ltl_prop_implies_equiv:
   "\<phi> \<sim>\<^sub>P \<psi> \<longleftrightarrow> (\<phi> \<longrightarrow>\<^sub>P \<psi> \<and> \<psi> \<longrightarrow>\<^sub>P \<phi>)"
   unfolding ltl_prop_equiv_def ltl_prop_implies_def by meson
 
 lemma ltl_prop_equiv_equivp:
   "equivp (\<sim>\<^sub>P)"
   by (simp add: ltl_prop_equiv_def equivpI reflp_def symp_def transp_def)
 
 lemma ltl_prop_equiv_trans[trans]:
   "\<phi> \<sim>\<^sub>P \<psi> \<Longrightarrow> \<psi> \<sim>\<^sub>P \<chi> \<Longrightarrow> \<phi> \<sim>\<^sub>P \<chi>"
   by (simp add: ltl_prop_equiv_def)
 
 lemma ltl_prop_equiv_true:
   "\<phi> \<sim>\<^sub>P true\<^sub>n \<longleftrightarrow> {} \<Turnstile>\<^sub>P \<phi>"
   using bot.extremum ltl_prop_entailment.simps(1) ltl_prop_equiv_def by blast
 
 lemma ltl_prop_equiv_false:
   "\<phi> \<sim>\<^sub>P false\<^sub>n \<longleftrightarrow> \<not> UNIV \<Turnstile>\<^sub>P \<phi>"
   by (meson ltl_prop_entailment.simps(2) ltl_prop_entailment_monotonI ltl_prop_equiv_def top_greatest)
 
 lemma ltl_prop_equiv_true_implies_true:
   "x \<sim>\<^sub>P true\<^sub>n \<Longrightarrow> x \<longrightarrow>\<^sub>P y \<Longrightarrow> y \<sim>\<^sub>P true\<^sub>n"
   by (simp add: ltl_prop_equiv_def ltl_prop_implies_def)
 
 lemma ltl_prop_equiv_false_implied_by_false:
   "y \<sim>\<^sub>P false\<^sub>n \<Longrightarrow> x \<longrightarrow>\<^sub>P y \<Longrightarrow> x \<sim>\<^sub>P false\<^sub>n"
   by (simp add: ltl_prop_equiv_def ltl_prop_implies_def)
 
 lemma ltl_prop_implication_implies_ltl_implication:
   "w \<Turnstile>\<^sub>n \<phi> \<Longrightarrow> \<phi> \<longrightarrow>\<^sub>P \<psi> \<Longrightarrow> w \<Turnstile>\<^sub>n \<psi>"
   using ltl_models_equiv_prop_entailment ltl_prop_implies_def by blast
 
 lemma ltl_prop_equiv_implies_ltl_lang_equiv:
   "\<phi> \<sim>\<^sub>P \<psi> \<Longrightarrow> \<phi> \<sim>\<^sub>L \<psi>"
   using ltl_lang_equiv_def ltl_prop_implication_implies_ltl_implication ltl_prop_implies_equiv by blast
 
 lemma ltl_prop_equiv_lt_ltl_lang_equiv[simp]:
   "(\<sim>\<^sub>P) \<le> (\<sim>\<^sub>L)"
   using ltl_prop_equiv_implies_ltl_lang_equiv by blast
 
 
-
 subsection \<open>Constants Equivalence\<close>
 
 datatype tvl = Yes | No | Maybe
 
 definition eval_and :: "tvl \<Rightarrow> tvl \<Rightarrow> tvl"
 where
   "eval_and \<phi> \<psi> =
     (case (\<phi>, \<psi>) of
       (Yes, Yes) \<Rightarrow> Yes
     | (No, _) \<Rightarrow> No
     | (_, No) \<Rightarrow> No
     | _ \<Rightarrow> Maybe)"
 
 definition eval_or :: "tvl \<Rightarrow> tvl \<Rightarrow> tvl"
 where
   "eval_or \<phi> \<psi> =
     (case (\<phi>, \<psi>) of
       (No, No) \<Rightarrow> No
     | (Yes, _) \<Rightarrow> Yes
     | (_, Yes) \<Rightarrow> Yes
     | _ \<Rightarrow> Maybe)"
 
 fun eval :: "'a ltln \<Rightarrow> tvl"
 where
   "eval true\<^sub>n = Yes"
 | "eval false\<^sub>n = No"
 | "eval (\<phi> and\<^sub>n \<psi>) = eval_and (eval \<phi>) (eval \<psi>)"
 | "eval (\<phi> or\<^sub>n \<psi>) = eval_or (eval \<phi>) (eval \<psi>)"
 | "eval \<phi> = Maybe"
 
 lemma eval_and_const[simp]:
   "eval_and \<phi> \<psi> = No \<longleftrightarrow> \<phi> = No \<or> \<psi> = No"
   "eval_and \<phi> \<psi> = Yes \<longleftrightarrow> \<phi> = Yes \<and> \<psi> = Yes"
   unfolding eval_and_def
   by (cases \<phi>; cases \<psi>, auto)+
 
 lemma eval_or_const[simp]:
   "eval_or \<phi> \<psi> = Yes \<longleftrightarrow> \<phi> = Yes \<or> \<psi> = Yes"
   "eval_or \<phi> \<psi> = No \<longleftrightarrow> \<phi> = No \<and> \<psi> = No"
   unfolding eval_or_def
   by (cases \<phi>; cases \<psi>, auto)+
 
 lemma eval_prop_entailment:
   "eval \<phi> = Yes \<longleftrightarrow> {} \<Turnstile>\<^sub>P \<phi>"
   "eval \<phi> = No \<longleftrightarrow> \<not> UNIV \<Turnstile>\<^sub>P \<phi>"
   by (induction \<phi>) auto
 
-
 definition ltl_const_equiv :: "'a ltln \<Rightarrow> 'a ltln \<Rightarrow> bool" (infix "\<sim>\<^sub>C" 75)
 where
   "\<phi> \<sim>\<^sub>C \<psi> \<equiv> \<phi> = \<psi> \<or> (eval \<phi> = eval \<psi> \<and> eval \<psi> \<noteq> Maybe)"
 
 lemma ltl_const_equiv_equivp:
   "equivp (\<sim>\<^sub>C)"
   unfolding ltl_const_equiv_def
   by (intro equivpI reflpI sympI transpI) auto
 
 lemma ltl_const_equiv_const:
   "\<phi> \<sim>\<^sub>C true\<^sub>n \<longleftrightarrow> eval \<phi> = Yes"
   "\<phi> \<sim>\<^sub>C false\<^sub>n \<longleftrightarrow> eval \<phi> = No"
   unfolding ltl_const_equiv_def by force+
 
 lemma ltl_const_equiv_and_const[simp]:
   "\<phi>\<^sub>1 and\<^sub>n \<phi>\<^sub>2 \<sim>\<^sub>C true\<^sub>n \<longleftrightarrow> \<phi>\<^sub>1 \<sim>\<^sub>C true\<^sub>n \<and> \<phi>\<^sub>2 \<sim>\<^sub>C true\<^sub>n"
   "\<phi>\<^sub>1 and\<^sub>n \<phi>\<^sub>2 \<sim>\<^sub>C false\<^sub>n \<longleftrightarrow> \<phi>\<^sub>1 \<sim>\<^sub>C false\<^sub>n \<or> \<phi>\<^sub>2 \<sim>\<^sub>C false\<^sub>n"
   unfolding ltl_const_equiv_const by force+
 
 lemma ltl_const_equiv_or_const[simp]:
   "\<phi>\<^sub>1 or\<^sub>n \<phi>\<^sub>2 \<sim>\<^sub>C true\<^sub>n \<longleftrightarrow> \<phi>\<^sub>1 \<sim>\<^sub>C true\<^sub>n \<or> \<phi>\<^sub>2 \<sim>\<^sub>C true\<^sub>n"
   "\<phi>\<^sub>1 or\<^sub>n \<phi>\<^sub>2 \<sim>\<^sub>C false\<^sub>n \<longleftrightarrow> \<phi>\<^sub>1 \<sim>\<^sub>C false\<^sub>n \<and> \<phi>\<^sub>2 \<sim>\<^sub>C false\<^sub>n"
   unfolding ltl_const_equiv_const by force+
 
 lemma ltl_const_equiv_other[simp]:
   "\<phi> \<sim>\<^sub>C prop\<^sub>n(a) \<longleftrightarrow> \<phi> = prop\<^sub>n(a)"
   "\<phi> \<sim>\<^sub>C nprop\<^sub>n(a) \<longleftrightarrow> \<phi> = nprop\<^sub>n(a)"
   "\<phi> \<sim>\<^sub>C X\<^sub>n \<psi> \<longleftrightarrow> \<phi> = X\<^sub>n \<psi>"
   "\<phi> \<sim>\<^sub>C \<psi>\<^sub>1 U\<^sub>n \<psi>\<^sub>2 \<longleftrightarrow> \<phi> = \<psi>\<^sub>1 U\<^sub>n \<psi>\<^sub>2"
   "\<phi> \<sim>\<^sub>C \<psi>\<^sub>1 R\<^sub>n \<psi>\<^sub>2 \<longleftrightarrow> \<phi> = \<psi>\<^sub>1 R\<^sub>n \<psi>\<^sub>2"
   "\<phi> \<sim>\<^sub>C \<psi>\<^sub>1 W\<^sub>n \<psi>\<^sub>2 \<longleftrightarrow> \<phi> = \<psi>\<^sub>1 W\<^sub>n \<psi>\<^sub>2"
   "\<phi> \<sim>\<^sub>C \<psi>\<^sub>1 M\<^sub>n \<psi>\<^sub>2 \<longleftrightarrow> \<phi> = \<psi>\<^sub>1 M\<^sub>n \<psi>\<^sub>2"
   using ltl_const_equiv_def by fastforce+
 
 lemma ltl_const_equiv_no_const_singleton:
   "eval \<psi> = Maybe \<Longrightarrow> \<phi> \<sim>\<^sub>C \<psi> \<Longrightarrow> \<phi> = \<psi>"
   unfolding ltl_const_equiv_def by fastforce
 
-
 lemma ltl_const_equiv_implies_prop_equiv:
   "\<phi> \<sim>\<^sub>C true\<^sub>n \<longleftrightarrow> \<phi> \<sim>\<^sub>P true\<^sub>n"
   "\<phi> \<sim>\<^sub>C false\<^sub>n \<longleftrightarrow> \<phi> \<sim>\<^sub>P false\<^sub>n"
   unfolding ltl_const_equiv_const eval_prop_entailment ltl_prop_equiv_def
   by auto
 
 lemma ltl_const_equiv_no_const_prop_equiv:
   "eval \<psi> = Maybe \<Longrightarrow> \<phi> \<sim>\<^sub>C \<psi> \<Longrightarrow> \<phi> \<sim>\<^sub>P \<psi>"
   using ltl_const_equiv_no_const_singleton equivp_reflp[OF ltl_prop_equiv_equivp]
   by blast
 
 lemma ltl_const_equiv_implies_ltl_prop_equiv:
   "\<phi> \<sim>\<^sub>C \<psi> \<Longrightarrow> \<phi> \<sim>\<^sub>P \<psi>"
 proof (induction \<psi>)
   case (And_ltln \<psi>1 \<psi>2)
 
   show ?case
   proof (cases "eval (\<psi>1 and\<^sub>n \<psi>2)")
     case Yes
 
     then have "\<phi> \<sim>\<^sub>C true\<^sub>n"
       by (meson And_ltln.prems equivp_transp ltl_const_equiv_const(1) ltl_const_equiv_equivp)
     then show ?thesis
       by (metis (full_types) Yes ltl_const_equiv_const(1) ltl_const_equiv_implies_prop_equiv(1) ltl_prop_equiv_trans ltl_prop_implies_equiv)
   next
     case No
 
     then have "\<phi> \<sim>\<^sub>C false\<^sub>n"
       by (meson And_ltln.prems equivp_transp ltl_const_equiv_const(2) ltl_const_equiv_equivp)
     then show ?thesis
       by (metis (full_types) No ltl_const_equiv_const(2) ltl_const_equiv_implies_prop_equiv(2) ltl_prop_equiv_trans ltl_prop_implies_equiv)
   next
     case Maybe
 
     then show ?thesis
       using And_ltln.prems ltl_const_equiv_no_const_prop_equiv by force
   qed
 next
   case (Or_ltln \<psi>1 \<psi>2)
 
   then show ?case
   proof (cases "eval (\<psi>1 or\<^sub>n \<psi>2)")
     case Yes
 
     then have "\<phi> \<sim>\<^sub>C true\<^sub>n"
       by (meson Or_ltln.prems equivp_transp ltl_const_equiv_const(1) ltl_const_equiv_equivp)
     then show ?thesis
       by (metis (full_types) Yes ltl_const_equiv_const(1) ltl_const_equiv_implies_prop_equiv(1) ltl_prop_equiv_trans ltl_prop_implies_equiv)
   next
     case No
 
     then have "\<phi> \<sim>\<^sub>C false\<^sub>n"
       by (meson Or_ltln.prems equivp_transp ltl_const_equiv_const(2) ltl_const_equiv_equivp)
     then show ?thesis
       by (metis (full_types) No ltl_const_equiv_const(2) ltl_const_equiv_implies_prop_equiv(2) ltl_prop_equiv_trans ltl_prop_implies_equiv)
   next
     case Maybe
 
     then show ?thesis
       using Or_ltln.prems ltl_const_equiv_no_const_prop_equiv by force
   qed
 qed (simp_all add: ltl_const_equiv_implies_prop_equiv equivp_reflp[OF ltl_prop_equiv_equivp])
 
 lemma ltl_const_equiv_lt_ltl_prop_equiv[simp]:
   "(\<sim>\<^sub>C) \<le> (\<sim>\<^sub>P)"
   using ltl_const_equiv_implies_ltl_prop_equiv by blast
 
 
-
 subsection \<open>Quotient types\<close>
 
 quotient_type 'a ltln\<^sub>L = "'a ltln" / "(\<sim>\<^sub>L)"
   by (rule ltl_lang_equiv_equivp)
 
 instantiation ltln\<^sub>L :: (type) equal
 begin
 
 lift_definition ltln\<^sub>L_eq_test :: "'a ltln\<^sub>L \<Rightarrow> 'a ltln\<^sub>L \<Rightarrow> bool" is "\<lambda>x y. x \<sim>\<^sub>L y"
   by (metis ltln\<^sub>L.abs_eq_iff)
 
 definition
   eq\<^sub>L: "equal_class.equal \<equiv> ltln\<^sub>L_eq_test"
 
 instance
   by (standard; simp add: eq\<^sub>L ltln\<^sub>L_eq_test.rep_eq, metis Quotient_ltln\<^sub>L Quotient_rel_rep)
 
 end
 
 
 quotient_type 'a ltln\<^sub>P = "'a ltln" / "(\<sim>\<^sub>P)"
   by (rule ltl_prop_equiv_equivp)
 
 instantiation ltln\<^sub>P :: (type) equal
 begin
 
 lift_definition ltln\<^sub>P_eq_test :: "'a ltln\<^sub>P \<Rightarrow> 'a ltln\<^sub>P \<Rightarrow> bool" is "\<lambda>x y. x \<sim>\<^sub>P y"
   by (metis ltln\<^sub>P.abs_eq_iff)
 
 definition
   eq\<^sub>P: "equal_class.equal \<equiv> ltln\<^sub>P_eq_test"
 
 instance
   by (standard; simp add: eq\<^sub>P ltln\<^sub>P_eq_test.rep_eq, metis Quotient_ltln\<^sub>P Quotient_rel_rep)
 
 end
 
 
 quotient_type 'a ltln\<^sub>C = "'a ltln" / "(\<sim>\<^sub>C)"
   by (rule ltl_const_equiv_equivp)
 
 instantiation ltln\<^sub>C :: (type) equal
 begin
 
 lift_definition ltln\<^sub>C_eq_test :: "'a ltln\<^sub>C \<Rightarrow> 'a ltln\<^sub>C \<Rightarrow> bool" is "\<lambda>x y. x \<sim>\<^sub>C y"
   by (metis ltln\<^sub>C.abs_eq_iff)
 
 definition
   eq\<^sub>C: "equal_class.equal \<equiv> ltln\<^sub>C_eq_test"
 
 instance
   by (standard; simp add: eq\<^sub>C ltln\<^sub>C_eq_test.rep_eq, metis Quotient_ltln\<^sub>C Quotient_rel_rep)
 
 end
 
 
 
 subsection \<open>Cardinality of propositional quotient sets\<close>
 
 definition sat_models :: "'a ltln\<^sub>P \<Rightarrow> 'a ltln set set"
 where
   "sat_models \<phi> = {\<A>. \<A> \<Turnstile>\<^sub>P rep_ltln\<^sub>P \<phi>}"
 
 lemma Rep_Abs_prop_entailment[simp]:
   "\<A> \<Turnstile>\<^sub>P rep_ltln\<^sub>P (abs_ltln\<^sub>P \<phi>) = \<A> \<Turnstile>\<^sub>P \<phi>"
   by (metis Quotient3_ltln\<^sub>P Quotient3_rep_abs ltl_prop_equiv_def)
 
 lemma sat_models_Abs:
   "\<A> \<in> sat_models (abs_ltln\<^sub>P \<phi>) = \<A> \<Turnstile>\<^sub>P \<phi>"
   by (simp add: sat_models_def)
 
 lemma sat_models_inj:
   "inj sat_models"
 proof (rule injI)
   fix \<phi> \<psi> :: "'a ltln\<^sub>P"
   assume "sat_models \<phi> = sat_models \<psi>"
 
   then have "rep_ltln\<^sub>P \<phi> \<sim>\<^sub>P rep_ltln\<^sub>P \<psi>"
     unfolding sat_models_def ltl_prop_equiv_def by force
 
   then show "\<phi> = \<psi>"
     by (meson Quotient3_ltln\<^sub>P Quotient3_rel_rep)
 qed
 
 
 fun prop_atoms :: "'a ltln \<Rightarrow> 'a ltln set"
 where
   "prop_atoms true\<^sub>n = {}"
 | "prop_atoms false\<^sub>n = {}"
 | "prop_atoms (\<phi> and\<^sub>n \<psi>) = prop_atoms \<phi> \<union> prop_atoms \<psi>"
 | "prop_atoms (\<phi> or\<^sub>n \<psi>) = prop_atoms \<phi> \<union> prop_atoms \<psi>"
 | "prop_atoms \<phi> = {\<phi>}"
 
 fun nested_prop_atoms :: "'a ltln \<Rightarrow> 'a ltln set"
 where
   "nested_prop_atoms true\<^sub>n = {}"
 | "nested_prop_atoms false\<^sub>n = {}"
 | "nested_prop_atoms (\<phi> and\<^sub>n \<psi>) = nested_prop_atoms \<phi> \<union> nested_prop_atoms \<psi>"
 | "nested_prop_atoms (\<phi> or\<^sub>n \<psi>) = nested_prop_atoms \<phi> \<union> nested_prop_atoms \<psi>"
 | "nested_prop_atoms (X\<^sub>n \<phi>) = {X\<^sub>n \<phi>} \<union> nested_prop_atoms \<phi>"
 | "nested_prop_atoms (\<phi> U\<^sub>n \<psi>) = {\<phi> U\<^sub>n \<psi>} \<union> nested_prop_atoms \<phi> \<union> nested_prop_atoms \<psi>"
 | "nested_prop_atoms (\<phi> R\<^sub>n \<psi>) = {\<phi> R\<^sub>n \<psi>} \<union> nested_prop_atoms \<phi> \<union> nested_prop_atoms \<psi>"
 | "nested_prop_atoms (\<phi> W\<^sub>n \<psi>) = {\<phi> W\<^sub>n \<psi>} \<union> nested_prop_atoms \<phi> \<union> nested_prop_atoms \<psi>"
 | "nested_prop_atoms (\<phi> M\<^sub>n \<psi>) = {\<phi> M\<^sub>n \<psi>} \<union> nested_prop_atoms \<phi> \<union> nested_prop_atoms \<psi>"
 | "nested_prop_atoms \<phi> = {\<phi>}"
 
 lemma prop_atoms_nested_prop_atoms:
   "prop_atoms \<phi> \<subseteq> nested_prop_atoms \<phi>"
   by (induction \<phi>) auto
 
 lemma prop_atoms_subfrmlsn:
   "prop_atoms \<phi> \<subseteq> subfrmlsn \<phi>"
   by (induction \<phi>) auto
 
 lemma nested_prop_atoms_subfrmlsn:
   "nested_prop_atoms \<phi> \<subseteq> subfrmlsn \<phi>"
   by (induction \<phi>) auto
 
 lemma prop_atoms_notin[simp]:
   "true\<^sub>n \<notin> prop_atoms \<phi>"
   "false\<^sub>n \<notin> prop_atoms \<phi>"
   "\<phi>\<^sub>1 and\<^sub>n \<phi>\<^sub>2 \<notin> prop_atoms \<phi>"
   "\<phi>\<^sub>1 or\<^sub>n \<phi>\<^sub>2 \<notin> prop_atoms \<phi>"
   by (induction \<phi>) auto
 
 lemma nested_prop_atoms_notin[simp]:
   "true\<^sub>n \<notin> nested_prop_atoms \<phi>"
   "false\<^sub>n \<notin> nested_prop_atoms \<phi>"
   "\<phi>\<^sub>1 and\<^sub>n \<phi>\<^sub>2 \<notin> nested_prop_atoms \<phi>"
   "\<phi>\<^sub>1 or\<^sub>n \<phi>\<^sub>2 \<notin> nested_prop_atoms \<phi>"
   by (induction \<phi>) auto
 
 lemma prop_atoms_finite:
   "finite (prop_atoms \<phi>)"
   by (induction \<phi>) auto
 
 lemma nested_prop_atoms_finite:
   "finite (nested_prop_atoms \<phi>)"
   by (induction \<phi>) auto
 
 lemma prop_atoms_entailment_iff:
   "\<phi> \<in> prop_atoms \<psi> \<Longrightarrow> \<A> \<Turnstile>\<^sub>P \<phi> \<longleftrightarrow> \<phi> \<in> \<A>"
   by (induction \<phi>) auto
 
 lemma prop_atoms_entailment_inter:
   "prop_atoms \<phi> \<subseteq> P \<Longrightarrow> (\<A> \<inter> P) \<Turnstile>\<^sub>P \<phi> = \<A> \<Turnstile>\<^sub>P \<phi>"
   by (induction \<phi>) auto
 
 lemma nested_prop_atoms_entailment_inter:
   "nested_prop_atoms \<phi> \<subseteq> P \<Longrightarrow> (\<A> \<inter> P) \<Turnstile>\<^sub>P \<phi> = \<A> \<Turnstile>\<^sub>P \<phi>"
   by (induction \<phi>) auto
 
 lemma sat_models_inter_inj_helper:
   assumes
     "prop_atoms \<phi> \<subseteq> P"
   and
     "prop_atoms \<psi> \<subseteq> P"
   and
     "sat_models (abs_ltln\<^sub>P \<phi>) \<inter> Pow P = sat_models (abs_ltln\<^sub>P \<psi>) \<inter> Pow P"
   shows
     "\<phi> \<sim>\<^sub>P \<psi>"
 proof -
   from assms have "\<forall>\<A>. (\<A> \<inter> P) \<Turnstile>\<^sub>P \<phi> \<longleftrightarrow> (\<A> \<inter> P) \<Turnstile>\<^sub>P \<psi>"
     by (auto simp: sat_models_Abs)
 
   with assms show "\<phi> \<sim>\<^sub>P \<psi>"
     by (simp add: prop_atoms_entailment_inter ltl_prop_equiv_def)
 qed
 
 lemma sat_models_inter_inj:
   "inj_on (\<lambda>\<phi>. sat_models \<phi> \<inter> Pow P) {abs_ltln\<^sub>P \<phi> |\<phi>. prop_atoms \<phi> \<subseteq> P}"
   by (auto simp: inj_on_def sat_models_inter_inj_helper ltln\<^sub>P.abs_eq_iff)
 
 lemma sat_models_pow_pow:
   "{sat_models (abs_ltln\<^sub>P \<phi>) \<inter> Pow P | \<phi>. prop_atoms \<phi> \<subseteq> P} \<subseteq> Pow (Pow P)"
   by (auto simp: sat_models_def)
 
 lemma sat_models_finite:
   "finite P \<Longrightarrow> finite {sat_models (abs_ltln\<^sub>P \<phi>) \<inter> Pow P | \<phi>. prop_atoms \<phi> \<subseteq> P}"
   using sat_models_pow_pow finite_subset by fastforce
 
 lemma sat_models_card:
   "finite P \<Longrightarrow> card ({sat_models (abs_ltln\<^sub>P \<phi>) \<inter> Pow P | \<phi>. prop_atoms \<phi> \<subseteq> P}) \<le> 2 ^ 2 ^ card P"
   by (metis (mono_tags, lifting) sat_models_pow_pow Pow_def card_Pow card_mono finite_Collect_subsets)
 
 
 lemma image_filter:
   "f ` {g a | a. P a} = {f (g a) | a. P a}"
   by blast
 
 lemma prop_equiv_finite:
   "finite P \<Longrightarrow> finite {abs_ltln\<^sub>P \<psi> | \<psi>. prop_atoms \<psi> \<subseteq> P}"
   by (auto simp: image_filter sat_models_finite finite_imageD[OF _ sat_models_inter_inj])
 
 lemma prop_equiv_card:
   "finite P \<Longrightarrow> card {abs_ltln\<^sub>P \<psi> | \<psi>. prop_atoms \<psi> \<subseteq> P} \<le> 2 ^ 2 ^ card P"
   by (auto simp: image_filter sat_models_card card_image[OF sat_models_inter_inj, symmetric])
 
 
 lemma prop_equiv_subset:
   "{abs_ltln\<^sub>P \<psi> |\<psi>. nested_prop_atoms \<psi> \<subseteq> P} \<subseteq> {abs_ltln\<^sub>P \<psi> |\<psi>. prop_atoms \<psi> \<subseteq> P}"
   using prop_atoms_nested_prop_atoms by blast
 
 lemma prop_equiv_finite':
   "finite P \<Longrightarrow> finite {abs_ltln\<^sub>P \<psi> | \<psi>. nested_prop_atoms \<psi> \<subseteq> P}"
   using prop_equiv_finite prop_equiv_subset finite_subset by fast
 
 lemma prop_equiv_card':
   "finite P \<Longrightarrow> card {abs_ltln\<^sub>P \<psi> | \<psi>. nested_prop_atoms \<psi> \<subseteq> P} \<le> 2 ^ 2 ^ card P"
   by (metis (mono_tags, lifting) prop_equiv_card prop_equiv_subset prop_equiv_finite card_mono le_trans)
 
 
 
 subsection \<open>Substitution\<close>
 
 fun subst :: "'a ltln \<Rightarrow> ('a ltln \<rightharpoonup> 'a ltln) \<Rightarrow> 'a ltln"
 where
   "subst true\<^sub>n m = true\<^sub>n"
 | "subst false\<^sub>n m = false\<^sub>n"
 | "subst (\<phi> and\<^sub>n \<psi>) m = subst \<phi> m and\<^sub>n subst \<psi> m"
 | "subst (\<phi> or\<^sub>n \<psi>) m = subst \<phi> m or\<^sub>n subst \<psi> m"
 | "subst \<phi> m = (case m \<phi> of Some \<psi> \<Rightarrow> \<psi> | None \<Rightarrow> \<phi>)"
 
 text \<open>Based on Uwe Schoening's Translation Lemma (Logic for CS, p. 54)\<close>
 
 lemma ltl_prop_equiv_subst_S:
   "S \<Turnstile>\<^sub>P subst \<phi> m = ((S - dom m) \<union> {\<chi> | \<chi> \<chi>'. \<chi> \<in> dom m \<and> m \<chi> = Some \<chi>' \<and> S \<Turnstile>\<^sub>P \<chi>'}) \<Turnstile>\<^sub>P \<phi>"
   by (induction \<phi>) (auto split: option.split)
 
 lemma subst_respects_ltl_prop_entailment:
   "\<phi> \<longrightarrow>\<^sub>P \<psi> \<Longrightarrow> subst \<phi> m \<longrightarrow>\<^sub>P subst \<psi> m"
   "\<phi> \<sim>\<^sub>P \<psi> \<Longrightarrow> subst \<phi> m \<sim>\<^sub>P subst \<psi> m"
   unfolding ltl_prop_equiv_def ltl_prop_implies_def ltl_prop_equiv_subst_S by blast+
 
 
 lemma eval_subst:
   "eval \<phi> = Yes \<Longrightarrow> eval (subst \<phi> m) = Yes"
   "eval \<phi> = No \<Longrightarrow> eval (subst \<phi> m) = No"
   by (meson empty_subsetI eval_prop_entailment ltl_prop_entailment_monotonI ltl_prop_equiv_subst_S subset_UNIV)+
 
 lemma subst_respects_ltl_const_entailment:
   "\<phi> \<sim>\<^sub>C \<psi> \<Longrightarrow> subst \<phi> m \<sim>\<^sub>C subst \<psi> m"
   unfolding ltl_const_equiv_def
   by (cases "eval \<psi>") (metis eval_subst(1), metis eval_subst(2), blast)
 
 
 
 subsection \<open>Order of Equivalence Relations\<close>
 
 locale ltl_equivalence =
   fixes
     eq :: "'a ltln \<Rightarrow> 'a ltln \<Rightarrow> bool" (infix "\<sim>" 75)
   assumes
     eq_equivp: "equivp (\<sim>)"
   and
     ge_const_equiv: "(\<sim>\<^sub>C) \<le> (\<sim>)"
   and
     le_lang_equiv: "(\<sim>) \<le> (\<sim>\<^sub>L)"
 begin
 
 lemma eq_implies_ltl_equiv:
   "\<phi> \<sim> \<psi> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> = w \<Turnstile>\<^sub>n \<psi>"
   using le_lang_equiv ltl_lang_equiv_def by blast
 
 lemma const_implies_eq:
   "\<phi> \<sim>\<^sub>C \<psi> \<Longrightarrow> \<phi> \<sim> \<psi>"
   using ge_const_equiv by blast
 
 lemma eq_implies_lang:
   "\<phi> \<sim> \<psi> \<Longrightarrow> \<phi> \<sim>\<^sub>L \<psi>"
   using le_lang_equiv by blast
 
 lemma eq_refl[simp]:
   "\<phi> \<sim> \<phi>"
   by (meson eq_equivp equivp_reflp)
 
 lemma eq_sym[sym]:
   "\<phi> \<sim> \<psi> \<Longrightarrow> \<psi> \<sim> \<phi>"
   by (meson eq_equivp equivp_symp)
 
 lemma eq_trans[trans]:
   "\<phi> \<sim> \<psi> \<Longrightarrow> \<psi> \<sim> \<chi> \<Longrightarrow> \<phi> \<sim> \<chi>"
   by (meson eq_equivp equivp_transp)
 
 end
 
 interpretation ltl_lang_equivalence: ltl_equivalence "(\<sim>\<^sub>L)"
   using ltl_lang_equiv_equivp ltl_const_equiv_lt_ltl_prop_equiv ltl_prop_equiv_lt_ltl_lang_equiv
   by unfold_locales blast+
 
 interpretation ltl_prop_equivalence: ltl_equivalence "(\<sim>\<^sub>P)"
   using ltl_prop_equiv_equivp ltl_const_equiv_lt_ltl_prop_equiv ltl_prop_equiv_lt_ltl_lang_equiv
   by unfold_locales blast+
 
 interpretation ltl_const_equivalence: ltl_equivalence "(\<sim>\<^sub>C)"
   using ltl_const_equiv_equivp ltl_const_equiv_lt_ltl_prop_equiv ltl_prop_equiv_lt_ltl_lang_equiv
   by unfold_locales blast+
 
 end
diff --git a/thys/LTL/LTL.thy b/thys/LTL/LTL.thy
--- a/thys/LTL/LTL.thy
+++ b/thys/LTL/LTL.thy
@@ -1,1185 +1,1189 @@
 (*
     Author:   Salomon Sickert
     Author:   Benedikt Seidl
     Author:   Alexander Schimpf (original entry: CAVA/LTL.thy)
     Author:   Stephan Merz (original entry: Stuttering_Equivalence/PLTL.thy)
     License:  BSD
 *)
 
 section \<open>Linear Temporal Logic\<close>
 
 theory LTL
 imports
   Main "HOL-Library.Omega_Words_Fun"
 begin
 
 text \<open>This theory provides a formalisation of linear temporal logic. It provides three variants:
     \begin{enumerate}
       \item LTL with syntactic sugar. This variant is the semantic reference and the included parser
             generates ASTs of this datatype.
       \item LTL in negation normal form without syntactic sugar. This variant is used by the included
             rewriting engine and is used for the translation to automata (implemented in other entries).
       \item LTL in restricted negation normal form without the rather uncommon operators ``weak until''
             and ``strong release''. It is used by the formalization of Gerth's algorithm.
       \item PLTL. A variant with a reduced set of operators.
     \end{enumerate}
     This theory subsumes (and partly reuses) the existing formalisation found in LTL\_to\_GBA and
     Stuttering\_Equivalence and unifies them.\<close>
 
 subsection \<open>LTL with Syntactic Sugar\<close>
 
 text \<open>In this section, we provide a formulation of LTL with explicit syntactic sugar deeply embedded.
     This formalization serves as a reference semantics.\<close>
 
 subsubsection \<open>Syntax\<close>
 
 datatype (atoms_ltlc: 'a) ltlc =
     True_ltlc                               ("true\<^sub>c")
   | False_ltlc                              ("false\<^sub>c")
   | Prop_ltlc 'a                            ("prop\<^sub>c'(_')")
   | Not_ltlc "'a ltlc"                      ("not\<^sub>c _" [85] 85)
   | And_ltlc "'a ltlc" "'a ltlc"            ("_ and\<^sub>c _" [82,82] 81)
   | Or_ltlc "'a ltlc" "'a ltlc"             ("_ or\<^sub>c _" [81,81] 80)
   | Implies_ltlc "'a ltlc" "'a ltlc"        ("_ implies\<^sub>c _" [81,81] 80)
   | Next_ltlc "'a ltlc"                     ("X\<^sub>c _" [88] 87)
   | Final_ltlc "'a ltlc"                    ("F\<^sub>c _" [88] 87)
   | Global_ltlc "'a ltlc"                   ("G\<^sub>c _" [88] 87)
   | Until_ltlc "'a ltlc" "'a ltlc"          ("_ U\<^sub>c _" [84,84] 83)
   | Release_ltlc "'a ltlc" "'a ltlc"        ("_ R\<^sub>c _" [84,84] 83)
   | WeakUntil_ltlc "'a ltlc" "'a ltlc"      ("_ W\<^sub>c _" [84,84] 83)
   | StrongRelease_ltlc "'a ltlc" "'a ltlc"  ("_ M\<^sub>c _" [84,84] 83)
 
 definition Iff_ltlc ("_ iff\<^sub>c _" [81,81] 80)
 where
   "\<phi> iff\<^sub>c \<psi> \<equiv> (\<phi> implies\<^sub>c \<psi>) and\<^sub>c (\<psi> implies\<^sub>c \<phi>)"
 
 subsubsection \<open>Semantics\<close>
 
 primrec semantics_ltlc :: "['a set word, 'a ltlc] \<Rightarrow> bool" ("_ \<Turnstile>\<^sub>c _" [80,80] 80)
 where
   "\<xi> \<Turnstile>\<^sub>c true\<^sub>c = True"
 | "\<xi> \<Turnstile>\<^sub>c false\<^sub>c = False"
 | "\<xi> \<Turnstile>\<^sub>c prop\<^sub>c(q) = (q\<in>\<xi> 0)"
 | "\<xi> \<Turnstile>\<^sub>c not\<^sub>c \<phi> = (\<not> \<xi> \<Turnstile>\<^sub>c \<phi>)"
 | "\<xi> \<Turnstile>\<^sub>c \<phi> and\<^sub>c \<psi> = (\<xi> \<Turnstile>\<^sub>c \<phi> \<and> \<xi> \<Turnstile>\<^sub>c \<psi>)"
 | "\<xi> \<Turnstile>\<^sub>c \<phi> or\<^sub>c \<psi> = (\<xi> \<Turnstile>\<^sub>c \<phi> \<or> \<xi> \<Turnstile>\<^sub>c \<psi>)"
 | "\<xi> \<Turnstile>\<^sub>c \<phi> implies\<^sub>c \<psi> = (\<xi> \<Turnstile>\<^sub>c \<phi> \<longrightarrow> \<xi> \<Turnstile>\<^sub>c \<psi>)"
 | "\<xi> \<Turnstile>\<^sub>c X\<^sub>c \<phi> = (suffix 1 \<xi> \<Turnstile>\<^sub>c \<phi>)"
 | "\<xi> \<Turnstile>\<^sub>c F\<^sub>c \<phi> = (\<exists>i. suffix i \<xi> \<Turnstile>\<^sub>c \<phi>)"
 | "\<xi> \<Turnstile>\<^sub>c G\<^sub>c \<phi> = (\<forall>i. suffix i \<xi> \<Turnstile>\<^sub>c \<phi>)"
 | "\<xi> \<Turnstile>\<^sub>c \<phi> U\<^sub>c \<psi> = (\<exists>i. suffix i \<xi> \<Turnstile>\<^sub>c \<psi> \<and> (\<forall>j<i. suffix j \<xi> \<Turnstile>\<^sub>c \<phi>))"
 | "\<xi> \<Turnstile>\<^sub>c \<phi> R\<^sub>c \<psi> = (\<forall>i. suffix i \<xi> \<Turnstile>\<^sub>c \<psi> \<or> (\<exists>j<i. suffix j \<xi> \<Turnstile>\<^sub>c \<phi>))"
 | "\<xi> \<Turnstile>\<^sub>c \<phi> W\<^sub>c \<psi> = (\<forall>i. suffix i \<xi> \<Turnstile>\<^sub>c \<phi> \<or> (\<exists>j\<le>i. suffix j \<xi> \<Turnstile>\<^sub>c \<psi>))"
 | "\<xi> \<Turnstile>\<^sub>c \<phi> M\<^sub>c \<psi> = (\<exists>i. suffix i \<xi> \<Turnstile>\<^sub>c \<phi> \<and> (\<forall>j\<le>i. suffix j \<xi> \<Turnstile>\<^sub>c \<psi>))"
 
 lemma semantics_ltlc_sugar [simp]:
   "\<xi> \<Turnstile>\<^sub>c \<phi> iff\<^sub>c \<psi> = (\<xi> \<Turnstile>\<^sub>c \<phi> \<longleftrightarrow> \<xi> \<Turnstile>\<^sub>c \<psi>)"
   "\<xi> \<Turnstile>\<^sub>c F\<^sub>c \<phi> = \<xi> \<Turnstile>\<^sub>c (true\<^sub>c U\<^sub>c \<phi>)"
   "\<xi> \<Turnstile>\<^sub>c G\<^sub>c \<phi> = \<xi> \<Turnstile>\<^sub>c (false\<^sub>c R\<^sub>c \<phi>)"
   by (auto simp add: Iff_ltlc_def)
 
 definition "language_ltlc \<phi> \<equiv> {\<xi>. \<xi> \<Turnstile>\<^sub>c \<phi>}"
 
 lemma language_ltlc_negate[simp]:
   "language_ltlc (not\<^sub>c \<phi>) = - language_ltlc \<phi>"
   unfolding language_ltlc_def by auto
 
 lemma ltl_true_or_con[simp]:
   "\<xi> \<Turnstile>\<^sub>c prop\<^sub>c(p) or\<^sub>c (not\<^sub>c prop\<^sub>c(p))"
   by auto
 
 lemma ltl_false_true_con[simp]:
   "\<xi> \<Turnstile>\<^sub>c not\<^sub>c true\<^sub>c \<longleftrightarrow> \<xi> \<Turnstile>\<^sub>c false\<^sub>c"
   by auto
 
 lemma ltl_Next_Neg_con[simp]:
   "\<xi> \<Turnstile>\<^sub>c X\<^sub>c (not\<^sub>c \<phi>) \<longleftrightarrow> \<xi> \<Turnstile>\<^sub>c not\<^sub>c X\<^sub>c \<phi>"
   by auto
 
 \<comment> \<open>The connection between dual operators\<close>
 
 lemma ltl_Until_Release_con:
   "\<xi> \<Turnstile>\<^sub>c \<phi> R\<^sub>c \<psi> \<longleftrightarrow> (\<not> \<xi> \<Turnstile>\<^sub>c (not\<^sub>c \<phi>) U\<^sub>c (not\<^sub>c \<psi>))"
   "\<xi> \<Turnstile>\<^sub>c \<phi> U\<^sub>c \<psi> \<longleftrightarrow> (\<not> \<xi> \<Turnstile>\<^sub>c (not\<^sub>c \<phi>) R\<^sub>c (not\<^sub>c \<psi>))"
   by auto
 
 lemma ltl_WeakUntil_StrongRelease_con:
   "\<xi> \<Turnstile>\<^sub>c \<phi> W\<^sub>c \<psi> \<longleftrightarrow> (\<not> \<xi> \<Turnstile>\<^sub>c (not\<^sub>c \<phi>) M\<^sub>c (not\<^sub>c \<psi>))"
   "\<xi> \<Turnstile>\<^sub>c \<phi> M\<^sub>c \<psi> \<longleftrightarrow> (\<not> \<xi> \<Turnstile>\<^sub>c (not\<^sub>c \<phi>) W\<^sub>c (not\<^sub>c \<psi>))"
   by auto
 
 \<comment> \<open>The connection between weak and strong operators\<close>
 
 lemma ltl_Release_StrongRelease_con:
   "\<xi> \<Turnstile>\<^sub>c \<phi> R\<^sub>c \<psi> \<longleftrightarrow> \<xi> \<Turnstile>\<^sub>c (\<phi> M\<^sub>c \<psi>) or\<^sub>c (G\<^sub>c \<psi>)"
   "\<xi> \<Turnstile>\<^sub>c \<phi> M\<^sub>c \<psi> \<longleftrightarrow> \<xi> \<Turnstile>\<^sub>c (\<phi> R\<^sub>c \<psi>) and\<^sub>c (F\<^sub>c \<phi>)"
 proof safe
   assume asm: "\<xi> \<Turnstile>\<^sub>c \<phi> R\<^sub>c \<psi>"
 
   show "\<xi> \<Turnstile>\<^sub>c (\<phi> M\<^sub>c \<psi>) or\<^sub>c (G\<^sub>c \<psi>)"
   proof (cases "\<xi> \<Turnstile>\<^sub>c G\<^sub>c \<psi>")
     case False
 
     then obtain i where "\<not> suffix i \<xi> \<Turnstile>\<^sub>c \<psi>" and "\<forall>j<i. suffix j \<xi> \<Turnstile>\<^sub>c \<psi>"
       using exists_least_iff[of "\<lambda>i. \<not> suffix i \<xi> \<Turnstile>\<^sub>c \<psi>"] by force
 
     then show ?thesis
       using asm by force
   qed simp
 next
   assume asm: "\<xi> \<Turnstile>\<^sub>c (\<phi> R\<^sub>c \<psi>) and\<^sub>c (F\<^sub>c \<phi>)"
 
   then show "\<xi> \<Turnstile>\<^sub>c \<phi> M\<^sub>c \<psi>"
   proof (cases "\<xi> \<Turnstile>\<^sub>c F\<^sub>c \<phi>")
     case True
 
     then obtain i where "suffix i \<xi> \<Turnstile>\<^sub>c \<phi>" and "\<forall>j<i. \<not> suffix j \<xi> \<Turnstile>\<^sub>c \<phi>"
       using exists_least_iff[of "\<lambda>i. suffix i \<xi> \<Turnstile>\<^sub>c \<phi>"] by force
 
     then show ?thesis
       using asm by force
   qed simp
 qed (unfold semantics_ltlc.simps; insert not_less, blast)+
 
 lemma ltl_Until_WeakUntil_con:
   "\<xi> \<Turnstile>\<^sub>c \<phi> U\<^sub>c \<psi> \<longleftrightarrow> \<xi> \<Turnstile>\<^sub>c (\<phi> W\<^sub>c \<psi>) and\<^sub>c (F\<^sub>c \<psi>)"
   "\<xi> \<Turnstile>\<^sub>c \<phi> W\<^sub>c \<psi> \<longleftrightarrow> \<xi> \<Turnstile>\<^sub>c (\<phi> U\<^sub>c \<psi>) or\<^sub>c (G\<^sub>c \<phi>)"
 proof safe
   assume asm: "\<xi> \<Turnstile>\<^sub>c (\<phi> W\<^sub>c \<psi>) and\<^sub>c (F\<^sub>c \<psi>)"
 
   then show "\<xi> \<Turnstile>\<^sub>c \<phi> U\<^sub>c \<psi>"
   proof (cases "\<xi> \<Turnstile>\<^sub>c F\<^sub>c \<psi>")
     case True
 
     then obtain i where "suffix i \<xi> \<Turnstile>\<^sub>c \<psi>" and "\<forall>j<i. \<not> suffix j \<xi> \<Turnstile>\<^sub>c \<psi>"
       using exists_least_iff[of "\<lambda>i. suffix i \<xi> \<Turnstile>\<^sub>c \<psi>"] by force
 
     then show ?thesis
       using asm by force
   qed simp
 next
   assume asm: "\<xi> \<Turnstile>\<^sub>c \<phi> W\<^sub>c \<psi>"
 
   then show "\<xi> \<Turnstile>\<^sub>c (\<phi> U\<^sub>c \<psi>) or\<^sub>c (G\<^sub>c \<phi>)"
   proof (cases "\<xi> \<Turnstile>\<^sub>c G\<^sub>c \<phi>")
     case False
 
     then obtain i where "\<not> suffix i \<xi> \<Turnstile>\<^sub>c \<phi>" and "\<forall>j<i. suffix j \<xi> \<Turnstile>\<^sub>c \<phi>"
       using exists_least_iff[of "\<lambda>i. \<not> suffix i \<xi> \<Turnstile>\<^sub>c \<phi>"] by force
 
     then show ?thesis
       using asm by force
   qed simp
 qed (unfold semantics_ltlc.simps; insert not_less, blast)+
 
 lemma ltl_StrongRelease_Until_con:
   "\<xi> \<Turnstile>\<^sub>c \<phi> M\<^sub>c \<psi> \<longleftrightarrow> \<xi> \<Turnstile>\<^sub>c \<psi> U\<^sub>c (\<phi> and\<^sub>c \<psi>)"
   using order.order_iff_strict by auto
 
 lemma ltl_WeakUntil_Release_con:
   "\<xi> \<Turnstile>\<^sub>c \<phi> R\<^sub>c \<psi> \<longleftrightarrow> \<xi> \<Turnstile>\<^sub>c \<psi> W\<^sub>c (\<phi> and\<^sub>c \<psi>)"
   by (meson ltl_Release_StrongRelease_con(1) ltl_StrongRelease_Until_con ltl_Until_WeakUntil_con(2) semantics_ltlc.simps(6))
 
 
 definition "pw_eq_on S w w' \<equiv> \<forall>i. w i \<inter> S = w' i \<inter> S"
 
 lemma pw_eq_on_refl[simp]: "pw_eq_on S w w"
   and pw_eq_on_sym: "pw_eq_on S w w' \<Longrightarrow> pw_eq_on S w' w"
   and pw_eq_on_trans[trans]: "\<lbrakk>pw_eq_on S w w'; pw_eq_on S w' w''\<rbrakk> \<Longrightarrow> pw_eq_on S w w''"
   unfolding pw_eq_on_def by auto
 
 lemma pw_eq_on_suffix:
   "pw_eq_on S w w' \<Longrightarrow> pw_eq_on S (suffix k w) (suffix k w')"
   by (simp add: pw_eq_on_def)
 
 lemma pw_eq_on_subset:
   "S \<subseteq> S' \<Longrightarrow> pw_eq_on S' w w' \<Longrightarrow> pw_eq_on S w w'"
   by (auto simp add: pw_eq_on_def)
 
 lemma ltlc_eq_on_aux:
   "pw_eq_on (atoms_ltlc \<phi>) w w' \<Longrightarrow> w \<Turnstile>\<^sub>c \<phi> \<Longrightarrow> w' \<Turnstile>\<^sub>c \<phi>"
 proof (induction \<phi> arbitrary: w w')
   case Until_ltlc
   thus ?case
     by simp (meson Un_upper1 Un_upper2 pw_eq_on_subset pw_eq_on_suffix)
 next
   case Release_ltlc
   thus ?case
     by simp (metis Un_upper1 pw_eq_on_subset pw_eq_on_suffix sup_commute)
 next
   case WeakUntil_ltlc
   thus ?case
     by simp (meson pw_eq_on_subset pw_eq_on_suffix sup.cobounded1 sup_ge2)
 next
   case StrongRelease_ltlc
   thus ?case
     by simp (metis Un_upper1 pw_eq_on_subset pw_eq_on_suffix pw_eq_on_sym sup_ge2)
 next
   case (And_ltlc \<phi> \<psi>)
   thus ?case
     by simp (meson Un_upper1 inf_sup_ord(4) pw_eq_on_subset)
 next
   case (Or_ltlc \<phi> \<psi>)
   thus ?case
     by simp (meson Un_upper2 pw_eq_on_subset sup_ge1)
 next
   case (Implies_ltlc \<phi> \<psi>)
   thus ?case
     by simp (meson Un_upper1 Un_upper2 pw_eq_on_subset[of "atoms_ltlc _" "atoms_ltlc \<phi> \<union> atoms_ltlc \<psi>"]  pw_eq_on_sym)
 qed (auto simp add: pw_eq_on_def; metis suffix_nth)+
 
 lemma ltlc_eq_on:
   "pw_eq_on (atoms_ltlc \<phi>) w w' \<Longrightarrow> w \<Turnstile>\<^sub>c \<phi> \<longleftrightarrow> w' \<Turnstile>\<^sub>c \<phi>"
   using ltlc_eq_on_aux pw_eq_on_sym by blast
 
 lemma suffix_comp: "(\<lambda>i. f (suffix k w i)) = suffix k (f o w)"
   by auto
 
 lemma suffix_range: "\<Union>(range \<xi>) \<subseteq> APs \<Longrightarrow> \<Union>(range (suffix k \<xi>)) \<subseteq> APs"
     by auto
 
 lemma map_semantics_ltlc_aux:
   assumes "inj_on f APs"
   assumes "\<Union>(range w) \<subseteq> APs"
   assumes "atoms_ltlc \<phi> \<subseteq> APs"
   shows "w \<Turnstile>\<^sub>c \<phi> \<longleftrightarrow> (\<lambda>i. f ` w i) \<Turnstile>\<^sub>c map_ltlc f \<phi>"
   using assms(2,3)
 proof (induction \<phi> arbitrary: w)
   case (Prop_ltlc x)
     thus ?case   using assms(1)
       by (simp add: SUP_le_iff inj_on_image_mem_iff)
 next
   case (Next_ltlc \<phi>)
     show ?case
       using Next_ltlc(1)[of "suffix 1 w", unfolded suffix_comp comp_def] Next_ltlc(2,3) apply simp
         by (metis Next_ltlc.prems(1) One_nat_def \<open>\<lbrakk>\<Union>(range (suffix 1 w)) \<subseteq> APs; atoms_ltlc \<phi> \<subseteq> APs\<rbrakk> \<Longrightarrow> suffix 1 w \<Turnstile>\<^sub>c \<phi> = suffix 1 (\<lambda>x. f ` w x) \<Turnstile>\<^sub>c map_ltlc f \<phi>\<close> suffix_range)
 next
   case (Final_ltlc \<phi>)
     thus ?case
        using Final_ltlc(1)[of "suffix _ _", unfolded suffix_comp comp_def, OF suffix_range] by fastforce
 next
   case (Global_ltlc)
     thus ?case
       using Global_ltlc(1)[of "suffix _ w", unfolded suffix_comp comp_def, OF suffix_range] by fastforce
 next
   case (Until_ltlc)
     thus ?case
       using Until_ltlc(1,2)[of "suffix _ w", unfolded suffix_comp comp_def, OF suffix_range] by fastforce
 next
   case (Release_ltlc)
     thus ?case
       using Release_ltlc(1,2)[of "suffix _ w", unfolded suffix_comp comp_def, OF suffix_range] by fastforce
 next
   case (WeakUntil_ltlc)
     thus ?case
       using WeakUntil_ltlc(1,2)[of "suffix _ w", unfolded suffix_comp comp_def, OF suffix_range] by fastforce
 next
   case (StrongRelease_ltlc)
     thus ?case
       using StrongRelease_ltlc(1,2)[of "suffix _ w", unfolded suffix_comp comp_def, OF suffix_range] by fastforce
 qed simp+
 
 definition "map_props f APs \<equiv> {i. \<exists>p\<in>APs. f p = Some i}"
 
 lemma map_semantics_ltlc:
   assumes INJ: "inj_on f (dom f)" and DOM: "atoms_ltlc \<phi> \<subseteq> dom f"
   shows "\<xi> \<Turnstile>\<^sub>c \<phi> \<longleftrightarrow> (map_props f o \<xi>) \<Turnstile>\<^sub>c map_ltlc (the o f) \<phi>"
 proof -
   let ?\<xi>r = "\<lambda>i. \<xi> i \<inter> atoms_ltlc \<phi>"
   let ?\<xi>r' = "\<lambda>i. \<xi> i \<inter> dom f"
 
   have 1: "\<Union>(range ?\<xi>r) \<subseteq> atoms_ltlc \<phi>" by auto
 
   have INJ_the_dom: "inj_on (the o f) (dom f)"
     using assms
     by (auto simp: inj_on_def domIff)
   note 2 = subset_inj_on[OF this DOM]
 
   have 3: "(\<lambda>i. (the o f) ` ?\<xi>r' i) = map_props f o \<xi>" using DOM INJ
     apply (auto intro!: ext simp: map_props_def domIff image_iff)
     by (metis Int_iff domI option.sel)
 
   have "\<xi> \<Turnstile>\<^sub>c \<phi> \<longleftrightarrow> ?\<xi>r \<Turnstile>\<^sub>c \<phi>"
     apply (rule ltlc_eq_on)
     apply (auto simp: pw_eq_on_def)
     done
   also from map_semantics_ltlc_aux[OF 2 1 subset_refl]
   have "\<dots> \<longleftrightarrow> (\<lambda>i. (the o f) ` ?\<xi>r i) \<Turnstile>\<^sub>c map_ltlc (the o f) \<phi>" .
   also have "\<dots> \<longleftrightarrow> (\<lambda>i. (the o f) ` ?\<xi>r' i) \<Turnstile>\<^sub>c map_ltlc (the o f) \<phi>"
     apply (rule ltlc_eq_on) using DOM INJ
     apply (auto simp: pw_eq_on_def ltlc.set_map domIff image_iff)
     by (metis Int_iff contra_subsetD domD domI inj_on_eq_iff option.sel)
   also note 3
   finally show ?thesis .
 qed
 
 lemma map_semantics_ltlc_inv:
   assumes INJ: "inj_on f (dom f)" and DOM: "atoms_ltlc \<phi> \<subseteq> dom f"
   shows "\<xi> \<Turnstile>\<^sub>c map_ltlc (the o f) \<phi> \<longleftrightarrow> (\<lambda>i. (the o f) -` \<xi> i) \<Turnstile>\<^sub>c \<phi>"
   using map_semantics_ltlc[OF assms]
   apply simp
   apply (intro ltlc_eq_on)
   apply (auto simp add: pw_eq_on_def ltlc.set_map map_props_def)
   by (metis DOM comp_apply contra_subsetD domD option.sel vimage_eq)
 
 
 
 
 subsection \<open>LTL in Negation Normal Form\<close>
 
 text \<open>We define a type of LTL formula in negation normal form (NNF).\<close>
 
 subsubsection \<open>Syntax\<close>
 
 datatype (atoms_ltln: 'a) ltln  =
     True_ltln                               ("true\<^sub>n")
   | False_ltln                              ("false\<^sub>n")
   | Prop_ltln 'a                            ("prop\<^sub>n'(_')")
   | Nprop_ltln 'a                           ("nprop\<^sub>n'(_')")
   | And_ltln "'a ltln" "'a ltln"            ("_ and\<^sub>n _" [82,82] 81)
   | Or_ltln "'a ltln" "'a ltln"             ("_ or\<^sub>n _" [84,84] 83)
   | Next_ltln "'a ltln"                     ("X\<^sub>n _" [88] 87)
   | Until_ltln "'a ltln" "'a ltln"          ("_ U\<^sub>n _" [84,84] 83)
   | Release_ltln "'a ltln" "'a ltln"        ("_ R\<^sub>n _" [84,84] 83)
   | WeakUntil_ltln "'a ltln" "'a ltln"      ("_ W\<^sub>n _" [84,84] 83)
   | StrongRelease_ltln "'a ltln" "'a ltln"  ("_ M\<^sub>n _" [84,84] 83)
 
 abbreviation finally\<^sub>n :: "'a ltln \<Rightarrow> 'a ltln" ("F\<^sub>n _" [88] 87)
 where
   "F\<^sub>n \<phi> \<equiv> true\<^sub>n U\<^sub>n \<phi>"
 
 notation (input) finally\<^sub>n ("\<diamondsuit>\<^sub>n _" [88] 87)
 
 abbreviation globally\<^sub>n :: "'a ltln \<Rightarrow> 'a ltln" ("G\<^sub>n _" [88] 87)
 where
   "G\<^sub>n \<phi> \<equiv> false\<^sub>n R\<^sub>n \<phi>"
 
 notation (input) globally\<^sub>n ("\<box>\<^sub>n _" [88] 87)
 
 subsubsection \<open>Semantics\<close>
 
 primrec semantics_ltln :: "['a set word, 'a ltln] \<Rightarrow> bool" ("_ \<Turnstile>\<^sub>n _" [80,80] 80)
 where
   "\<xi> \<Turnstile>\<^sub>n true\<^sub>n = True"
 | "\<xi> \<Turnstile>\<^sub>n false\<^sub>n = False"
 | "\<xi> \<Turnstile>\<^sub>n prop\<^sub>n(q) = (q \<in> \<xi> 0)"
 | "\<xi> \<Turnstile>\<^sub>n nprop\<^sub>n(q) = (q \<notin> \<xi> 0)"
 | "\<xi> \<Turnstile>\<^sub>n \<phi> and\<^sub>n \<psi> = (\<xi> \<Turnstile>\<^sub>n \<phi> \<and> \<xi> \<Turnstile>\<^sub>n \<psi>)"
 | "\<xi> \<Turnstile>\<^sub>n \<phi> or\<^sub>n \<psi> = (\<xi> \<Turnstile>\<^sub>n \<phi> \<or> \<xi> \<Turnstile>\<^sub>n \<psi>)"
 | "\<xi> \<Turnstile>\<^sub>n X\<^sub>n \<phi> = (suffix 1 \<xi> \<Turnstile>\<^sub>n \<phi>)"
 | "\<xi> \<Turnstile>\<^sub>n \<phi> U\<^sub>n \<psi> = (\<exists>i. suffix i \<xi> \<Turnstile>\<^sub>n \<psi> \<and> (\<forall>j<i. suffix j \<xi> \<Turnstile>\<^sub>n \<phi>))"
 | "\<xi> \<Turnstile>\<^sub>n \<phi> R\<^sub>n \<psi> = (\<forall>i. suffix i \<xi> \<Turnstile>\<^sub>n \<psi> \<or> (\<exists>j<i. suffix j \<xi> \<Turnstile>\<^sub>n \<phi>))"
 | "\<xi> \<Turnstile>\<^sub>n \<phi> W\<^sub>n \<psi> = (\<forall>i. suffix i \<xi> \<Turnstile>\<^sub>n \<phi> \<or> (\<exists>j\<le>i. suffix j \<xi> \<Turnstile>\<^sub>n \<psi>))"
 | "\<xi> \<Turnstile>\<^sub>n \<phi> M\<^sub>n \<psi> = (\<exists>i. suffix i \<xi> \<Turnstile>\<^sub>n \<phi> \<and> (\<forall>j\<le>i. suffix j \<xi> \<Turnstile>\<^sub>n \<psi>))"
 
 definition "language_ltln \<phi> \<equiv> {\<xi>. \<xi> \<Turnstile>\<^sub>n \<phi>}"
 
+lemma semantics_ltln_ite_simps[simp]:
+  "w \<Turnstile>\<^sub>n (if P then true\<^sub>n else false\<^sub>n) = P"
+  "w \<Turnstile>\<^sub>n (if P then false\<^sub>n else true\<^sub>n) = (\<not>P)"
+  by simp_all
+
 subsubsection \<open>Conversion\<close>
 
 fun ltlc_to_ltln' :: "bool \<Rightarrow> 'a ltlc \<Rightarrow> 'a ltln"
 where
   "ltlc_to_ltln' False true\<^sub>c = true\<^sub>n"
 | "ltlc_to_ltln' False false\<^sub>c = false\<^sub>n"
 | "ltlc_to_ltln' False prop\<^sub>c(q) = prop\<^sub>n(q)"
 | "ltlc_to_ltln' False (\<phi> and\<^sub>c \<psi>) = (ltlc_to_ltln' False \<phi>) and\<^sub>n (ltlc_to_ltln' False \<psi>)"
 | "ltlc_to_ltln' False (\<phi> or\<^sub>c \<psi>) = (ltlc_to_ltln' False \<phi>) or\<^sub>n (ltlc_to_ltln' False \<psi>)"
 | "ltlc_to_ltln' False (\<phi> implies\<^sub>c \<psi>) = (ltlc_to_ltln' True \<phi>) or\<^sub>n (ltlc_to_ltln' False \<psi>)"
 | "ltlc_to_ltln' False (F\<^sub>c \<phi>) = true\<^sub>n U\<^sub>n (ltlc_to_ltln' False \<phi>)"
 | "ltlc_to_ltln' False (G\<^sub>c \<phi>) = false\<^sub>n R\<^sub>n (ltlc_to_ltln' False \<phi>)"
 | "ltlc_to_ltln' False (\<phi> U\<^sub>c \<psi>) = (ltlc_to_ltln' False \<phi>) U\<^sub>n (ltlc_to_ltln' False \<psi>)"
 | "ltlc_to_ltln' False (\<phi> R\<^sub>c \<psi>) = (ltlc_to_ltln' False \<phi>) R\<^sub>n (ltlc_to_ltln' False \<psi>)"
 | "ltlc_to_ltln' False (\<phi> W\<^sub>c \<psi>) = (ltlc_to_ltln' False \<phi>) W\<^sub>n (ltlc_to_ltln' False \<psi>)"
 | "ltlc_to_ltln' False (\<phi> M\<^sub>c \<psi>) = (ltlc_to_ltln' False \<phi>) M\<^sub>n (ltlc_to_ltln' False \<psi>)"
 | "ltlc_to_ltln' True true\<^sub>c = false\<^sub>n"
 | "ltlc_to_ltln' True false\<^sub>c = true\<^sub>n"
 | "ltlc_to_ltln' True prop\<^sub>c(q) = nprop\<^sub>n(q)"
 | "ltlc_to_ltln' True (\<phi> and\<^sub>c \<psi>) = (ltlc_to_ltln' True \<phi>) or\<^sub>n (ltlc_to_ltln' True \<psi>)"
 | "ltlc_to_ltln' True (\<phi> or\<^sub>c \<psi>) = (ltlc_to_ltln' True \<phi>) and\<^sub>n (ltlc_to_ltln' True \<psi>)"
 | "ltlc_to_ltln' True (\<phi> implies\<^sub>c \<psi>) = (ltlc_to_ltln' False \<phi>) and\<^sub>n (ltlc_to_ltln' True \<psi>)"
 | "ltlc_to_ltln' True (F\<^sub>c \<phi>) = false\<^sub>n R\<^sub>n (ltlc_to_ltln' True \<phi>)"
 | "ltlc_to_ltln' True (G\<^sub>c \<phi>) = true\<^sub>n U\<^sub>n (ltlc_to_ltln' True \<phi>)"
 | "ltlc_to_ltln' True (\<phi> U\<^sub>c \<psi>) = (ltlc_to_ltln' True \<phi>) R\<^sub>n (ltlc_to_ltln' True \<psi>)"
 | "ltlc_to_ltln' True (\<phi> R\<^sub>c \<psi>) = (ltlc_to_ltln' True \<phi>) U\<^sub>n (ltlc_to_ltln' True \<psi>)"
 | "ltlc_to_ltln' True (\<phi> W\<^sub>c \<psi>) = (ltlc_to_ltln' True \<phi>) M\<^sub>n (ltlc_to_ltln' True \<psi>)"
 | "ltlc_to_ltln' True (\<phi> M\<^sub>c \<psi>) = (ltlc_to_ltln' True \<phi>) W\<^sub>n (ltlc_to_ltln' True \<psi>)"
 | "ltlc_to_ltln' b (not\<^sub>c \<phi>) = ltlc_to_ltln' (\<not> b) \<phi>"
 | "ltlc_to_ltln' b (X\<^sub>c \<phi>) = X\<^sub>n (ltlc_to_ltln' b \<phi>)"
 
 fun ltlc_to_ltln :: "'a ltlc \<Rightarrow> 'a ltln"
 where
   "ltlc_to_ltln \<phi> = ltlc_to_ltln' False \<phi>"
 
 fun ltln_to_ltlc :: "'a ltln \<Rightarrow> 'a ltlc"
 where
   "ltln_to_ltlc true\<^sub>n = true\<^sub>c"
 | "ltln_to_ltlc false\<^sub>n = false\<^sub>c"
 | "ltln_to_ltlc prop\<^sub>n(q) = prop\<^sub>c(q)"
 | "ltln_to_ltlc nprop\<^sub>n(q) = not\<^sub>c (prop\<^sub>c(q))"
 | "ltln_to_ltlc (\<phi> and\<^sub>n \<psi>) = (ltln_to_ltlc \<phi> and\<^sub>c ltln_to_ltlc \<psi>)"
 | "ltln_to_ltlc (\<phi> or\<^sub>n \<psi>) = (ltln_to_ltlc \<phi> or\<^sub>c ltln_to_ltlc \<psi>)"
 | "ltln_to_ltlc (X\<^sub>n \<phi>) = (X\<^sub>c ltln_to_ltlc \<phi>)"
 | "ltln_to_ltlc (\<phi> U\<^sub>n \<psi>) = (ltln_to_ltlc \<phi> U\<^sub>c ltln_to_ltlc \<psi>)"
 | "ltln_to_ltlc (\<phi> R\<^sub>n \<psi>) = (ltln_to_ltlc \<phi> R\<^sub>c ltln_to_ltlc \<psi>)"
 | "ltln_to_ltlc (\<phi> W\<^sub>n \<psi>) = (ltln_to_ltlc \<phi> W\<^sub>c ltln_to_ltlc \<psi>)"
 | "ltln_to_ltlc (\<phi> M\<^sub>n \<psi>) = (ltln_to_ltlc \<phi> M\<^sub>c ltln_to_ltlc \<psi>)"
 
 lemma ltlc_to_ltln'_correct:
   "w \<Turnstile>\<^sub>n (ltlc_to_ltln' True \<phi>) \<longleftrightarrow> \<not> w \<Turnstile>\<^sub>c \<phi>"
   "w \<Turnstile>\<^sub>n (ltlc_to_ltln' False \<phi>) \<longleftrightarrow> w \<Turnstile>\<^sub>c \<phi>"
   "size (ltlc_to_ltln' True \<phi>) \<le> 2 * size \<phi>"
   "size (ltlc_to_ltln' False \<phi>) \<le> 2 * size \<phi>"
   by (induction \<phi> arbitrary: w) simp+
 
 lemma ltlc_to_ltln_semantics [simp]:
   "w \<Turnstile>\<^sub>n ltlc_to_ltln \<phi> \<longleftrightarrow> w \<Turnstile>\<^sub>c \<phi>"
   using ltlc_to_ltln'_correct by auto
 
 lemma ltlc_to_ltln_size:
   "size (ltlc_to_ltln \<phi>) \<le> 2 * size \<phi>"
   using ltlc_to_ltln'_correct by simp
 
 lemma ltln_to_ltlc_semantics [simp]:
   "w \<Turnstile>\<^sub>c ltln_to_ltlc \<phi> \<longleftrightarrow> w \<Turnstile>\<^sub>n \<phi>"
   by (induction \<phi> arbitrary: w) simp+
 
 lemma ltlc_to_ltln_atoms:
   "atoms_ltln (ltlc_to_ltln \<phi>) = atoms_ltlc \<phi>"
 proof -
   have "atoms_ltln (ltlc_to_ltln' True \<phi>) = atoms_ltlc \<phi>"
     "atoms_ltln (ltlc_to_ltln' False \<phi>) = atoms_ltlc \<phi>"
     by (induction \<phi>) simp+
   thus ?thesis
     by simp
 qed
 
 subsubsection \<open>Negation\<close>
 
 fun not\<^sub>n
 where
   "not\<^sub>n true\<^sub>n = false\<^sub>n"
 | "not\<^sub>n false\<^sub>n = true\<^sub>n"
 | "not\<^sub>n prop\<^sub>n(a) = nprop\<^sub>n(a)"
 | "not\<^sub>n nprop\<^sub>n(a) = prop\<^sub>n(a)"
 | "not\<^sub>n (\<phi> and\<^sub>n \<psi>) = (not\<^sub>n \<phi>) or\<^sub>n (not\<^sub>n \<psi>)"
 | "not\<^sub>n (\<phi> or\<^sub>n \<psi>) = (not\<^sub>n \<phi>) and\<^sub>n (not\<^sub>n \<psi>)"
 | "not\<^sub>n (X\<^sub>n \<phi>) = X\<^sub>n (not\<^sub>n \<phi>)"
 | "not\<^sub>n (\<phi> U\<^sub>n \<psi>) = (not\<^sub>n \<phi>) R\<^sub>n (not\<^sub>n \<psi>)"
 | "not\<^sub>n (\<phi> R\<^sub>n \<psi>) = (not\<^sub>n \<phi>) U\<^sub>n (not\<^sub>n \<psi>)"
 | "not\<^sub>n (\<phi> W\<^sub>n \<psi>) = (not\<^sub>n \<phi>) M\<^sub>n (not\<^sub>n \<psi>)"
 | "not\<^sub>n (\<phi> M\<^sub>n \<psi>) = (not\<^sub>n \<phi>) W\<^sub>n (not\<^sub>n \<psi>)"
 
 lemma not\<^sub>n_semantics[simp]:
   "w \<Turnstile>\<^sub>n not\<^sub>n \<phi> \<longleftrightarrow> \<not> w \<Turnstile>\<^sub>n \<phi>"
   by (induction \<phi> arbitrary: w) auto
 
 lemma not\<^sub>n_size:
   "size (not\<^sub>n \<phi>) = size \<phi>"
   by (induction \<phi>) auto
 
 
 subsubsection \<open>Subformulas\<close>
 
 fun subfrmlsn :: "'a ltln \<Rightarrow> 'a ltln set"
 where
   "subfrmlsn (\<phi> and\<^sub>n \<psi>) = {\<phi> and\<^sub>n \<psi>} \<union> subfrmlsn \<phi> \<union> subfrmlsn \<psi>"
 | "subfrmlsn (\<phi> or\<^sub>n \<psi>) = {\<phi> or\<^sub>n \<psi>} \<union> subfrmlsn \<phi> \<union> subfrmlsn \<psi>"
 | "subfrmlsn (X\<^sub>n \<phi>) = {X\<^sub>n \<phi>} \<union> subfrmlsn \<phi>"
 | "subfrmlsn (\<phi> U\<^sub>n \<psi>) = {\<phi> U\<^sub>n \<psi>} \<union> subfrmlsn \<phi> \<union> subfrmlsn \<psi>"
 | "subfrmlsn (\<phi> R\<^sub>n \<psi>) = {\<phi> R\<^sub>n \<psi>} \<union> subfrmlsn \<phi> \<union> subfrmlsn \<psi>"
 | "subfrmlsn (\<phi> W\<^sub>n \<psi>) = {\<phi> W\<^sub>n \<psi>} \<union> subfrmlsn \<phi> \<union> subfrmlsn \<psi>"
 | "subfrmlsn (\<phi> M\<^sub>n \<psi>) = {\<phi> M\<^sub>n \<psi>} \<union> subfrmlsn \<phi> \<union> subfrmlsn \<psi>"
 | "subfrmlsn \<phi> = {\<phi>}"
 
 lemma subfrmlsn_id[simp]:
   "\<phi> \<in> subfrmlsn \<phi>"
   by (induction \<phi>) auto
 
 lemma subfrmlsn_finite:
   "finite (subfrmlsn \<phi>)"
   by (induction \<phi>) auto
 
 lemma subfrmlsn_card:
   "card (subfrmlsn \<phi>) \<le> size \<phi>"
   by (induction \<phi>) (simp_all add: card_insert_if subfrmlsn_finite, (meson add_le_mono card_Un_le dual_order.trans le_SucI)+)
 
 lemma subfrmlsn_subset:
   "\<psi> \<in> subfrmlsn \<phi> \<Longrightarrow> subfrmlsn \<psi> \<subseteq> subfrmlsn \<phi>"
   by (induction \<phi>) auto
 
 lemma subfrmlsn_size:
   "\<psi> \<in> subfrmlsn \<phi> \<Longrightarrow> size \<psi> < size \<phi> \<or> \<psi> = \<phi>"
   by (induction \<phi>) auto
 
 abbreviation
   "size_set S \<equiv> sum (\<lambda>x. 2 * size x + 1) S"
 
 lemma size_set_diff:
   "finite S \<Longrightarrow> S' \<subseteq> S \<Longrightarrow> size_set (S - S') = size_set S - size_set S'"
   using sum_diff_nat finite_subset by metis
 
 
 subsubsection \<open>Constant Folding\<close>
 
 lemma U_consts[intro, simp]:
   "w \<Turnstile>\<^sub>n \<phi> U\<^sub>n true\<^sub>n"
   "\<not> (w \<Turnstile>\<^sub>n \<phi> U\<^sub>n false\<^sub>n)"
   "(w \<Turnstile>\<^sub>n false\<^sub>n U\<^sub>n \<phi>) = (w \<Turnstile>\<^sub>n \<phi>)"
   by force+
 
 lemma R_consts[intro, simp]:
   "w \<Turnstile>\<^sub>n \<phi> R\<^sub>n true\<^sub>n"
   "\<not> (w \<Turnstile>\<^sub>n \<phi> R\<^sub>n false\<^sub>n)"
   "(w \<Turnstile>\<^sub>n true\<^sub>n R\<^sub>n \<phi>) = (w \<Turnstile>\<^sub>n \<phi>)"
   by force+
 
 lemma W_consts[intro, simp]:
   "w \<Turnstile>\<^sub>n true\<^sub>n W\<^sub>n \<phi>"
   "w \<Turnstile>\<^sub>n \<phi> W\<^sub>n true\<^sub>n"
   "(w \<Turnstile>\<^sub>n false\<^sub>n W\<^sub>n \<phi>) = (w \<Turnstile>\<^sub>n \<phi>)"
   "(w \<Turnstile>\<^sub>n \<phi> W\<^sub>n false\<^sub>n) = (w \<Turnstile>\<^sub>n G\<^sub>n \<phi>)"
   by force+
 
 lemma M_consts[intro, simp]:
   "\<not> (w \<Turnstile>\<^sub>n false\<^sub>n M\<^sub>n \<phi>)"
   "\<not> (w \<Turnstile>\<^sub>n \<phi> M\<^sub>n false\<^sub>n)"
   "(w \<Turnstile>\<^sub>n true\<^sub>n M\<^sub>n \<phi>) = (w \<Turnstile>\<^sub>n \<phi>)"
   "(w \<Turnstile>\<^sub>n \<phi> M\<^sub>n true\<^sub>n) = (w \<Turnstile>\<^sub>n F\<^sub>n \<phi>)"
   by force+
 
 
 subsubsection \<open>Distributivity\<close>
 
 lemma until_and_left_distrib:
   "w \<Turnstile>\<^sub>n (\<phi>\<^sub>1 and\<^sub>n \<phi>\<^sub>2) U\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n (\<phi>\<^sub>1 U\<^sub>n \<psi>) and\<^sub>n (\<phi>\<^sub>2 U\<^sub>n \<psi>)"
 proof
   assume "w \<Turnstile>\<^sub>n \<phi>\<^sub>1 U\<^sub>n \<psi> and\<^sub>n \<phi>\<^sub>2 U\<^sub>n \<psi>"
 
   then obtain i1 i2 where "suffix i1 w \<Turnstile>\<^sub>n \<psi> \<and> (\<forall>j<i1. suffix j w \<Turnstile>\<^sub>n \<phi>\<^sub>1)" and "suffix i2 w \<Turnstile>\<^sub>n \<psi> \<and> (\<forall>j<i2. suffix j w \<Turnstile>\<^sub>n \<phi>\<^sub>2)"
     by auto
 
   then have "suffix (min i1 i2) w \<Turnstile>\<^sub>n \<psi> \<and> (\<forall>j<min i1 i2. suffix j w \<Turnstile>\<^sub>n \<phi>\<^sub>1 and\<^sub>n \<phi>\<^sub>2)"
     by (simp add: min_def)
 
   then show "w \<Turnstile>\<^sub>n (\<phi>\<^sub>1 and\<^sub>n \<phi>\<^sub>2) U\<^sub>n \<psi>"
     by force
 qed auto
 
 lemma until_or_right_distrib:
   "w \<Turnstile>\<^sub>n \<phi> U\<^sub>n (\<psi>\<^sub>1 or\<^sub>n \<psi>\<^sub>2) \<longleftrightarrow> w \<Turnstile>\<^sub>n (\<phi> U\<^sub>n \<psi>\<^sub>1) or\<^sub>n (\<phi> U\<^sub>n \<psi>\<^sub>2)"
   by auto
 
 lemma release_and_right_distrib:
   "w \<Turnstile>\<^sub>n \<phi> R\<^sub>n (\<psi>\<^sub>1 and\<^sub>n \<psi>\<^sub>2) \<longleftrightarrow> w \<Turnstile>\<^sub>n (\<phi> R\<^sub>n \<psi>\<^sub>1) and\<^sub>n (\<phi> R\<^sub>n \<psi>\<^sub>2)"
   by auto
 
 lemma release_or_left_distrib:
   "w \<Turnstile>\<^sub>n (\<phi>\<^sub>1 or\<^sub>n \<phi>\<^sub>2) R\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n (\<phi>\<^sub>1 R\<^sub>n \<psi>) or\<^sub>n (\<phi>\<^sub>2 R\<^sub>n \<psi>)"
   by (metis not\<^sub>n.simps(6) not\<^sub>n.simps(9) not\<^sub>n_semantics until_and_left_distrib)
 
 lemma strong_release_and_right_distrib:
   "w \<Turnstile>\<^sub>n \<phi> M\<^sub>n (\<psi>\<^sub>1 and\<^sub>n \<psi>\<^sub>2) \<longleftrightarrow> w \<Turnstile>\<^sub>n (\<phi> M\<^sub>n \<psi>\<^sub>1) and\<^sub>n (\<phi> M\<^sub>n \<psi>\<^sub>2)"
 proof
   assume "w \<Turnstile>\<^sub>n (\<phi> M\<^sub>n \<psi>\<^sub>1) and\<^sub>n (\<phi> M\<^sub>n \<psi>\<^sub>2)"
 
   then obtain i1 i2 where "suffix i1 w \<Turnstile>\<^sub>n \<phi> \<and> (\<forall>j\<le>i1. suffix j w \<Turnstile>\<^sub>n \<psi>\<^sub>1)" and "suffix i2 w \<Turnstile>\<^sub>n \<phi> \<and> (\<forall>j\<le>i2. suffix j w \<Turnstile>\<^sub>n \<psi>\<^sub>2)"
     by auto
 
   then have "suffix (min i1 i2) w \<Turnstile>\<^sub>n \<phi> \<and> (\<forall>j\<le>min i1 i2. suffix j w \<Turnstile>\<^sub>n \<psi>\<^sub>1 and\<^sub>n \<psi>\<^sub>2)"
     by (simp add: min_def)
 
   then show "w \<Turnstile>\<^sub>n \<phi> M\<^sub>n (\<psi>\<^sub>1 and\<^sub>n \<psi>\<^sub>2)"
     by force
 qed auto
 
 lemma strong_release_or_left_distrib:
   "w \<Turnstile>\<^sub>n (\<phi>\<^sub>1 or\<^sub>n \<phi>\<^sub>2) M\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n (\<phi>\<^sub>1 M\<^sub>n \<psi>) or\<^sub>n (\<phi>\<^sub>2 M\<^sub>n \<psi>)"
   by auto
 
 lemma weak_until_and_left_distrib:
   "w \<Turnstile>\<^sub>n (\<phi>\<^sub>1 and\<^sub>n \<phi>\<^sub>2) W\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n (\<phi>\<^sub>1 W\<^sub>n \<psi>) and\<^sub>n (\<phi>\<^sub>2 W\<^sub>n \<psi>)"
   by auto
 
 lemma weak_until_or_right_distrib:
   "w \<Turnstile>\<^sub>n \<phi> W\<^sub>n (\<psi>\<^sub>1 or\<^sub>n \<psi>\<^sub>2) \<longleftrightarrow> w \<Turnstile>\<^sub>n (\<phi> W\<^sub>n \<psi>\<^sub>1) or\<^sub>n (\<phi> W\<^sub>n \<psi>\<^sub>2)"
   by (metis not\<^sub>n.simps(10) not\<^sub>n.simps(6) not\<^sub>n_semantics strong_release_and_right_distrib)
 
 
 lemma next_until_distrib:
   "w \<Turnstile>\<^sub>n X\<^sub>n (\<phi> U\<^sub>n \<psi>) \<longleftrightarrow> w \<Turnstile>\<^sub>n (X\<^sub>n \<phi>) U\<^sub>n (X\<^sub>n \<psi>)"
   by auto
 
 lemma next_release_distrib:
   "w \<Turnstile>\<^sub>n X\<^sub>n (\<phi> R\<^sub>n \<psi>) \<longleftrightarrow> w \<Turnstile>\<^sub>n (X\<^sub>n \<phi>) R\<^sub>n (X\<^sub>n \<psi>)"
   by auto
 
 lemma next_weak_until_distrib:
   "w \<Turnstile>\<^sub>n X\<^sub>n (\<phi> W\<^sub>n \<psi>) \<longleftrightarrow> w \<Turnstile>\<^sub>n (X\<^sub>n \<phi>) W\<^sub>n (X\<^sub>n \<psi>)"
   by auto
 
 lemma next_strong_release_distrib:
   "w \<Turnstile>\<^sub>n X\<^sub>n (\<phi> M\<^sub>n \<psi>) \<longleftrightarrow> w \<Turnstile>\<^sub>n (X\<^sub>n \<phi>) M\<^sub>n (X\<^sub>n \<psi>)"
   by auto
 
 
 subsubsection \<open>Nested operators\<close>
 
 lemma finally_until[simp]:
   "w \<Turnstile>\<^sub>n F\<^sub>n (\<phi> U\<^sub>n \<psi>) \<longleftrightarrow> w \<Turnstile>\<^sub>n F\<^sub>n \<psi>"
   by auto force
 
 lemma globally_release[simp]:
   "w \<Turnstile>\<^sub>n G\<^sub>n (\<phi> R\<^sub>n \<psi>) \<longleftrightarrow> w \<Turnstile>\<^sub>n G\<^sub>n \<psi>"
   by auto force
 
 lemma globally_weak_until[simp]:
   "w \<Turnstile>\<^sub>n G\<^sub>n (\<phi> W\<^sub>n \<psi>) \<longleftrightarrow> w \<Turnstile>\<^sub>n G\<^sub>n (\<phi> or\<^sub>n \<psi>)"
   by auto force
 
 lemma finally_strong_release[simp]:
   "w \<Turnstile>\<^sub>n F\<^sub>n (\<phi> M\<^sub>n \<psi>) \<longleftrightarrow> w \<Turnstile>\<^sub>n F\<^sub>n (\<phi> and\<^sub>n \<psi>)"
   by auto force
 
 
 subsubsection \<open>Weak and strong operators\<close>
 
 lemma ltln_weak_strong:
   "w \<Turnstile>\<^sub>n \<phi> W\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n (G\<^sub>n \<phi>) or\<^sub>n (\<phi> U\<^sub>n \<psi>)"
   "w \<Turnstile>\<^sub>n \<phi> R\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n (G\<^sub>n \<psi>) or\<^sub>n (\<phi> M\<^sub>n \<psi>)"
 proof auto
   fix i
   assume "\<forall>i. suffix i w \<Turnstile>\<^sub>n \<phi> \<or> (\<exists>j\<le>i. suffix j w \<Turnstile>\<^sub>n \<psi>)"
     and "\<forall>i. suffix i w \<Turnstile>\<^sub>n \<psi> \<longrightarrow> (\<exists>j<i. \<not> suffix j w \<Turnstile>\<^sub>n \<phi>)"
 
   then show "suffix i w \<Turnstile>\<^sub>n \<phi>"
     by (induction i rule: less_induct) force
 next
   fix i k
   assume "\<forall>j\<le>i. \<not> suffix j w \<Turnstile>\<^sub>n \<psi>"
     and "suffix k w \<Turnstile>\<^sub>n \<psi>"
     and "\<forall>j<k. suffix j w \<Turnstile>\<^sub>n \<phi>"
 
   then show "suffix i w \<Turnstile>\<^sub>n \<phi>"
     by (cases "i < k") simp_all
 next
   fix i
   assume "\<forall>i. suffix i w \<Turnstile>\<^sub>n \<psi> \<or> (\<exists>j<i. suffix j w \<Turnstile>\<^sub>n \<phi>)"
     and "\<forall>i. suffix i w \<Turnstile>\<^sub>n \<phi> \<longrightarrow> (\<exists>j\<le>i. \<not> suffix j w \<Turnstile>\<^sub>n \<psi>)"
 
   then show "suffix i w \<Turnstile>\<^sub>n \<psi>"
     by (induction i rule: less_induct) force
 next
   fix i k
   assume "\<forall>j<i. \<not> suffix j w \<Turnstile>\<^sub>n \<phi>"
     and "suffix k w \<Turnstile>\<^sub>n \<phi>"
     and "\<forall>j\<le>k. suffix j w \<Turnstile>\<^sub>n \<psi>"
 
   then show "suffix i w \<Turnstile>\<^sub>n \<psi>"
     by (cases "i \<le> k") simp_all
 qed
 
 lemma ltln_strong_weak:
   "w \<Turnstile>\<^sub>n \<phi> U\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n (F\<^sub>n \<psi>) and\<^sub>n (\<phi> W\<^sub>n \<psi>)"
   "w \<Turnstile>\<^sub>n \<phi> M\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n (F\<^sub>n \<phi>) and\<^sub>n (\<phi> R\<^sub>n \<psi>)"
   by (metis ltln_weak_strong not\<^sub>n.simps(1,5,8-11) not\<^sub>n_semantics)+
 
 lemma ltln_strong_to_weak:
   "w \<Turnstile>\<^sub>n \<phi> U\<^sub>n \<psi> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> W\<^sub>n \<psi>"
   "w \<Turnstile>\<^sub>n \<phi> M\<^sub>n \<psi> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> R\<^sub>n \<psi>"
   using ltln_weak_strong by simp_all blast+
 
 lemma ltln_weak_to_strong:
   "\<lbrakk>w \<Turnstile>\<^sub>n \<phi> W\<^sub>n \<psi>; \<not> w \<Turnstile>\<^sub>n G\<^sub>n \<phi>\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> U\<^sub>n \<psi>"
   "\<lbrakk>w \<Turnstile>\<^sub>n \<phi> W\<^sub>n \<psi>; w \<Turnstile>\<^sub>n F\<^sub>n \<psi>\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> U\<^sub>n \<psi>"
   "\<lbrakk>w \<Turnstile>\<^sub>n \<phi> R\<^sub>n \<psi>; \<not> w \<Turnstile>\<^sub>n G\<^sub>n \<psi>\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> M\<^sub>n \<psi>"
   "\<lbrakk>w \<Turnstile>\<^sub>n \<phi> R\<^sub>n \<psi>; w \<Turnstile>\<^sub>n F\<^sub>n \<phi>\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> M\<^sub>n \<psi>"
   unfolding ltln_weak_strong[of w \<phi> \<psi>] by auto
 
 
 lemma ltln_StrongRelease_to_Until:
   "w \<Turnstile>\<^sub>n \<phi> M\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n \<psi> U\<^sub>n (\<phi> and\<^sub>n \<psi>)"
   using order.order_iff_strict by auto
 
 lemma ltln_Release_to_WeakUntil:
   "w \<Turnstile>\<^sub>n \<phi> R\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n \<psi> W\<^sub>n (\<phi> and\<^sub>n \<psi>)"
   by (meson ltln_StrongRelease_to_Until ltln_weak_strong semantics_ltln.simps(6))
 
 lemma ltln_WeakUntil_to_Release:
   "w \<Turnstile>\<^sub>n \<phi> W\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n \<psi> R\<^sub>n (\<phi> or\<^sub>n \<psi>)"
   by (metis ltln_StrongRelease_to_Until not\<^sub>n.simps(6,9,10) not\<^sub>n_semantics)
 
 lemma ltln_Until_to_StrongRelease:
   "w \<Turnstile>\<^sub>n \<phi> U\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n \<psi> M\<^sub>n (\<phi> or\<^sub>n \<psi>)"
   by (metis ltln_Release_to_WeakUntil not\<^sub>n.simps(6,8,11) not\<^sub>n_semantics)
 
 
 subsubsection \<open>GF and FG semantics\<close>
 
 lemma GF_suffix:
-  "w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<phi>) \<Longrightarrow> suffix i w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<phi>)"
-  by simp
+  "suffix i w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>) \<longleftrightarrow> w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)"
+  by auto (metis ab_semigroup_add_class.add_ac(1) add.left_commute)
 
 lemma FG_suffix:
-  "w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<phi>) \<Longrightarrow> suffix i w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<phi>)"
-  by (auto simp: algebra_simps)
-
+  "suffix i w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>) \<longleftrightarrow> w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>)"
+  by (auto simp: algebra_simps) (metis add.commute add.left_commute)
 
 lemma GF_Inf_many:
   "w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<phi>) \<longleftrightarrow> (\<exists>\<^sub>\<infinity> i. suffix i w \<Turnstile>\<^sub>n \<phi>)"
   unfolding INFM_nat_le
   by simp (blast dest: le_Suc_ex intro: le_add1)
 
 lemma FG_Alm_all:
   "w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<phi>) \<longleftrightarrow> (\<forall>\<^sub>\<infinity> i. suffix i w \<Turnstile>\<^sub>n \<phi>)"
   unfolding MOST_nat_le
   by simp (blast dest: le_Suc_ex intro: le_add1)
 
 
 (* TODO: move to Infinite_Set.thy ?? *)
 lemma MOST_nat_add:
   "(\<forall>\<^sub>\<infinity>i::nat. P i) \<longleftrightarrow> (\<forall>\<^sub>\<infinity>i. P (i + j))"
   by (simp add: cofinite_eq_sequentially)
 
 lemma INFM_nat_add:
   "(\<exists>\<^sub>\<infinity>i::nat. P i) \<longleftrightarrow> (\<exists>\<^sub>\<infinity>i. P (i + j))"
   using MOST_nat_add not_MOST not_INFM by blast
 
 
 lemma FG_suffix_G:
   "w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<phi>) \<Longrightarrow> \<forall>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<phi>"
 proof -
   assume "w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<phi>)"
   then have "w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n (G\<^sub>n \<phi>))"
     by (meson globally_release semantics_ltln.simps(8))
   then show "\<forall>\<^sub>\<infinity>i. suffix i w  \<Turnstile>\<^sub>n G\<^sub>n \<phi>"
     unfolding FG_Alm_all .
 qed
 
 lemma Alm_all_GF_F:
   "\<forall>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>) \<longleftrightarrow> suffix i w \<Turnstile>\<^sub>n F\<^sub>n \<psi>"
   unfolding MOST_nat
 proof standard+
   fix i :: nat
   assume "suffix i w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)"
   then show "suffix i w \<Turnstile>\<^sub>n F\<^sub>n \<psi>"
     unfolding GF_Inf_many INFM_nat by fastforce
 next
   fix i :: nat
   assume suffix: "suffix i w \<Turnstile>\<^sub>n F\<^sub>n \<psi>"
   assume max: "i > Max {i. suffix i w \<Turnstile>\<^sub>n \<psi>}"
 
   with suffix obtain j where "j \<ge> i" and j_suffix: "suffix j w \<Turnstile>\<^sub>n \<psi>"
     by simp (blast intro: le_add1)
 
   with max have j_max: "j > Max {i. suffix i w \<Turnstile>\<^sub>n \<psi>}"
     by fastforce
 
   show "suffix i w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)"
   proof (cases "w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)")
     case False
     then have "\<not> (\<exists>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n \<psi>)"
       unfolding GF_Inf_many by simp
     then have "finite {i. suffix i w \<Turnstile>\<^sub>n \<psi>}"
       by (simp add: INFM_iff_infinite)
     then have "\<forall>i>Max {i. suffix i w \<Turnstile>\<^sub>n \<psi>}. \<not> suffix i w \<Turnstile>\<^sub>n \<psi>"
       using Max_ge not_le by auto
     then show ?thesis
       using j_suffix j_max by blast
   qed force
 qed
 
 lemma Alm_all_FG_G:
   "\<forall>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>) \<longleftrightarrow> suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<psi>"
   unfolding MOST_nat
 proof standard+
   fix i :: nat
   assume "suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<psi>"
   then show "suffix i w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>)"
     unfolding FG_Alm_all INFM_nat by fastforce
 next
   fix i :: nat
   assume suffix: "suffix i w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>)"
   assume max: "i > Max {i. \<not> suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<psi>}"
 
   with suffix have "\<forall>\<^sub>\<infinity>j. suffix (i + j) w \<Turnstile>\<^sub>n G\<^sub>n \<psi>"
     using FG_suffix_G[of "suffix i w"] suffix_suffix
     by fastforce
   then have "\<not> (\<exists>\<^sub>\<infinity>j. \<not> suffix j w \<Turnstile>\<^sub>n G\<^sub>n \<psi>)"
     using MOST_nat_add[of "\<lambda>i. suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<psi>" i]
     by (simp add: algebra_simps)
   then have "finite {i. \<not> suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<psi>}"
     by (simp add: INFM_iff_infinite)
 
   with max show "suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<psi>"
     using Max_ge leD by blast
 qed
 
 
 subsubsection \<open>Expansion\<close>
 
 lemma ltln_expand_Until:
   "\<xi> \<Turnstile>\<^sub>n \<phi> U\<^sub>n \<psi> \<longleftrightarrow> (\<xi> \<Turnstile>\<^sub>n \<psi> or\<^sub>n (\<phi> and\<^sub>n (X\<^sub>n (\<phi> U\<^sub>n \<psi>))))"
   (is "?lhs = ?rhs")
 proof
   assume ?lhs
   then obtain i where "suffix i \<xi> \<Turnstile>\<^sub>n \<psi>"
     and "\<forall>j<i. suffix j \<xi> \<Turnstile>\<^sub>n \<phi>"
     by auto
   thus ?rhs
     by (cases i) auto
 next
   assume ?rhs
   show ?lhs
   proof (cases "\<xi> \<Turnstile>\<^sub>n \<psi>")
     case False
     then have "\<xi> \<Turnstile>\<^sub>n \<phi>" and "\<xi> \<Turnstile>\<^sub>n X\<^sub>n (\<phi> U\<^sub>n \<psi>)"
       using `?rhs` by auto
     thus ?lhs
       using less_Suc_eq_0_disj suffix_singleton_suffix by force
   qed force
 qed
 
 lemma ltln_expand_Release:
   "\<xi> \<Turnstile>\<^sub>n \<phi> R\<^sub>n \<psi> \<longleftrightarrow> (\<xi> \<Turnstile>\<^sub>n \<psi> and\<^sub>n (\<phi> or\<^sub>n (X\<^sub>n (\<phi> R\<^sub>n \<psi>))))"
   (is "?lhs = ?rhs")
 proof
   assume ?lhs
   thus ?rhs
     using less_Suc_eq_0_disj by force
 next
   assume ?rhs
 
   {
     fix i
     assume "\<not> suffix i \<xi> \<Turnstile>\<^sub>n \<psi>"
     then have "\<exists>j<i. suffix j \<xi> \<Turnstile>\<^sub>n \<phi>"
       using `?rhs` by (cases i) force+
   }
 
   thus ?lhs
     by auto
 qed
 
 lemma ltln_expand_WeakUntil:
   "\<xi> \<Turnstile>\<^sub>n \<phi> W\<^sub>n \<psi> \<longleftrightarrow> (\<xi> \<Turnstile>\<^sub>n \<psi> or\<^sub>n (\<phi> and\<^sub>n (X\<^sub>n (\<phi> W\<^sub>n \<psi>))))"
   (is "?lhs = ?rhs")
 proof
   assume ?lhs
   thus ?rhs
     by (metis ltln_expand_Release ltln_expand_Until ltln_weak_strong(1) semantics_ltln.simps(2,5,6,7))
 next
   assume ?rhs
 
   {
     fix i
     assume "\<not> suffix i \<xi> \<Turnstile>\<^sub>n \<phi>"
     then have "\<exists>j\<le>i. suffix j \<xi> \<Turnstile>\<^sub>n \<psi>"
       using `?rhs` by (cases i) force+
   }
 
   thus ?lhs
     by auto
 qed
 
 lemma ltln_expand_StrongRelease:
   "\<xi> \<Turnstile>\<^sub>n \<phi> M\<^sub>n \<psi> \<longleftrightarrow> (\<xi> \<Turnstile>\<^sub>n \<psi> and\<^sub>n (\<phi> or\<^sub>n (X\<^sub>n (\<phi> M\<^sub>n \<psi>))))"
   (is "?lhs = ?rhs")
 proof
   assume ?lhs
   then obtain i where "suffix i \<xi> \<Turnstile>\<^sub>n \<phi>"
     and "\<forall>j\<le>i. suffix j \<xi> \<Turnstile>\<^sub>n \<psi>"
     by auto
   thus ?rhs
     by (cases i) auto
 next
   assume ?rhs
   show ?lhs
   proof (cases "\<xi> \<Turnstile>\<^sub>n \<phi>")
     case True
     thus ?lhs
       using `?rhs` ltln_expand_WeakUntil by fastforce
   next
     case False
     thus ?lhs
       by (metis `?rhs` ltln_expand_WeakUntil not\<^sub>n.simps(5,6,7,11) not\<^sub>n_semantics)
   qed
 qed
 
 lemma ltln_Release_alterdef:
   "w \<Turnstile>\<^sub>n \<phi> R\<^sub>n \<psi> \<longleftrightarrow> w \<Turnstile>\<^sub>n (G\<^sub>n \<psi>) or\<^sub>n (\<psi> U\<^sub>n (\<phi> and\<^sub>n \<psi>))"
 proof (cases "\<exists>i. \<not>suffix i w \<Turnstile>\<^sub>n \<psi>")
   case True
   define i where "i \<equiv> Least (\<lambda>i. \<not>suffix i w \<Turnstile>\<^sub>n \<psi>)"
   have "\<And>j. j < i \<Longrightarrow> suffix j w \<Turnstile>\<^sub>n \<psi>" and "\<not> suffix i w \<Turnstile>\<^sub>n \<psi>"
     using True LeastI not_less_Least unfolding i_def by fast+
   hence *: "\<forall>i. suffix i w \<Turnstile>\<^sub>n \<psi> \<or> (\<exists>j<i. suffix j w \<Turnstile>\<^sub>n \<phi>) \<Longrightarrow> (\<exists>i. (suffix i w \<Turnstile>\<^sub>n \<psi> \<and> suffix i w \<Turnstile>\<^sub>n \<phi>) \<and> (\<forall>j<i. suffix j w \<Turnstile>\<^sub>n \<psi>))"
     by fastforce
   hence "\<exists>i. (suffix i w \<Turnstile>\<^sub>n \<psi> \<and> suffix i w \<Turnstile>\<^sub>n \<phi>) \<and> (\<forall>j<i. suffix j w \<Turnstile>\<^sub>n \<psi>) \<Longrightarrow> (\<forall>i. suffix i w \<Turnstile>\<^sub>n \<psi> \<or> (\<exists>j<i. suffix j w \<Turnstile>\<^sub>n \<phi>))"
     using linorder_cases by blast
   thus ?thesis
     using True * by auto
 qed auto
 
 
 
 
 subsection \<open>LTL in restricted Negation Normal Form\<close>
 
 text \<open>Some algorithms do not handle the operators W and M,
     hence we also provide a datatype without these two operators.\<close>
 
 subsubsection \<open>Syntax\<close>
 
 datatype (atoms_ltlr: 'a) ltlr =
     True_ltlr                               ("true\<^sub>r")
   | False_ltlr                              ("false\<^sub>r")
   | Prop_ltlr 'a                            ("prop\<^sub>r'(_')")
   | Nprop_ltlr 'a                           ("nprop\<^sub>r'(_')")
   | And_ltlr "'a ltlr" "'a ltlr"            ("_ and\<^sub>r _" [82,82] 81)
   | Or_ltlr "'a ltlr" "'a ltlr"             ("_ or\<^sub>r _" [84,84] 83)
   | Next_ltlr "'a ltlr"                     ("X\<^sub>r _" [88] 87)
   | Until_ltlr "'a ltlr" "'a ltlr"          ("_ U\<^sub>r _" [84,84] 83)
   | Release_ltlr "'a ltlr" "'a ltlr"        ("_ R\<^sub>r _" [84,84] 83)
 
 
 subsubsection \<open>Semantics\<close>
 
 primrec semantics_ltlr :: "['a set word, 'a ltlr] \<Rightarrow> bool" ("_ \<Turnstile>\<^sub>r _" [80,80] 80)
 where
   "\<xi> \<Turnstile>\<^sub>r true\<^sub>r = True"
 | "\<xi> \<Turnstile>\<^sub>r false\<^sub>r = False"
 | "\<xi> \<Turnstile>\<^sub>r prop\<^sub>r(q) = (q \<in> \<xi> 0)"
 | "\<xi> \<Turnstile>\<^sub>r nprop\<^sub>r(q) = (q \<notin> \<xi> 0)"
 | "\<xi> \<Turnstile>\<^sub>r \<phi> and\<^sub>r \<psi> = (\<xi> \<Turnstile>\<^sub>r \<phi> \<and> \<xi> \<Turnstile>\<^sub>r \<psi>)"
 | "\<xi> \<Turnstile>\<^sub>r \<phi> or\<^sub>r \<psi> = (\<xi> \<Turnstile>\<^sub>r \<phi> \<or> \<xi> \<Turnstile>\<^sub>r \<psi>)"
 | "\<xi> \<Turnstile>\<^sub>r X\<^sub>r \<phi> = (suffix 1 \<xi> \<Turnstile>\<^sub>r \<phi>)"
 | "\<xi> \<Turnstile>\<^sub>r \<phi> U\<^sub>r \<psi> = (\<exists>i. suffix i \<xi> \<Turnstile>\<^sub>r \<psi> \<and> (\<forall>j<i. suffix j \<xi> \<Turnstile>\<^sub>r \<phi>))"
 | "\<xi> \<Turnstile>\<^sub>r \<phi> R\<^sub>r \<psi> = (\<forall>i. suffix i \<xi> \<Turnstile>\<^sub>r \<psi> \<or> (\<exists>j<i. suffix j \<xi> \<Turnstile>\<^sub>r \<phi>))"
 
 
 subsubsection \<open>Conversion\<close>
 
 fun ltln_to_ltlr :: "'a ltln \<Rightarrow> 'a ltlr"
 where
   "ltln_to_ltlr true\<^sub>n = true\<^sub>r"
 | "ltln_to_ltlr false\<^sub>n = false\<^sub>r"
 | "ltln_to_ltlr prop\<^sub>n(a) = prop\<^sub>r(a)"
 | "ltln_to_ltlr nprop\<^sub>n(a) = nprop\<^sub>r(a)"
 | "ltln_to_ltlr (\<phi> and\<^sub>n \<psi>) = (ltln_to_ltlr \<phi>) and\<^sub>r (ltln_to_ltlr \<psi>)"
 | "ltln_to_ltlr (\<phi> or\<^sub>n \<psi>) = (ltln_to_ltlr \<phi>) or\<^sub>r (ltln_to_ltlr \<psi>)"
 | "ltln_to_ltlr (X\<^sub>n \<phi>) = X\<^sub>r (ltln_to_ltlr \<phi>)"
 | "ltln_to_ltlr (\<phi> U\<^sub>n \<psi>) = (ltln_to_ltlr \<phi>) U\<^sub>r (ltln_to_ltlr \<psi>)"
 | "ltln_to_ltlr (\<phi> R\<^sub>n \<psi>) = (ltln_to_ltlr \<phi>) R\<^sub>r (ltln_to_ltlr \<psi>)"
 | "ltln_to_ltlr (\<phi> W\<^sub>n \<psi>) = (ltln_to_ltlr \<psi>) R\<^sub>r ((ltln_to_ltlr \<phi>) or\<^sub>r (ltln_to_ltlr \<psi>))"
 | "ltln_to_ltlr (\<phi> M\<^sub>n \<psi>) = (ltln_to_ltlr \<psi>) U\<^sub>r ((ltln_to_ltlr \<phi>) and\<^sub>r (ltln_to_ltlr \<psi>))"
 
 fun ltlr_to_ltln :: "'a ltlr \<Rightarrow> 'a ltln"
 where
   "ltlr_to_ltln true\<^sub>r = true\<^sub>n"
 | "ltlr_to_ltln false\<^sub>r = false\<^sub>n"
 | "ltlr_to_ltln prop\<^sub>r(a) = prop\<^sub>n(a)"
 | "ltlr_to_ltln nprop\<^sub>r(a) = nprop\<^sub>n(a)"
 | "ltlr_to_ltln (\<phi> and\<^sub>r \<psi>) = (ltlr_to_ltln \<phi>) and\<^sub>n (ltlr_to_ltln \<psi>)"
 | "ltlr_to_ltln (\<phi> or\<^sub>r \<psi>) = (ltlr_to_ltln \<phi>) or\<^sub>n (ltlr_to_ltln \<psi>)"
 | "ltlr_to_ltln (X\<^sub>r \<phi>) = X\<^sub>n (ltlr_to_ltln \<phi>)"
 | "ltlr_to_ltln (\<phi> U\<^sub>r \<psi>) = (ltlr_to_ltln \<phi>) U\<^sub>n (ltlr_to_ltln \<psi>)"
 | "ltlr_to_ltln (\<phi> R\<^sub>r \<psi>) = (ltlr_to_ltln \<phi>) R\<^sub>n (ltlr_to_ltln \<psi>)"
 
 lemma ltln_to_ltlr_semantics:
   "w \<Turnstile>\<^sub>r ltln_to_ltlr \<phi> \<longleftrightarrow> w \<Turnstile>\<^sub>n \<phi>"
   by (induction \<phi> arbitrary: w) (unfold ltln_WeakUntil_to_Release ltln_StrongRelease_to_Until, simp_all)
 
 lemma ltlr_to_ltln_semantics:
   "w \<Turnstile>\<^sub>n ltlr_to_ltln \<phi> \<longleftrightarrow> w \<Turnstile>\<^sub>r \<phi>"
   by (induction \<phi> arbitrary: w) simp_all
 
 
 subsubsection \<open>Negation\<close>
 
 fun not\<^sub>r
 where
   "not\<^sub>r true\<^sub>r = false\<^sub>r"
 | "not\<^sub>r false\<^sub>r = true\<^sub>r"
 | "not\<^sub>r prop\<^sub>r(a) = nprop\<^sub>r(a)"
 | "not\<^sub>r nprop\<^sub>r(a) = prop\<^sub>r(a)"
 | "not\<^sub>r (\<phi> and\<^sub>r \<psi>) = (not\<^sub>r \<phi>) or\<^sub>r (not\<^sub>r \<psi>)"
 | "not\<^sub>r (\<phi> or\<^sub>r \<psi>) = (not\<^sub>r \<phi>) and\<^sub>r (not\<^sub>r \<psi>)"
 | "not\<^sub>r (X\<^sub>r \<phi>) = X\<^sub>r (not\<^sub>r \<phi>)"
 | "not\<^sub>r (\<phi> U\<^sub>r \<psi>) = (not\<^sub>r \<phi>) R\<^sub>r (not\<^sub>r \<psi>)"
 | "not\<^sub>r (\<phi> R\<^sub>r \<psi>) = (not\<^sub>r \<phi>) U\<^sub>r (not\<^sub>r \<psi>)"
 
 lemma not\<^sub>r_semantics [simp]:
   "w \<Turnstile>\<^sub>r not\<^sub>r \<phi> \<longleftrightarrow> \<not> w \<Turnstile>\<^sub>r \<phi>"
   by (induction \<phi> arbitrary: w) auto
 
 
 subsubsection \<open>Subformulas\<close>
 
 fun subfrmlsr :: "'a ltlr \<Rightarrow> 'a ltlr set"
 where
   "subfrmlsr (\<phi> and\<^sub>r \<psi>) = {\<phi> and\<^sub>r \<psi>} \<union> subfrmlsr \<phi> \<union> subfrmlsr \<psi>"
 | "subfrmlsr (\<phi> or\<^sub>r \<psi>) = {\<phi> or\<^sub>r \<psi>} \<union> subfrmlsr \<phi> \<union> subfrmlsr \<psi>"
 | "subfrmlsr (\<phi> U\<^sub>r \<psi>) = {\<phi> U\<^sub>r \<psi>} \<union> subfrmlsr \<phi> \<union> subfrmlsr \<psi>"
 | "subfrmlsr (\<phi> R\<^sub>r \<psi>) = {\<phi> R\<^sub>r \<psi>} \<union> subfrmlsr \<phi> \<union> subfrmlsr \<psi>"
 | "subfrmlsr (X\<^sub>r \<phi>) = {X\<^sub>r \<phi>} \<union> subfrmlsr \<phi>"
 | "subfrmlsr x = {x}"
 
 lemma subfrmlsr_id[simp]:
   "\<phi> \<in> subfrmlsr \<phi>"
   by (induction \<phi>) auto
 
 lemma subfrmlsr_finite:
   "finite (subfrmlsr \<phi>)"
   by (induction \<phi>) auto
 
 lemma subfrmlsr_subset:
   "\<psi> \<in> subfrmlsr \<phi> \<Longrightarrow> subfrmlsr \<psi> \<subseteq> subfrmlsr \<phi>"
   by (induction \<phi>) auto
 
 lemma subfrmlsr_size:
   "\<psi> \<in> subfrmlsr \<phi> \<Longrightarrow> size \<psi> < size \<phi> \<or> \<psi> = \<phi>"
   by (induction \<phi>) auto
 
 
 subsubsection \<open>Expansion lemmas\<close>
 
 lemma ltlr_expand_Until:
   "\<xi> \<Turnstile>\<^sub>r \<phi> U\<^sub>r \<psi> \<longleftrightarrow> (\<xi> \<Turnstile>\<^sub>r \<psi> or\<^sub>r (\<phi> and\<^sub>r (X\<^sub>r (\<phi> U\<^sub>r \<psi>))))"
   by (metis ltln_expand_Until ltlr_to_ltln.simps(5-8) ltlr_to_ltln_semantics)
 
 lemma ltlr_expand_Release:
   "\<xi> \<Turnstile>\<^sub>r \<phi> R\<^sub>r \<psi> \<longleftrightarrow> (\<xi> \<Turnstile>\<^sub>r \<psi> and\<^sub>r (\<phi> or\<^sub>r (X\<^sub>r (\<phi> R\<^sub>r \<psi>))))"
   by (metis ltln_expand_Release ltlr_to_ltln.simps(5-7,9) ltlr_to_ltln_semantics)
 
 
 
 
 subsection \<open>Propositional LTL\<close>
 
 text \<open>We define the syntax and semantics of propositional linear-time
     temporal logic PLTL.
     PLTL formulas are built from atomic formulas, propositional connectives,
     and the temporal operators ``next'' and ``until''. The following data
     type definition is parameterized by the type of states over which
     formulas are evaluated.\<close>
 
 subsubsection \<open>Syntax\<close>
 
 datatype 'a pltl  =
     False_ltlp                       ("false\<^sub>p")
   | Atom_ltlp "'a \<Rightarrow> bool"           ("atom\<^sub>p'(_')")
   | Implies_ltlp "'a pltl" "'a pltl" ("_ implies\<^sub>p _" [81,81] 80)
   | Next_ltlp "'a pltl"              ("X\<^sub>p _" [88] 87)
   | Until_ltlp "'a pltl" "'a pltl"   ("_ U\<^sub>p _" [84,84] 83)
 
 \<comment> \<open>Further connectives of PLTL can be defined in terms of the existing syntax.\<close>
 
 definition Not_ltlp ("not\<^sub>p _" [85] 85)
 where
   "not\<^sub>p \<phi> \<equiv> \<phi> implies\<^sub>p false\<^sub>p"
 
 definition True_ltlp ("true\<^sub>p")
 where
   "true\<^sub>p \<equiv> not\<^sub>p false\<^sub>p"
 
 definition Or_ltlp ("_ or\<^sub>p _" [81,81] 80)
 where
   "\<phi> or\<^sub>p \<psi> \<equiv> (not\<^sub>p \<phi>) implies\<^sub>p \<psi>"
 
 definition And_ltlp ("_ and\<^sub>p _" [82,82] 81)
 where
   "\<phi> and\<^sub>p \<psi> \<equiv> not\<^sub>p ((not\<^sub>p \<phi>) or\<^sub>p (not\<^sub>p \<psi>))"
 
 definition Eventually_ltlp ("F\<^sub>p _" [88] 87)
 where
   "F\<^sub>p \<phi> \<equiv> true\<^sub>p U\<^sub>p \<phi>"
 
 definition Always_ltlp ("G\<^sub>p _" [88] 87)
 where
   "G\<^sub>p \<phi> \<equiv> not\<^sub>p (F\<^sub>p (not\<^sub>p \<phi>))"
 
 definition Release_ltlp ("_ R\<^sub>p _" [84,84] 83)
 where
   "\<phi> R\<^sub>p \<psi> \<equiv> not\<^sub>p ((not\<^sub>p \<phi>) U\<^sub>p (not\<^sub>p \<psi>))"
 
 definition WeakUntil_ltlp ("_ W\<^sub>p _" [84,84] 83)
 where
   "\<phi> W\<^sub>p \<psi> \<equiv> \<psi> R\<^sub>p (\<phi> or\<^sub>p \<psi>)"
 
 definition StrongRelease_ltlp ("_ M\<^sub>p _" [84,84] 83)
 where
   "\<phi> M\<^sub>p \<psi> \<equiv> \<psi> U\<^sub>p (\<phi> and\<^sub>p \<psi>)"
 
 
 subsubsection \<open>Semantics\<close>
 
 fun semantics_pltl :: "['a word, 'a pltl] \<Rightarrow> bool" ("_ \<Turnstile>\<^sub>p _" [80,80] 80)
 where
   "w \<Turnstile>\<^sub>p false\<^sub>p = False"
 | "w \<Turnstile>\<^sub>p atom\<^sub>p(p) = (p (w 0))"
 | "w \<Turnstile>\<^sub>p \<phi> implies\<^sub>p \<psi> = (w \<Turnstile>\<^sub>p \<phi> \<longrightarrow> w \<Turnstile>\<^sub>p \<psi>)"
 | "w \<Turnstile>\<^sub>p X\<^sub>p \<phi> = (suffix 1 w \<Turnstile>\<^sub>p \<phi>)"
 | "w \<Turnstile>\<^sub>p \<phi> U\<^sub>p \<psi> = (\<exists>i. suffix i w \<Turnstile>\<^sub>p \<psi> \<and> (\<forall>j<i. suffix j w \<Turnstile>\<^sub>p \<phi>))"
 
 lemma semantics_pltl_sugar [simp]:
   "w \<Turnstile>\<^sub>p not\<^sub>p \<phi> = (\<not>w \<Turnstile>\<^sub>p \<phi>)"
   "w \<Turnstile>\<^sub>p true\<^sub>p = True"
   "w \<Turnstile>\<^sub>p \<phi> or\<^sub>p \<psi> = (w \<Turnstile>\<^sub>p \<phi> \<or> w \<Turnstile>\<^sub>p \<psi>)"
   "w \<Turnstile>\<^sub>p \<phi> and\<^sub>p \<psi> = (w \<Turnstile>\<^sub>p \<phi> \<and> w \<Turnstile>\<^sub>p \<psi>)"
   "w \<Turnstile>\<^sub>p F\<^sub>p \<phi> = (\<exists>i. suffix i w \<Turnstile>\<^sub>p \<phi>)"
   "w \<Turnstile>\<^sub>p G\<^sub>p \<phi> = (\<forall>i. suffix i w \<Turnstile>\<^sub>p \<phi>)"
   "w \<Turnstile>\<^sub>p \<phi> R\<^sub>p \<psi> = (\<forall>i. suffix i w \<Turnstile>\<^sub>p \<psi> \<or> (\<exists>j<i. suffix j w \<Turnstile>\<^sub>p \<phi>))"
   "w \<Turnstile>\<^sub>p \<phi> W\<^sub>p \<psi> = (\<forall>i. suffix i w \<Turnstile>\<^sub>p \<phi> \<or> (\<exists>j\<le>i. suffix j w \<Turnstile>\<^sub>p \<psi>))"
   "w \<Turnstile>\<^sub>p \<phi> M\<^sub>p \<psi> = (\<exists>i. suffix i w \<Turnstile>\<^sub>p \<phi> \<and> (\<forall>j\<le>i. suffix j w \<Turnstile>\<^sub>p \<psi>))"
   by (auto simp: Not_ltlp_def True_ltlp_def Or_ltlp_def And_ltlp_def Eventually_ltlp_def Always_ltlp_def Release_ltlp_def WeakUntil_ltlp_def StrongRelease_ltlp_def) (insert le_neq_implies_less, blast)+
 
 definition "language_ltlp \<phi> \<equiv> {\<xi>. \<xi> \<Turnstile>\<^sub>p \<phi>}"
 
 
 subsubsection \<open>Conversion\<close>
 
 fun ltlc_to_pltl :: "'a ltlc \<Rightarrow> 'a set pltl"
 where
   "ltlc_to_pltl true\<^sub>c = true\<^sub>p"
 | "ltlc_to_pltl false\<^sub>c = false\<^sub>p"
 | "ltlc_to_pltl (prop\<^sub>c(q)) = atom\<^sub>p((\<in>) q)"
 | "ltlc_to_pltl (not\<^sub>c \<phi>) = not\<^sub>p (ltlc_to_pltl \<phi>)"
 | "ltlc_to_pltl (\<phi> and\<^sub>c \<psi>) = (ltlc_to_pltl \<phi>) and\<^sub>p (ltlc_to_pltl \<psi>)"
 | "ltlc_to_pltl (\<phi> or\<^sub>c \<psi>) = (ltlc_to_pltl \<phi>) or\<^sub>p (ltlc_to_pltl \<psi>)"
 | "ltlc_to_pltl (\<phi> implies\<^sub>c \<psi>) = (ltlc_to_pltl \<phi>) implies\<^sub>p (ltlc_to_pltl \<psi>)"
 | "ltlc_to_pltl (X\<^sub>c \<phi>) = X\<^sub>p (ltlc_to_pltl \<phi>)"
 | "ltlc_to_pltl (F\<^sub>c \<phi>) = F\<^sub>p (ltlc_to_pltl \<phi>)"
 | "ltlc_to_pltl (G\<^sub>c \<phi>) = G\<^sub>p (ltlc_to_pltl \<phi>)"
 | "ltlc_to_pltl (\<phi> U\<^sub>c \<psi>) = (ltlc_to_pltl \<phi>) U\<^sub>p (ltlc_to_pltl \<psi>)"
 | "ltlc_to_pltl (\<phi> R\<^sub>c \<psi>) = (ltlc_to_pltl \<phi>) R\<^sub>p (ltlc_to_pltl \<psi>)"
 | "ltlc_to_pltl (\<phi> W\<^sub>c \<psi>) = (ltlc_to_pltl \<phi>) W\<^sub>p (ltlc_to_pltl \<psi>)"
 | "ltlc_to_pltl (\<phi> M\<^sub>c \<psi>) = (ltlc_to_pltl \<phi>) M\<^sub>p (ltlc_to_pltl \<psi>)"
 
 lemma ltlc_to_pltl_semantics [simp]:
   "w \<Turnstile>\<^sub>p (ltlc_to_pltl \<phi>) \<longleftrightarrow> w \<Turnstile>\<^sub>c \<phi>"
   by (induction \<phi> arbitrary: w) simp_all
 
 
 subsubsection \<open>Atoms\<close>
 
 fun atoms_pltl :: "'a pltl \<Rightarrow> ('a \<Rightarrow> bool) set"
 where
   "atoms_pltl false\<^sub>p = {}"
 | "atoms_pltl atom\<^sub>p(p) = {p}"
 | "atoms_pltl (\<phi> implies\<^sub>p \<psi>) = atoms_pltl \<phi> \<union> atoms_pltl \<psi>"
 | "atoms_pltl (X\<^sub>p \<phi>) = atoms_pltl \<phi>"
 | "atoms_pltl (\<phi> U\<^sub>p \<psi>) = atoms_pltl \<phi> \<union> atoms_pltl \<psi>"
 
 lemma atoms_finite [iff]:
   "finite (atoms_pltl \<phi>)"
   by (induct \<phi>) auto
 
 lemma atoms_pltl_sugar [simp]:
   "atoms_pltl (not\<^sub>p \<phi>) = atoms_pltl \<phi>"
   "atoms_pltl true\<^sub>p = {}"
   "atoms_pltl (\<phi> or\<^sub>p \<psi>) = atoms_pltl \<phi> \<union> atoms_pltl \<psi>"
   "atoms_pltl (\<phi> and\<^sub>p \<psi>) = atoms_pltl \<phi> \<union> atoms_pltl \<psi>"
   "atoms_pltl (F\<^sub>p \<phi>) = atoms_pltl \<phi>"
   "atoms_pltl (G\<^sub>p \<phi>) = atoms_pltl \<phi>"
   by (auto simp: Not_ltlp_def True_ltlp_def Or_ltlp_def And_ltlp_def Eventually_ltlp_def Always_ltlp_def)
 
 end
diff --git a/thys/LTL_Master_Theorem/Logical_Characterization/Advice.thy b/thys/LTL_Master_Theorem/Logical_Characterization/Advice.thy
--- a/thys/LTL_Master_Theorem/Logical_Characterization/Advice.thy
+++ b/thys/LTL_Master_Theorem/Logical_Characterization/Advice.thy
@@ -1,539 +1,996 @@
 (*
     Author:   Benedikt Seidl
+    Author:   Salomon Sickert
     License:  BSD
 *)
 
 section \<open>Advice functions\<close>
 
 theory Advice
 imports
   LTL.LTL LTL.Equivalence_Relations
   Syntactic_Fragments_and_Stability After
 begin
 
 subsection \<open>The GF and FG Advice Functions\<close>
 
 fun GF_advice :: "'a ltln \<Rightarrow> 'a ltln set \<Rightarrow> 'a ltln" ("_[_]\<^sub>\<nu>" [90,60] 89)
   where
   "(X\<^sub>n \<psi>)[X]\<^sub>\<nu> = X\<^sub>n (\<psi>[X]\<^sub>\<nu>)"
 | "(\<psi>\<^sub>1 and\<^sub>n \<psi>\<^sub>2)[X]\<^sub>\<nu> = (\<psi>\<^sub>1[X]\<^sub>\<nu>) and\<^sub>n (\<psi>\<^sub>2[X]\<^sub>\<nu>)"
 | "(\<psi>\<^sub>1 or\<^sub>n \<psi>\<^sub>2)[X]\<^sub>\<nu> = (\<psi>\<^sub>1[X]\<^sub>\<nu>) or\<^sub>n (\<psi>\<^sub>2[X]\<^sub>\<nu>)"
 | "(\<psi>\<^sub>1 W\<^sub>n \<psi>\<^sub>2)[X]\<^sub>\<nu> = (\<psi>\<^sub>1[X]\<^sub>\<nu>) W\<^sub>n (\<psi>\<^sub>2[X]\<^sub>\<nu>)"
 | "(\<psi>\<^sub>1 R\<^sub>n \<psi>\<^sub>2)[X]\<^sub>\<nu> = (\<psi>\<^sub>1[X]\<^sub>\<nu>) R\<^sub>n (\<psi>\<^sub>2[X]\<^sub>\<nu>)"
 | "(\<psi>\<^sub>1 U\<^sub>n \<psi>\<^sub>2)[X]\<^sub>\<nu> = (if (\<psi>\<^sub>1 U\<^sub>n \<psi>\<^sub>2) \<in> X then (\<psi>\<^sub>1[X]\<^sub>\<nu>) W\<^sub>n (\<psi>\<^sub>2[X]\<^sub>\<nu>) else false\<^sub>n)"
 | "(\<psi>\<^sub>1 M\<^sub>n \<psi>\<^sub>2)[X]\<^sub>\<nu> = (if (\<psi>\<^sub>1 M\<^sub>n \<psi>\<^sub>2) \<in> X then (\<psi>\<^sub>1[X]\<^sub>\<nu>) R\<^sub>n (\<psi>\<^sub>2[X]\<^sub>\<nu>) else false\<^sub>n)"
 | "\<phi>[_]\<^sub>\<nu> = \<phi>"
 
 fun FG_advice :: "'a ltln \<Rightarrow> 'a ltln set \<Rightarrow> 'a ltln" ("_[_]\<^sub>\<mu>" [90,60] 89)
 where
   "(X\<^sub>n \<psi>)[Y]\<^sub>\<mu> = X\<^sub>n (\<psi>[Y]\<^sub>\<mu>)"
 | "(\<psi>\<^sub>1 and\<^sub>n \<psi>\<^sub>2)[Y]\<^sub>\<mu> = (\<psi>\<^sub>1[Y]\<^sub>\<mu>) and\<^sub>n (\<psi>\<^sub>2[Y]\<^sub>\<mu>)"
 | "(\<psi>\<^sub>1 or\<^sub>n \<psi>\<^sub>2)[Y]\<^sub>\<mu> = (\<psi>\<^sub>1[Y]\<^sub>\<mu>) or\<^sub>n (\<psi>\<^sub>2[Y]\<^sub>\<mu>)"
 | "(\<psi>\<^sub>1 U\<^sub>n \<psi>\<^sub>2)[Y]\<^sub>\<mu> = (\<psi>\<^sub>1[Y]\<^sub>\<mu>) U\<^sub>n (\<psi>\<^sub>2[Y]\<^sub>\<mu>)"
 | "(\<psi>\<^sub>1 M\<^sub>n \<psi>\<^sub>2)[Y]\<^sub>\<mu> = (\<psi>\<^sub>1[Y]\<^sub>\<mu>) M\<^sub>n (\<psi>\<^sub>2[Y]\<^sub>\<mu>)"
 | "(\<psi>\<^sub>1 W\<^sub>n \<psi>\<^sub>2)[Y]\<^sub>\<mu> = (if (\<psi>\<^sub>1 W\<^sub>n \<psi>\<^sub>2) \<in> Y then true\<^sub>n else (\<psi>\<^sub>1[Y]\<^sub>\<mu>) U\<^sub>n (\<psi>\<^sub>2[Y]\<^sub>\<mu>))"
 | "(\<psi>\<^sub>1 R\<^sub>n \<psi>\<^sub>2)[Y]\<^sub>\<mu> = (if (\<psi>\<^sub>1 R\<^sub>n \<psi>\<^sub>2) \<in> Y then true\<^sub>n else (\<psi>\<^sub>1[Y]\<^sub>\<mu>) M\<^sub>n (\<psi>\<^sub>2[Y]\<^sub>\<mu>))"
 | "\<phi>[_]\<^sub>\<mu> = \<phi>"
 
 lemma GF_advice_\<nu>LTL:
   "\<phi>[X]\<^sub>\<nu> \<in> \<nu>LTL"
   "\<phi> \<in> \<nu>LTL \<Longrightarrow> \<phi>[X]\<^sub>\<nu> = \<phi>"
   by (induction \<phi>) auto
 
 lemma FG_advice_\<mu>LTL:
   "\<phi>[X]\<^sub>\<mu> \<in> \<mu>LTL"
   "\<phi> \<in> \<mu>LTL \<Longrightarrow> \<phi>[X]\<^sub>\<mu> = \<phi>"
   by (induction \<phi>) auto
 
 
 lemma GF_advice_subfrmlsn:
   "subfrmlsn (\<phi>[X]\<^sub>\<nu>) \<subseteq> {\<psi>[X]\<^sub>\<nu> | \<psi>. \<psi> \<in> subfrmlsn \<phi>}"
   by (induction \<phi>) force+
 
 lemma FG_advice_subfrmlsn:
   "subfrmlsn (\<phi>[Y]\<^sub>\<mu>) \<subseteq> {\<psi>[Y]\<^sub>\<mu> | \<psi>. \<psi> \<in> subfrmlsn \<phi>}"
   by (induction \<phi>) force+
 
 lemma GF_advice_subfrmlsn_card:
   "card (subfrmlsn (\<phi>[X]\<^sub>\<nu>)) \<le> card (subfrmlsn \<phi>)"
 proof -
   have "card (subfrmlsn (\<phi>[X]\<^sub>\<nu>)) \<le> card {\<psi>[X]\<^sub>\<nu> | \<psi>. \<psi> \<in> subfrmlsn \<phi>}"
     by (simp add: subfrmlsn_finite GF_advice_subfrmlsn card_mono)
 
   also have "\<dots> \<le> card (subfrmlsn \<phi>)"
     by (metis Collect_mem_eq card_image_le image_Collect subfrmlsn_finite)
 
   finally show ?thesis .
 qed
 
 lemma FG_advice_subfrmlsn_card:
   "card (subfrmlsn (\<phi>[Y]\<^sub>\<mu>)) \<le> card (subfrmlsn \<phi>)"
 proof -
   have "card (subfrmlsn (\<phi>[Y]\<^sub>\<mu>)) \<le> card {\<psi>[Y]\<^sub>\<mu> | \<psi>. \<psi> \<in> subfrmlsn \<phi>}"
     by (simp add: subfrmlsn_finite FG_advice_subfrmlsn card_mono)
 
   also have "\<dots> \<le> card (subfrmlsn \<phi>)"
     by (metis Collect_mem_eq card_image_le image_Collect subfrmlsn_finite)
 
   finally show ?thesis .
 qed
 
+lemma GF_advice_monotone:
+  "X \<subseteq> Y \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>[X]\<^sub>\<nu> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>[Y]\<^sub>\<nu>"
+proof (induction \<phi> arbitrary: w)
+  case (Until_ltln \<phi> \<psi>)
+  then show ?case
+    by (cases "\<phi> U\<^sub>n \<psi> \<in> X") (simp_all, blast)
+next
+  case (Release_ltln \<phi> \<psi>)
+  then show ?case by (simp, blast)
+next
+  case (WeakUntil_ltln \<phi> \<psi>)
+  then show ?case by (simp, blast)
+next
+  case (StrongRelease_ltln \<phi> \<psi>)
+  then show ?case
+    by (cases "\<phi> M\<^sub>n \<psi> \<in> X") (simp_all, blast)
+qed auto
 
+lemma FG_advice_monotone:
+  "X \<subseteq> Y \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>[X]\<^sub>\<mu> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>[Y]\<^sub>\<mu>"
+proof (induction \<phi> arbitrary: w)
+  case (Until_ltln \<phi> \<psi>)
+  then show ?case by (simp, blast)
+next
+  case (Release_ltln \<phi> \<psi>)
+  then show ?case
+    by (cases "\<phi> R\<^sub>n \<psi> \<in> X") (auto, blast)
+next
+  case (WeakUntil_ltln \<phi> \<psi>)
+  then show ?case
+    by (cases "\<phi> W\<^sub>n \<psi> \<in> X") (auto, blast)
+next
+  case (StrongRelease_ltln \<phi> \<psi>)
+  then show ?case by (simp, blast)
+qed auto
+
+lemma GF_advice_ite_simps[simp]:
+  "(if P then true\<^sub>n else false\<^sub>n)[X]\<^sub>\<nu> = (if P then true\<^sub>n else false\<^sub>n)"
+  "(if P then false\<^sub>n else true\<^sub>n)[X]\<^sub>\<nu> = (if P then false\<^sub>n else true\<^sub>n)"
+  by simp_all
+
+lemma FG_advice_ite_simps[simp]:
+  "(if P then true\<^sub>n else false\<^sub>n)[Y]\<^sub>\<mu> = (if P then true\<^sub>n else false\<^sub>n)"
+  "(if P then false\<^sub>n else true\<^sub>n)[Y]\<^sub>\<mu> = (if P then false\<^sub>n else true\<^sub>n)"
+  by simp_all
 
 subsection \<open>Advice Functions on Nested Propositions\<close>
 
 definition nested_prop_atoms\<^sub>\<nu> :: "'a ltln \<Rightarrow> 'a ltln set \<Rightarrow> 'a ltln set"
 where
   "nested_prop_atoms\<^sub>\<nu> \<phi> X = {\<psi>[X]\<^sub>\<nu> | \<psi>. \<psi> \<in> nested_prop_atoms \<phi>}"
 
 definition nested_prop_atoms\<^sub>\<mu> :: "'a ltln \<Rightarrow> 'a ltln set \<Rightarrow> 'a ltln set"
 where
   "nested_prop_atoms\<^sub>\<mu> \<phi> X = {\<psi>[X]\<^sub>\<mu> | \<psi>. \<psi> \<in> nested_prop_atoms \<phi>}"
 
 lemma nested_prop_atoms\<^sub>\<nu>_finite:
   "finite (nested_prop_atoms\<^sub>\<nu> \<phi> X)"
   by (simp add: nested_prop_atoms\<^sub>\<nu>_def nested_prop_atoms_finite)
 
 lemma nested_prop_atoms\<^sub>\<mu>_finite:
   "finite (nested_prop_atoms\<^sub>\<mu> \<phi> X)"
   by (simp add: nested_prop_atoms\<^sub>\<mu>_def nested_prop_atoms_finite)
 
 lemma nested_prop_atoms\<^sub>\<nu>_card:
   "card (nested_prop_atoms\<^sub>\<nu> \<phi> X) \<le> card (nested_prop_atoms \<phi>)"
   unfolding nested_prop_atoms\<^sub>\<nu>_def
   by (metis Collect_mem_eq card_image_le image_Collect nested_prop_atoms_finite)
 
 lemma nested_prop_atoms\<^sub>\<mu>_card:
   "card (nested_prop_atoms\<^sub>\<mu> \<phi> X) \<le> card (nested_prop_atoms \<phi>)"
   unfolding nested_prop_atoms\<^sub>\<mu>_def
   by (metis Collect_mem_eq card_image_le image_Collect nested_prop_atoms_finite)
 
 lemma GF_advice_nested_prop_atoms\<^sub>\<nu>:
   "nested_prop_atoms (\<phi>[X]\<^sub>\<nu>) \<subseteq> nested_prop_atoms\<^sub>\<nu> \<phi> X"
   by (induction \<phi>) (unfold nested_prop_atoms\<^sub>\<nu>_def, force+)
 
 lemma FG_advice_nested_prop_atoms\<^sub>\<mu>:
   "nested_prop_atoms (\<phi>[Y]\<^sub>\<mu>) \<subseteq> nested_prop_atoms\<^sub>\<mu> \<phi> Y"
   by (induction \<phi>) (unfold nested_prop_atoms\<^sub>\<mu>_def, force+)
 
+lemma nested_prop_atoms\<^sub>\<nu>_subset:
+  "nested_prop_atoms \<phi> \<subseteq> nested_prop_atoms \<psi> \<Longrightarrow> nested_prop_atoms\<^sub>\<nu> \<phi> X \<subseteq> nested_prop_atoms\<^sub>\<nu> \<psi> X"
+  unfolding nested_prop_atoms\<^sub>\<nu>_def by blast
+
+lemma nested_prop_atoms\<^sub>\<mu>_subset:
+  "nested_prop_atoms \<phi> \<subseteq> nested_prop_atoms \<psi> \<Longrightarrow> nested_prop_atoms\<^sub>\<mu> \<phi> Y \<subseteq> nested_prop_atoms\<^sub>\<mu> \<psi> Y"
+  unfolding nested_prop_atoms\<^sub>\<mu>_def by blast
+
 lemma GF_advice_nested_prop_atoms_card:
   "card (nested_prop_atoms (\<phi>[X]\<^sub>\<nu>)) \<le> card (nested_prop_atoms \<phi>)"
 proof -
   have "card (nested_prop_atoms (\<phi>[X]\<^sub>\<nu>)) \<le> card (nested_prop_atoms\<^sub>\<nu> \<phi> X)"
     by (simp add: nested_prop_atoms\<^sub>\<nu>_finite GF_advice_nested_prop_atoms\<^sub>\<nu> card_mono)
 
   then show ?thesis
     using nested_prop_atoms\<^sub>\<nu>_card le_trans by blast
 qed
 
 lemma FG_advice_nested_prop_atoms_card:
   "card (nested_prop_atoms (\<phi>[Y]\<^sub>\<mu>)) \<le> card (nested_prop_atoms \<phi>)"
 proof -
   have "card (nested_prop_atoms (\<phi>[Y]\<^sub>\<mu>)) \<le> card (nested_prop_atoms\<^sub>\<mu> \<phi> Y)"
     by (simp add: nested_prop_atoms\<^sub>\<mu>_finite FG_advice_nested_prop_atoms\<^sub>\<mu> card_mono)
 
   then show ?thesis
     using nested_prop_atoms\<^sub>\<mu>_card le_trans by blast
 qed
 
 
 
 subsection \<open>Intersecting the Advice Set\<close>
 
 lemma GF_advice_inter:
   "X \<inter> subformulas\<^sub>\<mu> \<phi> \<subseteq> S \<Longrightarrow> \<phi>[X \<inter> S]\<^sub>\<nu> = \<phi>[X]\<^sub>\<nu>"
   by (induction \<phi>) auto
 
 lemma GF_advice_inter_subformulas:
   "\<phi>[X \<inter> subformulas\<^sub>\<mu> \<phi>]\<^sub>\<nu> = \<phi>[X]\<^sub>\<nu>"
   using GF_advice_inter by blast
 
 lemma GF_advice_minus_subformulas:
   "\<psi> \<notin> subformulas\<^sub>\<mu> \<phi> \<Longrightarrow> \<phi>[X - {\<psi>}]\<^sub>\<nu> = \<phi>[X]\<^sub>\<nu>"
 proof -
   assume "\<psi> \<notin> subformulas\<^sub>\<mu> \<phi>"
   then have "subformulas\<^sub>\<mu> \<phi> \<inter> X \<subseteq> X - {\<psi>}"
     by blast
   then show "\<phi>[X - {\<psi>}]\<^sub>\<nu> = \<phi>[X]\<^sub>\<nu>"
     by (metis GF_advice_inter Diff_subset Int_absorb1 inf.commute)
 qed
 
 lemma GF_advice_minus_size:
   "\<lbrakk>size \<phi> \<le> size \<psi>; \<phi> \<noteq> \<psi>\<rbrakk> \<Longrightarrow> \<phi>[X - {\<psi>}]\<^sub>\<nu> = \<phi>[X]\<^sub>\<nu>"
   using subfrmlsn_size subformulas\<^sub>\<mu>_subfrmlsn GF_advice_minus_subformulas
   by fastforce
 
 
 lemma FG_advice_inter:
   "Y \<inter> subformulas\<^sub>\<nu> \<phi> \<subseteq> S \<Longrightarrow> \<phi>[Y \<inter> S]\<^sub>\<mu> = \<phi>[Y]\<^sub>\<mu>"
   by (induction \<phi>) auto
 
 lemma FG_advice_inter_subformulas:
   "\<phi>[Y \<inter> subformulas\<^sub>\<nu> \<phi>]\<^sub>\<mu> = \<phi>[Y]\<^sub>\<mu>"
   using FG_advice_inter by blast
 
 lemma FG_advice_minus_subformulas:
   "\<psi> \<notin> subformulas\<^sub>\<nu> \<phi> \<Longrightarrow> \<phi>[Y - {\<psi>}]\<^sub>\<mu> = \<phi>[Y]\<^sub>\<mu>"
 proof -
   assume "\<psi> \<notin> subformulas\<^sub>\<nu> \<phi>"
   then have "subformulas\<^sub>\<nu> \<phi> \<inter> Y \<subseteq> Y - {\<psi>}"
     by blast
   then show "\<phi>[Y - {\<psi>}]\<^sub>\<mu>  = \<phi>[Y]\<^sub>\<mu>"
     by (metis FG_advice_inter Diff_subset Int_absorb1 inf.commute)
 qed
 
 lemma FG_advice_minus_size:
   "\<lbrakk>size \<phi> \<le> size \<psi>; \<phi> \<noteq> \<psi>\<rbrakk> \<Longrightarrow> \<phi>[Y - {\<psi>}]\<^sub>\<mu> = \<phi>[Y]\<^sub>\<mu>"
   using subfrmlsn_size subformulas\<^sub>\<nu>_subfrmlsn FG_advice_minus_subformulas
   by fastforce
 
 lemma FG_advice_insert:
   "\<lbrakk>\<psi> \<notin> Y; size \<phi> < size \<psi>\<rbrakk> \<Longrightarrow> \<phi>[insert \<psi> Y]\<^sub>\<mu> = \<phi>[Y]\<^sub>\<mu>"
   by (metis FG_advice_minus_size Diff_insert_absorb less_imp_le neq_iff)
 
 
 
 subsection \<open>Correctness GF-advice function\<close>
 
 lemma GF_advice_a1:
   "\<lbrakk>\<F> \<phi> w \<subseteq> X; w \<Turnstile>\<^sub>n \<phi>\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>[X]\<^sub>\<nu>"
 proof (induction \<phi> arbitrary: w)
   case (Next_ltln \<phi>)
   then show ?case
     using \<F>_suffix by simp blast
 next
   case (Until_ltln \<phi>1 \<phi>2)
 
   have "\<F> (\<phi>1 W\<^sub>n \<phi>2) w \<subseteq> \<F> (\<phi>1 U\<^sub>n \<phi>2) w"
     by fastforce
   then have "\<F> (\<phi>1 W\<^sub>n \<phi>2) w \<subseteq> X" and "w \<Turnstile>\<^sub>n \<phi>1 W\<^sub>n \<phi>2"
     using Until_ltln.prems ltln_strong_to_weak by blast+
   then have "w \<Turnstile>\<^sub>n \<phi>1[X]\<^sub>\<nu> W\<^sub>n \<phi>2[X]\<^sub>\<nu>"
     using Until_ltln.IH
     by simp (meson \<F>_suffix subset_trans sup.boundedE)
 
   moreover
 
   have "w \<Turnstile>\<^sub>n \<phi>1 U\<^sub>n \<phi>2"
     using Until_ltln.prems by simp
   then have "\<phi>1 U\<^sub>n \<phi>2 \<in> \<F> (\<phi>1 U\<^sub>n \<phi>2) w"
     by force
   then have "\<phi>1 U\<^sub>n \<phi>2 \<in> X"
     using Until_ltln.prems by fast
 
   ultimately show ?case
     by auto
 next
   case (Release_ltln \<phi>1 \<phi>2)
   then show ?case
     by simp (meson \<F>_suffix subset_trans sup.boundedE)
 next
   case (WeakUntil_ltln \<phi>1 \<phi>2)
   then show ?case
     by simp (meson \<F>_suffix subset_trans sup.boundedE)
 next
   case (StrongRelease_ltln \<phi>1 \<phi>2)
 
   have "\<F> (\<phi>1 R\<^sub>n \<phi>2) w \<subseteq> \<F> (\<phi>1 M\<^sub>n \<phi>2) w"
     by fastforce
   then have "\<F> (\<phi>1 R\<^sub>n \<phi>2) w \<subseteq> X" and "w \<Turnstile>\<^sub>n \<phi>1 R\<^sub>n \<phi>2"
     using StrongRelease_ltln.prems ltln_strong_to_weak by blast+
   then have "w \<Turnstile>\<^sub>n \<phi>1[X]\<^sub>\<nu> R\<^sub>n \<phi>2[X]\<^sub>\<nu>"
     using StrongRelease_ltln.IH
     by simp (meson \<F>_suffix subset_trans sup.boundedE)
 
   moreover
 
   have "w \<Turnstile>\<^sub>n \<phi>1 M\<^sub>n \<phi>2"
     using StrongRelease_ltln.prems by simp
   then have "\<phi>1 M\<^sub>n \<phi>2 \<in> \<F> (\<phi>1 M\<^sub>n \<phi>2) w"
     by force
   then have "\<phi>1 M\<^sub>n \<phi>2 \<in> X"
     using StrongRelease_ltln.prems by fast
 
   ultimately show ?case
     by auto
 qed auto
 
 lemma GF_advice_a2_helper:
   "\<lbrakk>\<forall>\<psi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>); w \<Turnstile>\<^sub>n \<phi>[X]\<^sub>\<nu>\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>"
 proof (induction \<phi> arbitrary: w)
   case (Next_ltln \<phi>)
   then show ?case
     unfolding GF_advice.simps semantics_ltln.simps(7)
     using GF_suffix by blast
 next
   case (Until_ltln \<phi>1 \<phi>2)
 
   then have "\<phi>1 U\<^sub>n \<phi>2 \<in> X"
     using ccontr[of "\<phi>1 U\<^sub>n \<phi>2 \<in> X"] by force
   then have "w \<Turnstile>\<^sub>n F\<^sub>n \<phi>2"
     using Until_ltln.prems by fastforce
 
   moreover
 
   have "w \<Turnstile>\<^sub>n (\<phi>1 U\<^sub>n \<phi>2)[X]\<^sub>\<nu>"
     using Until_ltln.prems by simp
   then have "w \<Turnstile>\<^sub>n (\<phi>1[X]\<^sub>\<nu>) W\<^sub>n (\<phi>2[X]\<^sub>\<nu>)"
     unfolding GF_advice.simps using `\<phi>1 U\<^sub>n \<phi>2 \<in> X` by simp
   then have "w \<Turnstile>\<^sub>n \<phi>1 W\<^sub>n \<phi>2"
     unfolding GF_advice.simps semantics_ltln.simps(10)
     by (metis GF_suffix Until_ltln.IH Until_ltln.prems(1))
 
   ultimately show ?case
     using ltln_weak_to_strong by blast
 next
   case (Release_ltln \<phi>1 \<phi>2)
   then show ?case
     unfolding GF_advice.simps semantics_ltln.simps(9)
     by (metis GF_suffix Release_ltln.IH Release_ltln.prems(1))
 next
   case (WeakUntil_ltln \<phi>1 \<phi>2)
   then show ?case
     unfolding GF_advice.simps semantics_ltln.simps(10)
     by (metis GF_suffix)
 next
   case (StrongRelease_ltln \<phi>1 \<phi>2)
 
   then have "\<phi>1 M\<^sub>n \<phi>2 \<in> X"
     using ccontr[of "\<phi>1 M\<^sub>n \<phi>2 \<in> X"] by force
   then have "w \<Turnstile>\<^sub>n F\<^sub>n \<phi>1"
     using StrongRelease_ltln.prems by fastforce
 
   moreover
 
   have "w \<Turnstile>\<^sub>n (\<phi>1 M\<^sub>n \<phi>2)[X]\<^sub>\<nu>"
     using StrongRelease_ltln.prems by simp
   then have "w \<Turnstile>\<^sub>n (\<phi>1[X]\<^sub>\<nu>) R\<^sub>n (\<phi>2[X]\<^sub>\<nu>)"
     unfolding GF_advice.simps using `\<phi>1 M\<^sub>n \<phi>2 \<in> X` by simp
   then have "w \<Turnstile>\<^sub>n \<phi>1 R\<^sub>n \<phi>2"
     unfolding GF_advice.simps semantics_ltln.simps(9)
     by (metis GF_suffix StrongRelease_ltln.IH StrongRelease_ltln.prems(1))
 
   ultimately show ?case
     using ltln_weak_to_strong by blast
 qed auto
 
 lemma GF_advice_a2:
   "\<lbrakk>X \<subseteq> \<G>\<F> \<phi> w; w \<Turnstile>\<^sub>n \<phi>[X]\<^sub>\<nu>\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>"
   by (metis GF_advice_a2_helper \<G>\<F>_elim subset_eq)
 
 lemma GF_advice_a3:
   "\<lbrakk>X = \<F> \<phi> w; X = \<G>\<F> \<phi> w\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> \<longleftrightarrow> w \<Turnstile>\<^sub>n \<phi>[X]\<^sub>\<nu>"
   using GF_advice_a1 GF_advice_a2 by fastforce
 
 
 
 subsection \<open>Correctness FG-advice function\<close>
 
 lemma FG_advice_b1:
   "\<lbrakk>\<F>\<G> \<phi> w \<subseteq> Y; w \<Turnstile>\<^sub>n \<phi>\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>[Y]\<^sub>\<mu>"
 proof (induction \<phi> arbitrary: w)
   case (Next_ltln \<phi>)
   then show ?case
     using \<F>\<G>_suffix by simp blast
 next
   case (Until_ltln \<phi>1 \<phi>2)
   then show ?case
     by simp (metis \<F>\<G>_suffix)
 next
   case (Release_ltln \<phi>1 \<phi>2)
 
   show ?case
   proof (cases "\<phi>1 R\<^sub>n \<phi>2 \<in> Y")
     case False
     then have "\<phi>1 R\<^sub>n \<phi>2 \<notin> \<F>\<G> (\<phi>1 R\<^sub>n \<phi>2) w"
       using Release_ltln.prems by blast
     then have "\<not> w \<Turnstile>\<^sub>n G\<^sub>n \<phi>2"
       by fastforce
     then have "w \<Turnstile>\<^sub>n \<phi>1 M\<^sub>n \<phi>2"
       using Release_ltln.prems ltln_weak_to_strong by blast
 
     moreover
 
     have "\<F>\<G> (\<phi>1 M\<^sub>n \<phi>2) w \<subseteq> \<F>\<G> (\<phi>1 R\<^sub>n \<phi>2) w"
       by fastforce
     then have "\<F>\<G> (\<phi>1 M\<^sub>n \<phi>2) w \<subseteq> Y"
       using Release_ltln.prems by blast
 
     ultimately show ?thesis
       using Release_ltln.IH by simp (metis \<F>\<G>_suffix)
   qed simp
 next
   case (WeakUntil_ltln \<phi>1 \<phi>2)
 
   show ?case
   proof (cases "\<phi>1 W\<^sub>n \<phi>2 \<in> Y")
     case False
     then have "\<phi>1 W\<^sub>n \<phi>2 \<notin> \<F>\<G> (\<phi>1 W\<^sub>n \<phi>2) w"
       using WeakUntil_ltln.prems by blast
     then have "\<not> w \<Turnstile>\<^sub>n G\<^sub>n \<phi>1"
       by fastforce
     then have "w \<Turnstile>\<^sub>n \<phi>1 U\<^sub>n \<phi>2"
       using WeakUntil_ltln.prems ltln_weak_to_strong by blast
 
     moreover
 
     have "\<F>\<G> (\<phi>1 U\<^sub>n \<phi>2) w \<subseteq> \<F>\<G> (\<phi>1 W\<^sub>n \<phi>2) w"
       by fastforce
     then have "\<F>\<G> (\<phi>1 U\<^sub>n \<phi>2) w \<subseteq> Y"
       using WeakUntil_ltln.prems by blast
 
     ultimately show ?thesis
       using WeakUntil_ltln.IH by simp (metis \<F>\<G>_suffix)
   qed simp
 next
   case (StrongRelease_ltln \<phi>1 \<phi>2)
   then show ?case
     by simp (metis \<F>\<G>_suffix)
 qed auto
 
 lemma FG_advice_b2_helper:
   "\<lbrakk>\<forall>\<psi> \<in> Y. w \<Turnstile>\<^sub>n G\<^sub>n \<psi>; w \<Turnstile>\<^sub>n \<phi>[Y]\<^sub>\<mu>\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>"
 proof (induction \<phi> arbitrary: w)
   case (Until_ltln \<phi>1 \<phi>2)
   then show ?case
     by simp (metis (no_types, lifting) suffix_suffix)
 next
   case (Release_ltln \<phi>1 \<phi>2)
   then show ?case
   proof (cases "\<phi>1 R\<^sub>n \<phi>2 \<in> Y")
     case True
     then show ?thesis
       using Release_ltln.prems by force
   next
     case False
     then have "w \<Turnstile>\<^sub>n (\<phi>1[Y]\<^sub>\<mu>) M\<^sub>n (\<phi>2[Y]\<^sub>\<mu>)"
       using Release_ltln.prems by simp
     then have "w \<Turnstile>\<^sub>n \<phi>1 M\<^sub>n \<phi>2"
       using Release_ltln
       by simp (metis (no_types, lifting) suffix_suffix)
     then show ?thesis
       using ltln_strong_to_weak by fast
   qed
 next
   case (WeakUntil_ltln \<phi>1 \<phi>2)
   then show ?case
   proof (cases "\<phi>1 W\<^sub>n \<phi>2 \<in> Y")
     case True
     then show ?thesis
       using WeakUntil_ltln.prems by force
   next
     case False
     then have "w \<Turnstile>\<^sub>n (\<phi>1[Y]\<^sub>\<mu>) U\<^sub>n (\<phi>2[Y]\<^sub>\<mu>)"
       using WeakUntil_ltln.prems by simp
     then have "w \<Turnstile>\<^sub>n \<phi>1 U\<^sub>n \<phi>2"
       using WeakUntil_ltln
       by simp (metis (no_types, lifting) suffix_suffix)
     then show ?thesis
       using ltln_strong_to_weak by fast
   qed
 next
   case (StrongRelease_ltln \<phi>1 \<phi>2)
   then show ?case
     by simp (metis (no_types, lifting) suffix_suffix)
 qed auto
 
 lemma FG_advice_b2:
   "\<lbrakk>Y \<subseteq> \<G> \<phi> w; w \<Turnstile>\<^sub>n \<phi>[Y]\<^sub>\<mu>\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>"
   by (metis FG_advice_b2_helper \<G>_elim subset_eq)
 
 lemma FG_advice_b3:
   "\<lbrakk>Y = \<F>\<G> \<phi> w; Y = \<G> \<phi> w\<rbrakk> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> \<longleftrightarrow> w \<Turnstile>\<^sub>n \<phi>[Y]\<^sub>\<mu>"
   using FG_advice_b1 FG_advice_b2 by fastforce
 
 
 
-subsection \<open>Advice functions and the after function\<close>
+subsection \<open>Advice Functions and the ``after'' Function\<close>
 
 lemma GF_advice_af_letter:
   "(x ## w) \<Turnstile>\<^sub>n \<phi>[X]\<^sub>\<nu> \<Longrightarrow> w \<Turnstile>\<^sub>n (af_letter \<phi> x)[X]\<^sub>\<nu>"
 proof (induction \<phi>)
   case (Until_ltln \<phi>1 \<phi>2)
 
   then have "w \<Turnstile>\<^sub>n af_letter ((\<phi>1 U\<^sub>n \<phi>2)[X]\<^sub>\<nu>) x"
     using af_letter_build by blast
 
   then show ?case
     using Until_ltln.IH af_letter_build by fastforce
 next
   case (Release_ltln \<phi>1 \<phi>2)
 
   then have "w \<Turnstile>\<^sub>n af_letter ((\<phi>1 R\<^sub>n \<phi>2)[X]\<^sub>\<nu>) x"
     using af_letter_build by blast
 
   then show ?case
     using Release_ltln.IH af_letter_build by auto
 next
   case (WeakUntil_ltln \<phi>1 \<phi>2)
 
   then have "w \<Turnstile>\<^sub>n af_letter ((\<phi>1 W\<^sub>n \<phi>2)[X]\<^sub>\<nu>) x"
     using af_letter_build by blast
 
   then show ?case
     using WeakUntil_ltln.IH af_letter_build by auto
 next
   case (StrongRelease_ltln \<phi>1 \<phi>2)
 
   then have "w \<Turnstile>\<^sub>n af_letter ((\<phi>1 M\<^sub>n \<phi>2)[X]\<^sub>\<nu>) x"
     using af_letter_build by blast
 
   then show ?case
     using StrongRelease_ltln.IH af_letter_build by force
 qed auto
 
+lemma FG_advice_af_letter:
+  "w \<Turnstile>\<^sub>n (af_letter \<phi> x)[Y]\<^sub>\<mu> \<Longrightarrow> (x ## w) \<Turnstile>\<^sub>n \<phi>[Y]\<^sub>\<mu>"
+proof (induction \<phi>)
+  case (Prop_ltln a)
+  then show ?case
+    using semantics_ltln.simps(3) by fastforce
+next
+  case (Until_ltln \<phi>1 \<phi>2)
+  then show ?case
+    unfolding af_letter.simps FG_advice.simps semantics_ltln.simps(5,6)
+    using af_letter_build apply (cases "w \<Turnstile>\<^sub>n af_letter \<phi>2 x[Y]\<^sub>\<mu>") apply force
+    by (metis af_letter.simps(8) semantics_ltln.simps(5) semantics_ltln.simps(6))
+next
+  case (Release_ltln \<phi>1 \<phi>2)
+  then show ?case
+    apply (cases "\<phi>1 R\<^sub>n \<phi>2 \<in> Y")
+    apply simp
+    unfolding af_letter.simps FG_advice.simps semantics_ltln.simps(5,6)
+    using af_letter_build  apply (cases "w \<Turnstile>\<^sub>n af_letter \<phi>1 x[Y]\<^sub>\<mu>") apply force
+    by (metis (full_types) af_letter.simps(11) semantics_ltln.simps(5) semantics_ltln.simps(6))
+next
+  case (WeakUntil_ltln \<phi>1 \<phi>2)
+  then show ?case
+    apply (cases "\<phi>1 W\<^sub>n \<phi>2 \<in> Y")
+    apply simp
+    unfolding af_letter.simps FG_advice.simps semantics_ltln.simps(5,6)
+    using af_letter_build  apply (cases "w \<Turnstile>\<^sub>n af_letter \<phi>2 x[Y]\<^sub>\<mu>") apply force
+    by (metis (full_types) af_letter.simps(8) semantics_ltln.simps(5) semantics_ltln.simps(6))
+next
+  case (StrongRelease_ltln \<phi>1 \<phi>2)
+  then show ?case
+    unfolding af_letter.simps FG_advice.simps semantics_ltln.simps(5,6)
+    using af_letter_build apply (cases "w \<Turnstile>\<^sub>n af_letter \<phi>1 x[Y]\<^sub>\<mu>") apply force
+    by (metis af_letter.simps(11) semantics_ltln.simps(5) semantics_ltln.simps(6))
+qed auto
+
 lemma GF_advice_af:
   "(w \<frown> w') \<Turnstile>\<^sub>n \<phi>[X]\<^sub>\<nu> \<Longrightarrow> w' \<Turnstile>\<^sub>n (af \<phi> w)[X]\<^sub>\<nu>"
   by (induction w arbitrary: \<phi>) (simp, insert GF_advice_af_letter, fastforce)
 
+lemma FG_advice_af:
+  "w' \<Turnstile>\<^sub>n (af \<phi> w)[X]\<^sub>\<mu> \<Longrightarrow> (w \<frown> w') \<Turnstile>\<^sub>n \<phi>[X]\<^sub>\<mu>"
+  by (induction w arbitrary: \<phi>) (simp, insert FG_advice_af_letter, fastforce)
+
+lemma GF_advice_af_2:
+  "w \<Turnstile>\<^sub>n \<phi>[X]\<^sub>\<nu> \<Longrightarrow> suffix i w \<Turnstile>\<^sub>n (af \<phi> (prefix i w))[X]\<^sub>\<nu>"
+  using GF_advice_af by force
+
+lemma FG_advice_af_2:
+  "suffix i w \<Turnstile>\<^sub>n (af \<phi> (prefix i w))[X]\<^sub>\<mu> \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>[X]\<^sub>\<mu>"
+  using FG_advice_af by force
+
+(* TODO move to Omega_Words_Fun.thy ?? *)
+lemma prefix_suffix_subsequence: "prefix i (suffix j w) = (w [j \<rightarrow> i + j])"
+  by (simp add: add.commute)
+
+text \<open>We show this generic lemma to prove the following theorems:\<close>
+
+lemma GF_advice_sync:
+  fixes index :: "nat \<Rightarrow> nat"
+  fixes formula :: "nat \<Rightarrow> 'a ltln"
+  assumes "\<And>i. i < n \<Longrightarrow> \<exists>j. suffix ((index i) + j) w \<Turnstile>\<^sub>n af (formula i) (w [index i \<rightarrow> (index i) + j])[X]\<^sub>\<nu>"
+  shows "\<exists>k. (\<forall>i < n. k \<ge> index i \<and> suffix k w \<Turnstile>\<^sub>n af (formula i) (w [index i \<rightarrow> k])[X]\<^sub>\<nu>)"
+  using assms
+proof (induction n)
+  case (Suc n)
+
+  obtain k1 where leq1: "\<And>i. i < n \<Longrightarrow> k1 \<ge> index i"
+    and suffix1: "\<And>i. i < n \<Longrightarrow> suffix k1 w \<Turnstile>\<^sub>n af (formula i) (w [(index i) \<rightarrow> k1])[X]\<^sub>\<nu>"
+    using Suc less_SucI by blast
+
+  obtain k2 where leq2: "k2 \<ge> index n"
+    and suffix2: "suffix k2 w \<Turnstile>\<^sub>n af (formula n) (w [index n \<rightarrow> k2])[X]\<^sub>\<nu>"
+    using le_add1 Suc.prems by blast
+
+  define k where "k \<equiv> k1 + k2"
+
+  have "\<And>i. i < Suc n \<Longrightarrow> k \<ge> index i"
+    unfolding k_def by (metis leq1 leq2 less_SucE trans_le_add1 trans_le_add2)
+
+  moreover
+
+  {
+    have "\<And>i. i < n \<Longrightarrow> suffix k w \<Turnstile>\<^sub>n af (formula i) (w [(index i) \<rightarrow> k])[X]\<^sub>\<nu>"
+      unfolding k_def
+      by (metis GF_advice_af_2[OF suffix1, unfolded suffix_suffix prefix_suffix_subsequence] af_subsequence_append leq1 add.commute le_add1)
+
+    moreover
+
+    have "suffix k w \<Turnstile>\<^sub>n af (formula n) (w [index n \<rightarrow> k])[X]\<^sub>\<nu>"
+      unfolding k_def
+      by (metis GF_advice_af_2[OF suffix2, unfolded suffix_suffix prefix_suffix_subsequence] af_subsequence_append leq2 add.commute le_add1)
+
+    ultimately
+
+    have "\<And>i. i \<le> n \<Longrightarrow> suffix k w \<Turnstile>\<^sub>n af (formula i) (w [(index i) \<rightarrow> k])[X]\<^sub>\<nu>"
+      using nat_less_le by blast
+  }
+
+  ultimately
+
+  show ?case
+    by (meson less_Suc_eq_le)
+qed simp
+
+lemma GF_advice_sync_and:
+  assumes "\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[X]\<^sub>\<nu>"
+  assumes "\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<psi> (prefix i w)[X]\<^sub>\<nu>"
+  shows "\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[X]\<^sub>\<nu> \<and> suffix i w \<Turnstile>\<^sub>n af \<psi> (prefix i w)[X]\<^sub>\<nu>"
+proof -
+  let ?formula = "\<lambda>i :: nat. (if (i = 0) then \<phi> else \<psi>)"
+
+  have assms: "\<And>i. i < 2 \<Longrightarrow> \<exists>j. suffix j w \<Turnstile>\<^sub>n af (?formula i) (w [0 \<rightarrow> j])[X]\<^sub>\<nu>"
+    using assms by simp
+  obtain k where k_def: "\<And>i :: nat. i < 2 \<Longrightarrow> suffix k w \<Turnstile>\<^sub>n af (if i = 0 then \<phi> else \<psi>) (prefix k w)[X]\<^sub>\<nu>"
+    using GF_advice_sync[of "2" "\<lambda>i. 0" w ?formula, simplified, OF assms, simplified] by blast
+  show ?thesis
+    using k_def[of 0] k_def[of 1] by auto
+qed
+
+lemma GF_advice_sync_less:
+  assumes "\<And>i. i < n \<Longrightarrow> \<exists>j. suffix (i + j) w \<Turnstile>\<^sub>n af \<phi> (w [i \<rightarrow> j + i])[X]\<^sub>\<nu>"
+  assumes "\<exists>j. suffix (n + j) w \<Turnstile>\<^sub>n af \<psi> (w [n \<rightarrow> j + n])[X]\<^sub>\<nu>"
+  shows "\<exists>k \<ge> n. (\<forall>j < n. suffix k w \<Turnstile>\<^sub>n af \<phi> (w [j \<rightarrow> k])[X]\<^sub>\<nu>) \<and> suffix k w \<Turnstile>\<^sub>n af \<psi> (w [n \<rightarrow> k])[X]\<^sub>\<nu>"
+proof -
+  let ?index = "\<lambda>i. min i n"
+  let ?formula = "\<lambda>i. if (i < n) then \<phi> else \<psi>"
+
+  {
+    fix i
+    assume "i < Suc n"
+    then have min_def: "min i n = i"
+      by simp
+    have "\<exists>j. suffix ((?index i) + j) w \<Turnstile>\<^sub>n af (?formula i) (w [?index i \<rightarrow> (?index i) + j])[X]\<^sub>\<nu>"
+      unfolding min_def
+      by (cases "i < n")
+         (metis (full_types) assms(1) add.commute, metis (full_types) assms(2) \<open>i < Suc n\<close> add.commute  less_SucE)
+  }
+
+  then obtain k where leq: "(\<And>i. i < Suc n \<Longrightarrow> min i n \<le> k)"
+    and suffix: "\<And>i. i < Suc n \<Longrightarrow> suffix k w \<Turnstile>\<^sub>n af (if i < n then \<phi> else \<psi>) (w [min i n \<rightarrow> k])[X]\<^sub>\<nu>"
+    using GF_advice_sync[of "Suc n" ?index w ?formula X] by metis
+
+  have "\<forall>j < n. suffix k w \<Turnstile>\<^sub>n af \<phi> (w [j \<rightarrow> k])[X]\<^sub>\<nu>"
+    using suffix by (metis (full_types) less_SucI min.strict_order_iff)
+
+  moreover
+
+  have "suffix k w \<Turnstile>\<^sub>n af \<psi> (w [n \<rightarrow> k])[X]\<^sub>\<nu>"
+    using suffix[of n, simplified] by blast
+
+  moreover
+
+  have "k \<ge> n"
+    using leq by presburger
+
+  ultimately
+  show ?thesis
+    by auto
+qed
+
+lemma GF_advice_sync_lesseq:
+  assumes "\<And>i. i \<le> n \<Longrightarrow> \<exists>j. suffix (i + j) w \<Turnstile>\<^sub>n af \<phi> (w [i \<rightarrow> j + i])[X]\<^sub>\<nu>"
+  assumes "\<exists>j. suffix (n + j) w \<Turnstile>\<^sub>n af \<psi> (w [n \<rightarrow> j + n])[X]\<^sub>\<nu>"
+  shows "\<exists>k \<ge> n. (\<forall>j \<le> n. suffix k w \<Turnstile>\<^sub>n af \<phi> (w [j \<rightarrow> k])[X]\<^sub>\<nu>) \<and> suffix k w \<Turnstile>\<^sub>n af \<psi> (w [n \<rightarrow> k])[X]\<^sub>\<nu>"
+proof -
+  let ?index = "\<lambda>i. min i n"
+  let ?formula = "\<lambda>i. if (i \<le> n) then \<phi> else \<psi>"
+
+  {
+    fix i
+    assume "i < Suc (Suc n)"
+    hence "\<exists>j. suffix ((?index i) + j) w \<Turnstile>\<^sub>n af (?formula i) (w [?index i \<rightarrow> (?index i) + j])[X]\<^sub>\<nu>"
+    proof (cases "i < Suc n")
+      case True
+      then have min_def: "min i n = i"
+        by simp
+      show ?thesis
+        unfolding min_def by (metis (full_types) assms(1) Suc_leI Suc_le_mono True add.commute)
+    next
+      case False
+      then have i_def: "i = Suc n"
+        using \<open>i < Suc (Suc n)\<close> less_antisym by blast
+      have min_def: "min i n = n"
+        unfolding i_def by simp
+      show ?thesis
+        using assms(2) False
+        by (simp add: min_def add.commute)
+    qed
+  }
+
+  then obtain k where leq: "(\<And>i. i \<le> Suc n \<Longrightarrow> min i n \<le> k)"
+    and suffix: "\<And>i :: nat. i < Suc (Suc n) \<Longrightarrow> suffix k w \<Turnstile>\<^sub>n af (if i \<le> n then \<phi> else \<psi>) (w [min i n \<rightarrow> k])[X]\<^sub>\<nu>"
+    using GF_advice_sync[of "Suc (Suc n)" ?index w ?formula X]
+    by (metis (no_types, hide_lams) less_Suc_eq min_le_iff_disj)
+
+  have "\<forall>j \<le> n. suffix k w \<Turnstile>\<^sub>n af \<phi> (w [j \<rightarrow> k])[X]\<^sub>\<nu>"
+    using suffix by (metis (full_types) le_SucI less_Suc_eq_le min.orderE)
+
+  moreover
+
+  have "suffix k w \<Turnstile>\<^sub>n af \<psi> (w [n \<rightarrow> k])[X]\<^sub>\<nu>"
+    using suffix[of "Suc n", simplified] by linarith
+
+  moreover
+
+  have "k \<ge> n"
+    using leq by presburger
+
+  ultimately
+  show ?thesis
+    by auto
+qed
+
+lemma af_subsequence_U_GF_advice:
+  assumes "i \<le> n"
+  assumes "suffix n w \<Turnstile>\<^sub>n ((af \<psi> (w [i \<rightarrow> n]))[X]\<^sub>\<nu>)"
+  assumes "\<And>j. j < i \<Longrightarrow> suffix n w \<Turnstile>\<^sub>n ((af \<phi> (w [j \<rightarrow> n]))[X]\<^sub>\<nu>)"
+  shows "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> U\<^sub>n \<psi>) (prefix (Suc n) w))[X]\<^sub>\<nu>"
+  using assms
+proof (induction i arbitrary: w n)
+  case 0
+  then have A: "suffix n w \<Turnstile>\<^sub>n ((af \<psi> (w [0 \<rightarrow> n]))[X]\<^sub>\<nu>)"
+    by blast
+  then have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<psi> (w [0 \<rightarrow> Suc n]))[X]\<^sub>\<nu>"
+    using GF_advice_af_2[OF A, of 1] by simp
+  then show ?case
+    unfolding GF_advice.simps af_subsequence_U semantics_ltln.simps by blast
+next
+  case (Suc i)
+  have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<phi> (prefix (Suc n) w))[X]\<^sub>\<nu>"
+    using Suc.prems(3)[OF zero_less_Suc, THEN GF_advice_af_2, unfolded suffix_suffix, of 1]
+    by simp
+  moreover
+  have B: "(Suc (n - 1)) = n"
+    using Suc by simp
+  note Suc.IH[of "n - 1" "suffix 1 w", unfolded suffix_suffix] Suc.prems
+  then have "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> U\<^sub>n \<psi>) (w [1 \<rightarrow> (Suc n)]))[X]\<^sub>\<nu>"
+    by (metis B One_nat_def Suc_le_mono Suc_mono plus_1_eq_Suc subsequence_shift)
+  ultimately
+  show ?case
+    unfolding af_subsequence_U semantics_ltln.simps GF_advice.simps by blast
+qed
+
+lemma af_subsequence_M_GF_advice:
+  assumes "i \<le> n"
+  assumes "suffix n w \<Turnstile>\<^sub>n ((af \<phi> (w [i \<rightarrow> n]))[X]\<^sub>\<nu>)"
+  assumes "\<And>j. j \<le> i \<Longrightarrow> suffix n w \<Turnstile>\<^sub>n ((af \<psi> (w [j \<rightarrow> n]))[X]\<^sub>\<nu>)"
+  shows "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> M\<^sub>n \<psi>) (prefix (Suc n) w))[X]\<^sub>\<nu>"
+  using assms
+proof (induction i arbitrary: w n)
+  case 0
+  then have A: "suffix n w \<Turnstile>\<^sub>n ((af \<psi> (w [0 \<rightarrow> n]))[X]\<^sub>\<nu>)"
+    by blast
+  have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<psi> (w [0 \<rightarrow> Suc n]))[X]\<^sub>\<nu>"
+    using GF_advice_af_2[OF A, of 1] by simp
+  moreover
+  have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<phi> (w [0 \<rightarrow> Suc n]))[X]\<^sub>\<nu>"
+    using GF_advice_af_2[OF "0.prems"(2), of 1, unfolded suffix_suffix] by auto
+  ultimately
+  show ?case
+    unfolding af_subsequence_M GF_advice.simps semantics_ltln.simps by blast
+next
+  case (Suc i)
+  have "suffix 1 (suffix n w) \<Turnstile>\<^sub>n af (af \<psi> (prefix n w)) [suffix n w 0][X]\<^sub>\<nu>"
+    by (metis (no_types) GF_advice_af_2 Suc.prems(3) plus_1_eq_Suc subsequence_singleton suffix_0 suffix_suffix zero_le)
+  then have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<psi> (prefix (Suc n) w))[X]\<^sub>\<nu>"
+    using Suc.prems(3)[THEN GF_advice_af_2, unfolded suffix_suffix, of 1] by simp
+  moreover
+  have B: "(Suc (n - 1)) = n"
+    using Suc by simp
+  note Suc.IH[of _ "suffix 1 w", unfolded subsequence_shift suffix_suffix]
+  then have "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> M\<^sub>n \<psi>) (w [1 \<rightarrow> (Suc n)]))[X]\<^sub>\<nu>"
+    by (metis B One_nat_def Suc_le_mono plus_1_eq_Suc Suc.prems)
+  ultimately
+  show ?case
+    unfolding af_subsequence_M semantics_ltln.simps GF_advice.simps by blast
+qed
+
+lemma af_subsequence_R_GF_advice:
+  assumes "i \<le> n"
+  assumes "suffix n w \<Turnstile>\<^sub>n ((af \<phi> (w [i \<rightarrow> n]))[X]\<^sub>\<nu>)"
+  assumes "\<And>j. j \<le> i \<Longrightarrow> suffix n w \<Turnstile>\<^sub>n ((af \<psi> (w [j \<rightarrow> n]))[X]\<^sub>\<nu>)"
+  shows "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> R\<^sub>n \<psi>) (prefix (Suc n) w))[X]\<^sub>\<nu>"
+  using assms
+proof (induction i arbitrary: w n)
+  case 0
+  then have A: "suffix n w \<Turnstile>\<^sub>n ((af \<psi> (w [0 \<rightarrow> n]))[X]\<^sub>\<nu>)"
+    by blast
+  have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<psi> (w [0 \<rightarrow> Suc n]))[X]\<^sub>\<nu>"
+    using GF_advice_af_2[OF A, of 1] by simp
+  moreover
+  have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<phi> (w [0 \<rightarrow> Suc n]))[X]\<^sub>\<nu>"
+    using GF_advice_af_2[OF "0.prems"(2), of 1, unfolded suffix_suffix] by auto
+  ultimately
+  show ?case
+    unfolding af_subsequence_R GF_advice.simps semantics_ltln.simps by blast
+next
+  case (Suc i)
+  have "suffix 1 (suffix n w) \<Turnstile>\<^sub>n af (af \<psi> (prefix n w)) [suffix n w 0][X]\<^sub>\<nu>"
+    by (metis (no_types) GF_advice_af_2 Suc.prems(3) plus_1_eq_Suc subsequence_singleton suffix_0 suffix_suffix zero_le)
+  then have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<psi> (prefix (Suc n) w))[X]\<^sub>\<nu>"
+    using Suc.prems(3)[THEN GF_advice_af_2, unfolded suffix_suffix, of 1] by simp
+  moreover
+  have B: "(Suc (n - 1)) = n"
+    using Suc by simp
+  note Suc.IH[of _ "suffix 1 w", unfolded subsequence_shift suffix_suffix]
+  then have "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> R\<^sub>n \<psi>) (w [1 \<rightarrow> (Suc n)]))[X]\<^sub>\<nu>"
+    by (metis B One_nat_def Suc_le_mono plus_1_eq_Suc Suc.prems)
+  ultimately
+  show ?case
+    unfolding af_subsequence_R semantics_ltln.simps GF_advice.simps by blast
+qed
+
+lemma af_subsequence_W_GF_advice:
+  assumes "i \<le> n"
+  assumes "suffix n w \<Turnstile>\<^sub>n ((af \<psi> (w [i \<rightarrow> n]))[X]\<^sub>\<nu>)"
+  assumes "\<And>j. j < i \<Longrightarrow> suffix n w \<Turnstile>\<^sub>n ((af \<phi> (w [j \<rightarrow> n]))[X]\<^sub>\<nu>)"
+  shows "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> W\<^sub>n \<psi>) (prefix (Suc n) w))[X]\<^sub>\<nu>"
+  using assms
+proof (induction i arbitrary: w n)
+  case 0
+  then have A: "suffix n w \<Turnstile>\<^sub>n ((af \<psi> (w [0 \<rightarrow> n]))[X]\<^sub>\<nu>)"
+    by blast
+  have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<psi> (w [0 \<rightarrow> Suc n]))[X]\<^sub>\<nu>"
+    using GF_advice_af_2[OF A, of 1] by simp
+  then show ?case
+    unfolding af_subsequence_W GF_advice.simps semantics_ltln.simps by blast
+next
+  case (Suc i)
+  have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<phi> (prefix (Suc n) w))[X]\<^sub>\<nu>"
+    using Suc.prems(3)[OF zero_less_Suc, THEN GF_advice_af_2, unfolded suffix_suffix, of 1]
+    by simp
+  moreover
+  have B: "(Suc (n - 1)) = n"
+    using Suc by simp
+  note Suc.IH[of "n - 1" "suffix 1 w", unfolded suffix_suffix] Suc.prems
+  then have "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> W\<^sub>n \<psi>) (w [1 \<rightarrow> (Suc n)]))[X]\<^sub>\<nu>"
+    by (metis B One_nat_def Suc_le_mono Suc_mono plus_1_eq_Suc subsequence_shift)
+  ultimately
+  show ?case
+    unfolding af_subsequence_W unfolding semantics_ltln.simps GF_advice.simps by simp
+qed
+
+lemma af_subsequence_R_GF_advice_connect:
+  assumes "i \<le> n"
+  assumes "suffix n w \<Turnstile>\<^sub>n af (\<phi> R\<^sub>n \<psi>) (w [i \<rightarrow> n])[X]\<^sub>\<nu>"
+  assumes "\<And>j. j \<le> i \<Longrightarrow> suffix n w \<Turnstile>\<^sub>n ((af \<psi> (w [j \<rightarrow> n]))[X]\<^sub>\<nu>)"
+  shows "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> R\<^sub>n \<psi>) (prefix (Suc n) w))[X]\<^sub>\<nu>"
+  using assms
+proof (induction i arbitrary: w n)
+  case 0
+  then have A: "suffix n w \<Turnstile>\<^sub>n ((af \<psi> (w [0 \<rightarrow> n]))[X]\<^sub>\<nu>)"
+    by blast
+  have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<psi> (w [0 \<rightarrow> Suc n]))[X]\<^sub>\<nu>"
+    using GF_advice_af_2[OF A, of 1] by simp
+  moreover
+  have "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> R\<^sub>n \<psi>) (w [0 \<rightarrow> Suc n]))[X]\<^sub>\<nu>"
+    using GF_advice_af_2[OF "0.prems"(2), of 1, unfolded suffix_suffix] by simp
+  ultimately
+  show ?case
+    unfolding af_subsequence_R GF_advice.simps semantics_ltln.simps by blast
+next
+  case (Suc i)
+  have "suffix 1 (suffix n w) \<Turnstile>\<^sub>n af (af \<psi> (prefix n w)) [suffix n w 0][X]\<^sub>\<nu>"
+    by (metis (no_types) GF_advice_af_2 Suc.prems(3) plus_1_eq_Suc subsequence_singleton suffix_0 suffix_suffix zero_le)
+  then have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<psi> (prefix (Suc n) w))[X]\<^sub>\<nu>"
+    using Suc.prems(3)[THEN GF_advice_af_2, unfolded suffix_suffix, of 1] by simp
+  moreover
+  have B: "(Suc (n - 1)) = n"
+    using Suc by simp
+  note Suc.IH[of _ "suffix 1 w", unfolded subsequence_shift suffix_suffix]
+  then have "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> R\<^sub>n \<psi>) (w [1 \<rightarrow> (Suc n)]))[X]\<^sub>\<nu>"
+    by (metis B One_nat_def Suc_le_mono plus_1_eq_Suc Suc.prems)
+  ultimately
+  show ?case
+    unfolding af_subsequence_R semantics_ltln.simps GF_advice.simps by blast
+qed
+
+lemma af_subsequence_W_GF_advice_connect:
+  assumes "i \<le> n"
+  assumes "suffix n w \<Turnstile>\<^sub>n af (\<phi> W\<^sub>n \<psi>) (w [i \<rightarrow> n])[X]\<^sub>\<nu>"
+  assumes "\<And>j. j < i \<Longrightarrow> suffix n w \<Turnstile>\<^sub>n ((af \<phi> (w [j \<rightarrow> n]))[X]\<^sub>\<nu>)"
+  shows "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> W\<^sub>n \<psi>) (prefix (Suc n) w))[X]\<^sub>\<nu>"
+  using assms
+proof (induction i arbitrary: w n)
+  case 0
+  have "suffix (Suc n) w \<Turnstile>\<^sub>n af_letter (af (\<phi> W\<^sub>n \<psi>) (prefix n w)) (w n)[X]\<^sub>\<nu>"
+    by (simp add: "0.prems"(2) GF_advice_af_letter)
+  moreover
+  have "prefix (Suc n) w = prefix n w @ [w n]"
+    using subseq_to_Suc by blast
+  ultimately show ?case
+    by (metis (no_types) foldl.simps(1) foldl.simps(2) foldl_append)
+next
+  case (Suc i)
+  have "suffix (Suc n) w \<Turnstile>\<^sub>n (af \<phi> (prefix (Suc n) w))[X]\<^sub>\<nu>"
+    using Suc.prems(3)[OF zero_less_Suc, THEN GF_advice_af_2, unfolded suffix_suffix, of 1] by simp
+  moreover
+  have "n > 0" and B: "(Suc (n - 1)) = n"
+    using Suc by simp+
+  note Suc.IH[of "n - 1" "suffix 1 w", unfolded suffix_suffix] Suc.prems
+  then have "suffix (Suc n) w \<Turnstile>\<^sub>n (af (\<phi> W\<^sub>n \<psi>) (w [1 \<rightarrow> (Suc n)]))[X]\<^sub>\<nu>"
+    by (metis B One_nat_def Suc_le_mono Suc_mono plus_1_eq_Suc subsequence_shift)
+  ultimately
+  show ?case
+    unfolding af_subsequence_W unfolding semantics_ltln.simps GF_advice.simps by simp
+qed
 
 
 subsection \<open>Advice Functions and Propositional Entailment\<close>
 
 lemma GF_advice_prop_entailment:
   "\<A> \<Turnstile>\<^sub>P \<phi>[X]\<^sub>\<nu> \<Longrightarrow> {\<psi>. \<psi>[X]\<^sub>\<nu> \<in> \<A>} \<Turnstile>\<^sub>P \<phi>"
   "false\<^sub>n \<notin> \<A> \<Longrightarrow> {\<psi>. \<psi>[X]\<^sub>\<nu> \<in> \<A>} \<Turnstile>\<^sub>P \<phi> \<Longrightarrow> \<A> \<Turnstile>\<^sub>P \<phi>[X]\<^sub>\<nu>"
   by (induction \<phi>) (auto, meson, meson)
 
 lemma GF_advice_iff_prop_entailment:
   "false\<^sub>n \<notin> \<A> \<Longrightarrow> \<A> \<Turnstile>\<^sub>P \<phi>[X]\<^sub>\<nu> \<longleftrightarrow> {\<psi>. \<psi>[X]\<^sub>\<nu> \<in> \<A>} \<Turnstile>\<^sub>P \<phi>"
   by (metis GF_advice_prop_entailment)
 
 lemma FG_advice_prop_entailment:
   "true\<^sub>n \<in> \<A> \<Longrightarrow> \<A> \<Turnstile>\<^sub>P \<phi>[Y]\<^sub>\<mu> \<Longrightarrow> {\<psi>. \<psi>[Y]\<^sub>\<mu> \<in> \<A>} \<Turnstile>\<^sub>P \<phi>"
   "{\<psi>. \<psi>[Y]\<^sub>\<mu> \<in> \<A>} \<Turnstile>\<^sub>P \<phi> \<Longrightarrow> \<A> \<Turnstile>\<^sub>P \<phi>[Y]\<^sub>\<mu>"
   by (induction \<phi>) auto
 
 lemma FG_advice_iff_prop_entailment:
   "true\<^sub>n \<in> \<A> \<Longrightarrow> \<A> \<Turnstile>\<^sub>P \<phi>[X]\<^sub>\<mu> \<longleftrightarrow> {\<psi>. \<psi>[X]\<^sub>\<mu> \<in> \<A>} \<Turnstile>\<^sub>P \<phi>"
   by (metis FG_advice_prop_entailment)
 
 lemma GF_advice_subst:
   "\<phi>[X]\<^sub>\<nu> = subst \<phi> (\<lambda>\<psi>. Some (\<psi>[X]\<^sub>\<nu>))"
   by (induction \<phi>) auto
 
 lemma FG_advice_subst:
   "\<phi>[X]\<^sub>\<mu> = subst \<phi> (\<lambda>\<psi>. Some (\<psi>[X]\<^sub>\<mu>))"
   by (induction \<phi>) auto
 
 lemma GF_advice_prop_congruent:
   "\<phi> \<longrightarrow>\<^sub>P \<psi> \<Longrightarrow> \<phi>[X]\<^sub>\<nu> \<longrightarrow>\<^sub>P \<psi>[X]\<^sub>\<nu>"
   "\<phi> \<sim>\<^sub>P \<psi> \<Longrightarrow> \<phi>[X]\<^sub>\<nu> \<sim>\<^sub>P \<psi>[X]\<^sub>\<nu>"
   by (metis GF_advice_subst subst_respects_ltl_prop_entailment)+
 
 lemma FG_advice_prop_congruent:
   "\<phi> \<longrightarrow>\<^sub>P \<psi> \<Longrightarrow> \<phi>[X]\<^sub>\<mu> \<longrightarrow>\<^sub>P \<psi>[X]\<^sub>\<mu>"
   "\<phi> \<sim>\<^sub>P \<psi> \<Longrightarrow> \<phi>[X]\<^sub>\<mu> \<sim>\<^sub>P \<psi>[X]\<^sub>\<mu>"
   by (metis FG_advice_subst subst_respects_ltl_prop_entailment)+
 
 locale GF_advice_congruent = ltl_equivalence +
   assumes
     GF_advice_congruent: "\<phi> \<sim> \<psi> \<Longrightarrow> \<phi>[X]\<^sub>\<nu> \<sim> \<psi>[X]\<^sub>\<nu>"
 begin
 
 end
 
 interpretation prop_GF_advice_compatible: GF_advice_congruent "(\<sim>\<^sub>P)"
   by unfold_locales (simp add: GF_advice_prop_congruent(2))
 
 end
diff --git a/thys/LTL_Master_Theorem/Logical_Characterization/After.thy b/thys/LTL_Master_Theorem/Logical_Characterization/After.thy
--- a/thys/LTL_Master_Theorem/Logical_Characterization/After.thy
+++ b/thys/LTL_Master_Theorem/Logical_Characterization/After.thy
@@ -1,695 +1,719 @@
 (*
     Author:   Benedikt Seidl
     License:  BSD
 *)
 
 section \<open>The ``after''-Function\<close>
 
 theory After
-imports 
+imports
   LTL.LTL LTL.Equivalence_Relations Syntactic_Fragments_and_Stability
 begin
 
 subsection \<open>Definition of af\<close>
 
 primrec af_letter :: "'a ltln \<Rightarrow> 'a set \<Rightarrow> 'a ltln"
 where
   "af_letter true\<^sub>n \<nu> = true\<^sub>n"
 | "af_letter false\<^sub>n \<nu> = false\<^sub>n"
 | "af_letter prop\<^sub>n(a) \<nu> = (if a \<in> \<nu> then true\<^sub>n else false\<^sub>n)"
 | "af_letter nprop\<^sub>n(a) \<nu>  = (if a \<notin> \<nu> then true\<^sub>n else false\<^sub>n)"
 | "af_letter (\<phi> and\<^sub>n \<psi>) \<nu> = (af_letter \<phi> \<nu>) and\<^sub>n (af_letter \<psi> \<nu>)"
 | "af_letter (\<phi> or\<^sub>n \<psi>) \<nu> = (af_letter \<phi> \<nu>) or\<^sub>n (af_letter \<psi> \<nu>)"
 | "af_letter (X\<^sub>n \<phi>) \<nu> = \<phi>"
 | "af_letter (\<phi> U\<^sub>n \<psi>) \<nu> = (af_letter \<psi> \<nu>) or\<^sub>n ((af_letter \<phi> \<nu>) and\<^sub>n (\<phi> U\<^sub>n \<psi>))"
 | "af_letter (\<phi> R\<^sub>n \<psi>) \<nu> = (af_letter \<psi> \<nu>) and\<^sub>n ((af_letter \<phi> \<nu>) or\<^sub>n (\<phi> R\<^sub>n \<psi>))"
 | "af_letter (\<phi> W\<^sub>n \<psi>) \<nu> = (af_letter \<psi> \<nu>) or\<^sub>n ((af_letter \<phi> \<nu>) and\<^sub>n (\<phi> W\<^sub>n \<psi>))"
 | "af_letter (\<phi> M\<^sub>n \<psi>) \<nu> = (af_letter \<psi> \<nu>) and\<^sub>n ((af_letter \<phi> \<nu>) or\<^sub>n (\<phi> M\<^sub>n \<psi>))"
 
 abbreviation af :: "'a ltln \<Rightarrow> 'a set list \<Rightarrow> 'a ltln"
 where
   "af \<phi> w \<equiv> foldl af_letter \<phi> w"
 
 
 lemma af_decompose:
   "af (\<phi> and\<^sub>n \<psi>) w = (af \<phi> w) and\<^sub>n (af \<psi> w)"
   "af (\<phi> or\<^sub>n \<psi>) w = (af \<phi> w) or\<^sub>n (af \<psi> w)"
   by (induction w rule: rev_induct) simp_all
 
 lemma af_simps[simp]:
   "af true\<^sub>n w = true\<^sub>n"
   "af false\<^sub>n w = false\<^sub>n"
   "af (X\<^sub>n \<phi>) (x # xs) = af \<phi> xs"
   by (induction w) simp_all
 
+lemma af_ite_simps[simp]:
+  "af (if P then true\<^sub>n else false\<^sub>n) w = (if P then true\<^sub>n else false\<^sub>n)"
+  "af (if P then false\<^sub>n else true\<^sub>n) w = (if P then false\<^sub>n else true\<^sub>n)"
+  by simp_all
+
+lemma af_subsequence_append:
+  "i \<le> j \<Longrightarrow> j \<le> k \<Longrightarrow> af (af \<phi> (w [i \<rightarrow> j])) (w [j \<rightarrow> k]) = af \<phi> (w [i \<rightarrow> k])"
+  by (metis foldl_append le_Suc_ex map_append subsequence_def upt_add_eq_append)
+
 lemma af_subsequence_U:
   "af (\<phi> U\<^sub>n \<psi>) (w [0 \<rightarrow> Suc n]) = (af \<psi> (w [0 \<rightarrow> Suc n])) or\<^sub>n ((af \<phi> (w [0 \<rightarrow> Suc n])) and\<^sub>n af (\<phi> U\<^sub>n \<psi>) (w [1 \<rightarrow> Suc n]))"
   by (induction n) fastforce+
 
+lemma af_subsequence_U':
+  "af (\<phi> U\<^sub>n \<psi>) (a # xs) = (af \<psi> (a # xs)) or\<^sub>n ((af \<phi> (a # xs)) and\<^sub>n af (\<phi> U\<^sub>n \<psi>) xs)"
+  by (simp add: af_decompose)
+
 lemma af_subsequence_R:
   "af (\<phi> R\<^sub>n \<psi>) (w [0 \<rightarrow> Suc n]) = (af \<psi> (w [0 \<rightarrow> Suc n])) and\<^sub>n ((af \<phi> (w [0 \<rightarrow> Suc n])) or\<^sub>n af (\<phi> R\<^sub>n \<psi>) (w [1 \<rightarrow> Suc n]))"
   by (induction n) fastforce+
 
+lemma af_subsequence_R':
+  "af (\<phi> R\<^sub>n \<psi>) (a # xs) = (af \<psi> (a # xs)) and\<^sub>n ((af \<phi> (a # xs)) or\<^sub>n af (\<phi> R\<^sub>n \<psi>) xs)"
+  by (simp add: af_decompose)
+
 lemma af_subsequence_W:
   "af (\<phi> W\<^sub>n \<psi>) (w [0 \<rightarrow> Suc n]) = (af \<psi> (w [0 \<rightarrow> Suc n])) or\<^sub>n ((af \<phi> (w [0 \<rightarrow> Suc n])) and\<^sub>n af (\<phi> W\<^sub>n \<psi>) (w [1 \<rightarrow> Suc n]))"
   by (induction n) fastforce+
 
+lemma af_subsequence_W':
+  "af (\<phi> W\<^sub>n \<psi>) (a # xs) = (af \<psi> (a # xs)) or\<^sub>n ((af \<phi> (a # xs)) and\<^sub>n af (\<phi> W\<^sub>n \<psi>) xs)"
+  by (simp add: af_decompose)
+
 lemma af_subsequence_M:
   "af (\<phi> M\<^sub>n \<psi>) (w [0 \<rightarrow> Suc n]) = (af \<psi> (w [0 \<rightarrow> Suc n])) and\<^sub>n ((af \<phi> (w [0 \<rightarrow> Suc n])) or\<^sub>n af (\<phi> M\<^sub>n \<psi>) (w [1 \<rightarrow> Suc n]))"
   by (induction n) fastforce+
 
+lemma af_subsequence_M':
+  "af (\<phi> M\<^sub>n \<psi>) (a # xs) = (af \<psi> (a # xs)) and\<^sub>n ((af \<phi> (a # xs)) or\<^sub>n af (\<phi> M\<^sub>n \<psi>) xs)"
+  by (simp add: af_decompose)
 
 lemma suffix_build[simp]:
   "suffix (Suc n) (x ## xs) = suffix n xs"
   by fastforce
 
 lemma af_letter_build:
   "(x ## w) \<Turnstile>\<^sub>n \<phi> \<longleftrightarrow> w \<Turnstile>\<^sub>n af_letter \<phi> x"
 proof (induction \<phi> arbitrary: x w)
   case (Until_ltln \<phi> \<psi>)
   then show ?case
     unfolding ltln_expand_Until by force
 next
   case (Release_ltln \<phi> \<psi>)
   then show ?case
     unfolding ltln_expand_Release by force
 next
   case (WeakUntil_ltln \<phi> \<psi>)
   then show ?case
     unfolding ltln_expand_WeakUntil by force
 next
   case (StrongRelease_ltln \<phi> \<psi>)
   then show ?case
     unfolding ltln_expand_StrongRelease by force
 qed simp+
 
 lemma af_ltl_continuation:
   "(w \<frown> w') \<Turnstile>\<^sub>n \<phi> \<longleftrightarrow> w' \<Turnstile>\<^sub>n af \<phi> w"
 proof (induction w arbitrary: \<phi> w')
   case (Cons x xs)
   then show ?case
     using af_letter_build by fastforce
 qed simp
 
 
 
 subsection \<open>Range of the after function\<close>
 
 lemma af_letter_atoms:
   "atoms_ltln (af_letter \<phi> \<nu>) \<subseteq> atoms_ltln \<phi>"
   by (induction \<phi>) auto
 
 lemma af_atoms:
   "atoms_ltln (af \<phi> w) \<subseteq> atoms_ltln \<phi>"
   by (induction w rule: rev_induct) (simp, insert af_letter_atoms, fastforce)
 
 lemma af_letter_nested_prop_atoms:
   "nested_prop_atoms (af_letter \<phi> \<nu>) \<subseteq> nested_prop_atoms \<phi>"
   by (induction \<phi>) auto
 
 lemma af_nested_prop_atoms:
   "nested_prop_atoms (af \<phi> w) \<subseteq> nested_prop_atoms \<phi>"
   by (induction w rule: rev_induct) (auto, insert af_letter_nested_prop_atoms, blast)
 
 lemma af_letter_range:
   "range (af_letter \<phi>) \<subseteq> {\<psi>. nested_prop_atoms \<psi> \<subseteq> nested_prop_atoms \<phi>}"
   using af_letter_nested_prop_atoms by blast
 
 lemma af_range:
   "range (af \<phi>) \<subseteq> {\<psi>. nested_prop_atoms \<psi> \<subseteq> nested_prop_atoms \<phi>}"
   using af_nested_prop_atoms by blast
 
 
 
 subsection \<open>Subformulas of the after function\<close>
 
 lemma af_letter_subformulas\<^sub>\<mu>:
   "subformulas\<^sub>\<mu> (af_letter \<phi> \<xi>) = subformulas\<^sub>\<mu> \<phi>"
   by (induction \<phi>) auto
 
 lemma af_subformulas\<^sub>\<mu>:
   "subformulas\<^sub>\<mu> (af \<phi> w) = subformulas\<^sub>\<mu> \<phi>"
   using af_letter_subformulas\<^sub>\<mu>
   by (induction w arbitrary: \<phi> rule: rev_induct) (simp, fastforce)
 
 lemma af_letter_subformulas\<^sub>\<nu>:
   "subformulas\<^sub>\<nu> (af_letter \<phi> \<xi>) = subformulas\<^sub>\<nu> \<phi>"
   by (induction \<phi>) auto
 
 lemma af_subformulas\<^sub>\<nu>:
   "subformulas\<^sub>\<nu> (af \<phi> w) = subformulas\<^sub>\<nu> \<phi>"
   using af_letter_subformulas\<^sub>\<nu>
   by (induction w arbitrary: \<phi> rule: rev_induct) (simp, fastforce)
 
 
 
 subsection \<open>Stability and the after function\<close>
 
 lemma \<G>\<F>_af:
   "\<G>\<F> (af \<phi> (prefix i w)) (suffix i w) = \<G>\<F> \<phi> (suffix i w)"
   unfolding \<G>\<F>_semantics' af_subformulas\<^sub>\<mu> by blast
 
 lemma \<F>_af:
   "\<F> (af \<phi> (prefix i w)) (suffix i w) = \<F> \<phi> (suffix i w)"
   unfolding \<F>_semantics' af_subformulas\<^sub>\<mu> by blast
 
 lemma \<F>\<G>_af:
   "\<F>\<G> (af \<phi> (prefix i w)) (suffix i w) = \<F>\<G> \<phi> (suffix i w)"
   unfolding \<F>\<G>_semantics' af_subformulas\<^sub>\<nu> by blast
 
 lemma \<G>_af:
   "\<G> (af \<phi> (prefix i w)) (suffix i w) = \<G> \<phi> (suffix i w)"
   unfolding \<G>_semantics' af_subformulas\<^sub>\<nu> by blast
 
 
 
 subsection \<open>Congruence\<close>
 
 lemma af_letter_lang_congruent:
   "\<phi> \<sim>\<^sub>L \<psi> \<Longrightarrow> af_letter \<phi> \<nu> \<sim>\<^sub>L af_letter \<psi> \<nu>"
   unfolding ltl_lang_equiv_def
   using af_letter_build by blast
 
 lemma af_lang_congruent:
   "\<phi> \<sim>\<^sub>L \<psi> \<Longrightarrow> af \<phi> w \<sim>\<^sub>L af \<psi> w"
   unfolding ltl_lang_equiv_def using af_ltl_continuation
   by (induction \<phi>) blast+
 
 
 
 lemma af_letter_subst:
   "af_letter \<phi> \<nu> = subst \<phi> (\<lambda>\<psi>. Some (af_letter \<psi> \<nu>))"
   by (induction \<phi>) auto
 
 lemma af_letter_prop_congruent:
   "\<phi> \<longrightarrow>\<^sub>P \<psi> \<Longrightarrow> af_letter \<phi> \<nu> \<longrightarrow>\<^sub>P af_letter \<psi> \<nu>"
   "\<phi> \<sim>\<^sub>P \<psi> \<Longrightarrow> af_letter \<phi> \<nu> \<sim>\<^sub>P af_letter \<psi> \<nu>"
   by (metis af_letter_subst subst_respects_ltl_prop_entailment)+
 
 lemma af_prop_congruent:
   "\<phi> \<longrightarrow>\<^sub>P \<psi> \<Longrightarrow> af \<phi> w \<longrightarrow>\<^sub>P af \<psi> w"
   "\<phi> \<sim>\<^sub>P \<psi> \<Longrightarrow> af \<phi> w \<sim>\<^sub>P af \<psi> w"
   by (induction w arbitrary: \<phi> \<psi>) (insert af_letter_prop_congruent, fastforce+)
 
 
 lemma af_letter_const_congruent:
   "\<phi> \<sim>\<^sub>C \<psi> \<Longrightarrow> af_letter \<phi> \<nu> \<sim>\<^sub>C af_letter \<psi> \<nu>"
   by (metis af_letter_subst subst_respects_ltl_const_entailment)
 
 lemma af_const_congruent:
   "\<phi> \<sim>\<^sub>C \<psi> \<Longrightarrow> af \<phi> w \<sim>\<^sub>C af \<psi> w"
   by (induction w arbitrary: \<phi> \<psi>) (insert af_letter_const_congruent, fastforce+)
 
 
 lemma af_letter_one_step_back:
   "{x. \<A> \<Turnstile>\<^sub>P af_letter x \<sigma>} \<Turnstile>\<^sub>P \<phi> \<longleftrightarrow> \<A> \<Turnstile>\<^sub>P af_letter \<phi> \<sigma>"
   by (induction \<phi>) simp_all
 
 
 subsection \<open>Implications\<close>
 
 lemma af_F_prefix_prop:
   "af (F\<^sub>n \<phi>) w \<longrightarrow>\<^sub>P af (F\<^sub>n \<phi>) (w' @ w)"
   by (induction w') (simp add: ltl_prop_implies_def af_decompose(1,2))+
 
 lemma af_G_prefix_prop:
   "af (G\<^sub>n \<phi>) (w' @ w) \<longrightarrow>\<^sub>P af (G\<^sub>n \<phi>) w"
   by (induction w') (simp add: ltl_prop_implies_def af_decompose(1,2))+
 
 
 lemma af_F_prefix_lang:
   "w \<Turnstile>\<^sub>n af (F\<^sub>n \<phi>) ys \<Longrightarrow> w \<Turnstile>\<^sub>n af (F\<^sub>n \<phi>) (xs @ ys)"
   using af_F_prefix_prop ltl_prop_implication_implies_ltl_implication by blast
 
 lemma af_G_prefix_lang:
   "w \<Turnstile>\<^sub>n af (G\<^sub>n \<phi>) (xs @ ys) \<Longrightarrow> w \<Turnstile>\<^sub>n af (G\<^sub>n \<phi>) ys"
   using af_G_prefix_prop ltl_prop_implication_implies_ltl_implication by blast
 
 
 lemma af_F_prefix_const_equiv_true:
   "af (F\<^sub>n \<phi>) w \<sim>\<^sub>C true\<^sub>n \<Longrightarrow> af (F\<^sub>n \<phi>) (w' @ w) \<sim>\<^sub>C true\<^sub>n"
   using af_F_prefix_prop ltl_const_equiv_implies_prop_equiv(1) ltl_prop_equiv_true_implies_true by blast
 
 lemma af_G_prefix_const_equiv_false:
   "af (G\<^sub>n \<phi>) w \<sim>\<^sub>C false\<^sub>n \<Longrightarrow> af (G\<^sub>n \<phi>) (w' @ w) \<sim>\<^sub>C false\<^sub>n"
   using af_G_prefix_prop ltl_const_equiv_implies_prop_equiv(2) ltl_prop_equiv_false_implied_by_false by blast
 
 
 lemma af_F_prefix_lang_equiv_true:
   "af (F\<^sub>n \<phi>) w \<sim>\<^sub>L true\<^sub>n \<Longrightarrow> af (F\<^sub>n \<phi>) (w' @ w) \<sim>\<^sub>L true\<^sub>n"
   unfolding ltl_lang_equiv_def
   using af_F_prefix_lang by fastforce
 
 lemma af_G_prefix_lang_equiv_false:
   "af (G\<^sub>n \<phi>) w \<sim>\<^sub>L false\<^sub>n \<Longrightarrow> af (G\<^sub>n \<phi>) (w' @ w) \<sim>\<^sub>L false\<^sub>n"
   unfolding ltl_lang_equiv_def
   using af_G_prefix_lang by fastforce
 
 
 
 locale af_congruent = ltl_equivalence +
   assumes
     af_letter_congruent: "\<phi> \<sim> \<psi> \<Longrightarrow> af_letter \<phi> \<nu> \<sim> af_letter \<psi> \<nu>"
 begin
 
 lemma af_congruentness:
   "\<phi> \<sim> \<psi> \<Longrightarrow> af \<phi> xs \<sim> af \<psi> xs"
   by (induction xs arbitrary: \<phi> \<psi>) (insert af_letter_congruent, fastforce+)
 
 lemma af_append_congruent:
   "af \<phi> w \<sim> af \<psi> w \<Longrightarrow> af \<phi> (w @ w') \<sim> af \<psi> (w @ w')"
   by (simp add: af_congruentness)
 
 lemma af_append_true:
   "af \<phi> w \<sim> true\<^sub>n \<Longrightarrow> af \<phi> (w @ w') \<sim> true\<^sub>n"
   using af_congruentness by fastforce
 
 lemma af_append_false:
   "af \<phi> w \<sim> false\<^sub>n \<Longrightarrow> af \<phi> (w @ w') \<sim> false\<^sub>n"
   using af_congruentness by fastforce
 
 lemma prefix_append_subsequence:
   "i \<le> j \<Longrightarrow> (prefix i w) @ (w [i \<rightarrow> j]) = prefix j w"
   by (metis le_add_diff_inverse subsequence_append)
 
 lemma af_prefix_congruent:
   "i \<le> j \<Longrightarrow> af \<phi> (prefix i w) \<sim> af \<psi> (prefix i w) \<Longrightarrow> af \<phi> (prefix j w) \<sim> af \<psi> (prefix j w)"
   by (metis af_congruentness foldl_append prefix_append_subsequence)+
 
 lemma af_prefix_true:
   "i \<le> j \<Longrightarrow> af \<phi> (prefix i w) \<sim> true\<^sub>n \<Longrightarrow> af \<phi> (prefix j w) \<sim> true\<^sub>n"
   by (metis af_append_true prefix_append_subsequence)
 
 lemma af_prefix_false:
   "i \<le> j \<Longrightarrow> af \<phi> (prefix i w) \<sim> false\<^sub>n \<Longrightarrow> af \<phi> (prefix j w) \<sim> false\<^sub>n"
   by (metis af_append_false prefix_append_subsequence)
 
 end
 
 
 
 
 interpretation lang_af_congruent: af_congruent "(\<sim>\<^sub>L)"
   by unfold_locales (rule af_letter_lang_congruent)
 
 interpretation prop_af_congruent: af_congruent "(\<sim>\<^sub>P)"
   by unfold_locales (rule af_letter_prop_congruent)
 
 interpretation const_af_congruent: af_congruent "(\<sim>\<^sub>C)"
   by unfold_locales (rule af_letter_const_congruent)
 
 
 
 subsection \<open>After in @{term \<mu>LTL} and @{term \<nu>LTL}\<close>
 
 lemma valid_prefix_implies_ltl:
   "af \<phi> (prefix i w) \<sim>\<^sub>L true\<^sub>n \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>"
 proof -
   assume "af \<phi> (prefix i w) \<sim>\<^sub>L true\<^sub>n"
 
   then have "suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)"
     unfolding ltl_lang_equiv_def using semantics_ltln.simps(1) by blast
 
   then show "w \<Turnstile>\<^sub>n \<phi>"
     using af_ltl_continuation by force
 qed
 
 lemma ltl_implies_satisfiable_prefix:
   "w \<Turnstile>\<^sub>n \<phi> \<Longrightarrow> \<not> (af \<phi> (prefix i w) \<sim>\<^sub>L false\<^sub>n)"
 proof -
   assume "w \<Turnstile>\<^sub>n \<phi>"
 
   then have "suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)"
     using af_ltl_continuation by fastforce
 
   then show "\<not> (af \<phi> (prefix i w) \<sim>\<^sub>L false\<^sub>n)"
     unfolding ltl_lang_equiv_def using semantics_ltln.simps(2) by blast
 qed
 
 lemma \<mu>LTL_implies_valid_prefix:
   "\<phi> \<in> \<mu>LTL \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> \<Longrightarrow> \<exists>i. af \<phi> (prefix i w) \<sim>\<^sub>C true\<^sub>n"
 proof (induction \<phi> arbitrary: w)
   case True_ltln
   then show ?case
     using ltl_const_equiv_equivp equivp_reflp by fastforce
 next
   case (Prop_ltln x)
   then show ?case
     by (metis af_letter.simps(3) foldl_Cons foldl_Nil ltl_const_equiv_equivp equivp_reflp semantics_ltln.simps(3) subsequence_singleton)
 next
   case (Nprop_ltln x)
   then show ?case
     by (metis af_letter.simps(4) foldl_Cons foldl_Nil ltl_const_equiv_equivp equivp_reflp semantics_ltln.simps(4) subsequence_singleton)
 next
   case (And_ltln \<phi>1 \<phi>2)
 
   then obtain i1 i2 where "af \<phi>1 (prefix i1 w) \<sim>\<^sub>C true\<^sub>n" and "af \<phi>2 (prefix i2 w) \<sim>\<^sub>C true\<^sub>n"
     by fastforce
 
   then have "af \<phi>1 (prefix (i1 + i2) w) \<sim>\<^sub>C true\<^sub>n" and "af \<phi>2 (prefix (i2 + i1) w) \<sim>\<^sub>C true\<^sub>n"
     using const_af_congruent.af_prefix_true le_add1 by blast+
 
   then have "af (\<phi>1 and\<^sub>n \<phi>2) (prefix (i1 + i2) w) \<sim>\<^sub>C true\<^sub>n"
     unfolding af_decompose by (simp add: add.commute)
 
   then show ?case
     by blast
 next
   case (Or_ltln \<phi>1 \<phi>2)
 
   then obtain i where "af \<phi>1 (prefix i w) \<sim>\<^sub>C true\<^sub>n \<or> af \<phi>2 (prefix i w) \<sim>\<^sub>C true\<^sub>n"
     by auto
 
   then show ?case
     unfolding af_decompose by auto
 next
   case (Next_ltln \<phi>)
 
   then obtain i where "af \<phi> (prefix i (suffix 1 w)) \<sim>\<^sub>C true\<^sub>n"
     by fastforce
 
   then show ?case
     by (metis (no_types, lifting) One_nat_def add.right_neutral af_simps(3) foldl_Nil foldl_append subsequence_append subsequence_shift subsequence_singleton)
 next
   case (Until_ltln \<phi>1 \<phi>2)
 
   then obtain k where "suffix k w \<Turnstile>\<^sub>n \<phi>2" and "\<forall>j<k. suffix j w \<Turnstile>\<^sub>n \<phi>1"
     by fastforce
 
   then show ?case
   proof (induction k arbitrary: w)
     case 0
 
     then obtain i where "af \<phi>2 (prefix i w) \<sim>\<^sub>C true\<^sub>n"
       using Until_ltln by fastforce
 
     then have "af \<phi>2 (prefix (Suc i) w) \<sim>\<^sub>C true\<^sub>n"
       using const_af_congruent.af_prefix_true le_SucI by blast
 
     then have "af (\<phi>1 U\<^sub>n \<phi>2) (prefix (Suc i) w) \<sim>\<^sub>C true\<^sub>n"
       unfolding af_subsequence_U by simp
 
     then show ?case
       by blast
   next
     case (Suc k)
 
     then have "suffix k (suffix 1 w) \<Turnstile>\<^sub>n \<phi>2" and "\<forall>j<k. suffix j (suffix 1 w) \<Turnstile>\<^sub>n \<phi>1"
       by (simp add: Suc.prems)+
 
     then obtain i where i_def: "af (\<phi>1 U\<^sub>n \<phi>2) (prefix i (suffix 1 w)) \<sim>\<^sub>C true\<^sub>n"
       using Suc.IH by blast
 
     obtain j where "af \<phi>1 (prefix j w) \<sim>\<^sub>C true\<^sub>n"
       using Until_ltln Suc by fastforce
 
     then have "af \<phi>1 (prefix (Suc (j + i)) w) \<sim>\<^sub>C true\<^sub>n"
       using const_af_congruent.af_prefix_true le_SucI le_add1 by blast
 
     moreover
 
     from i_def have "af (\<phi>1 U\<^sub>n \<phi>2) (w [1 \<rightarrow> Suc (j + i)]) \<sim>\<^sub>C true\<^sub>n"
       by (metis One_nat_def const_af_congruent.af_prefix_true le_add2 plus_1_eq_Suc subsequence_shift)
 
     ultimately
 
     have "af (\<phi>1 U\<^sub>n \<phi>2) (prefix (Suc (j + i)) w) \<sim>\<^sub>C true\<^sub>n"
       unfolding af_subsequence_U by simp
 
     then show ?case
       by blast
   qed
 next
   case (StrongRelease_ltln \<phi>1 \<phi>2)
 
   then obtain k where "suffix k w \<Turnstile>\<^sub>n \<phi>1" and "\<forall>j\<le>k. suffix j w \<Turnstile>\<^sub>n \<phi>2"
     by fastforce
 
   then show ?case
   proof (induction k arbitrary: w)
     case 0
 
     then obtain i1 i2 where "af \<phi>1 (prefix i1 w) \<sim>\<^sub>C true\<^sub>n" and "af \<phi>2 (prefix i2 w) \<sim>\<^sub>C true\<^sub>n"
       using StrongRelease_ltln by fastforce
 
     then have "af \<phi>1 (prefix (Suc (i1 + i2)) w) \<sim>\<^sub>C true\<^sub>n" and "af \<phi>2 (prefix (Suc (i2 + i1)) w) \<sim>\<^sub>C true\<^sub>n"
       using const_af_congruent.af_prefix_true le_SucI le_add1 by blast+
 
     then have "af (\<phi>1 M\<^sub>n \<phi>2) (prefix (Suc (i1 + i2)) w) \<sim>\<^sub>C true\<^sub>n"
       unfolding af_subsequence_M by (simp add: add.commute)
 
     then show ?case
       by blast
   next
     case (Suc k)
 
     then have "suffix k (suffix 1 w) \<Turnstile>\<^sub>n \<phi>1" and "\<forall>j\<le>k. suffix j (suffix 1 w) \<Turnstile>\<^sub>n \<phi>2"
       by (simp add: Suc.prems)+
 
     then obtain i where i_def: "af (\<phi>1 M\<^sub>n \<phi>2) (prefix i (suffix 1 w)) \<sim>\<^sub>C true\<^sub>n"
       using Suc.IH by blast
 
     obtain j where "af \<phi>2 (prefix j w) \<sim>\<^sub>C true\<^sub>n"
       using StrongRelease_ltln Suc by fastforce
 
     then have "af \<phi>2 (prefix (Suc (j + i)) w) \<sim>\<^sub>C true\<^sub>n"
       using const_af_congruent.af_prefix_true le_SucI le_add1 by blast
 
     moreover
 
     from i_def have "af (\<phi>1 M\<^sub>n \<phi>2) (w [1 \<rightarrow> Suc (j + i)]) \<sim>\<^sub>C true\<^sub>n"
       by (metis One_nat_def const_af_congruent.af_prefix_true le_add2 plus_1_eq_Suc subsequence_shift)
 
     ultimately
 
     have "af (\<phi>1 M\<^sub>n \<phi>2) (prefix (Suc (j + i)) w) \<sim>\<^sub>C true\<^sub>n"
       unfolding af_subsequence_M by simp
 
     then show ?case
       by blast
   qed
 qed force+
 
 lemma satisfiable_prefix_implies_\<nu>LTL:
   "\<phi> \<in> \<nu>LTL \<Longrightarrow> \<nexists>i. af \<phi> (prefix i w) \<sim>\<^sub>C false\<^sub>n \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>"
 proof (erule contrapos_np, induction \<phi> arbitrary: w)
   case False_ltln
   then show ?case
     using ltl_const_equiv_equivp equivp_reflp by fastforce
 next
   case (Prop_ltln x)
   then show ?case
     by (metis af_letter.simps(3) foldl_Cons foldl_Nil ltl_const_equiv_equivp equivp_reflp semantics_ltln.simps(3) subsequence_singleton)
 next
   case (Nprop_ltln x)
   then show ?case
     by (metis af_letter.simps(4) foldl_Cons foldl_Nil ltl_const_equiv_equivp equivp_reflp semantics_ltln.simps(4) subsequence_singleton)
 next
   case (And_ltln \<phi>1 \<phi>2)
 
   then obtain i where "af \<phi>1 (prefix i w) \<sim>\<^sub>C false\<^sub>n \<or> af \<phi>2 (prefix i w) \<sim>\<^sub>C false\<^sub>n"
     by auto
 
   then show ?case
     unfolding af_decompose by auto
 next
   case (Or_ltln \<phi>1 \<phi>2)
 
   then obtain i1 i2 where "af \<phi>1 (prefix i1 w) \<sim>\<^sub>C false\<^sub>n" and "af \<phi>2 (prefix i2 w) \<sim>\<^sub>C false\<^sub>n"
     by fastforce
 
   then have "af \<phi>1 (prefix (i1 + i2) w) \<sim>\<^sub>C false\<^sub>n" and "af \<phi>2 (prefix (i2 + i1) w) \<sim>\<^sub>C false\<^sub>n"
     using const_af_congruent.af_prefix_false le_add1 by blast+
 
   then have "af (\<phi>1 or\<^sub>n \<phi>2) (prefix (i1 + i2) w) \<sim>\<^sub>C false\<^sub>n"
     unfolding af_decompose by (simp add: add.commute)
 
   then show ?case
     by blast
 next
   case (Next_ltln \<phi>)
 
   then obtain i where "af \<phi> (prefix i (suffix 1 w)) \<sim>\<^sub>C false\<^sub>n"
     by fastforce
 
   then show ?case
     by (metis (no_types, lifting) One_nat_def add.right_neutral af_simps(3) foldl_Nil foldl_append subsequence_append subsequence_shift subsequence_singleton)
 next
   case (Release_ltln \<phi>1 \<phi>2)
 
   then obtain k where "\<not> suffix k w \<Turnstile>\<^sub>n \<phi>2" and "\<forall>j<k. \<not> suffix j w \<Turnstile>\<^sub>n \<phi>1"
     by fastforce
 
   then show ?case
   proof (induction k arbitrary: w)
     case 0
 
     then obtain i where "af \<phi>2 (prefix i w) \<sim>\<^sub>C false\<^sub>n"
       using Release_ltln by fastforce
 
     then have "af \<phi>2 (prefix (Suc i) w) \<sim>\<^sub>C false\<^sub>n"
       using const_af_congruent.af_prefix_false le_SucI by blast
 
     then have "af (\<phi>1 R\<^sub>n \<phi>2) (prefix (Suc i) w) \<sim>\<^sub>C false\<^sub>n"
       unfolding af_subsequence_R by simp
 
     then show ?case
       by blast
   next
     case (Suc k)
 
     then have "\<not> suffix k (suffix 1 w) \<Turnstile>\<^sub>n \<phi>2" and "\<forall>j<k. \<not> suffix j (suffix 1 w) \<Turnstile>\<^sub>n \<phi>1"
       by (simp add: Suc.prems)+
 
     then obtain i where i_def: "af (\<phi>1 R\<^sub>n \<phi>2) (prefix i (suffix 1 w)) \<sim>\<^sub>C false\<^sub>n"
       using Suc.IH by blast
 
     obtain j where "af \<phi>1 (prefix j w) \<sim>\<^sub>C false\<^sub>n"
       using Release_ltln Suc by fastforce
 
     then have "af \<phi>1 (prefix (Suc (j + i)) w) \<sim>\<^sub>C false\<^sub>n"
       using const_af_congruent.af_prefix_false le_SucI le_add1 by blast
 
     moreover
 
     from i_def have "af (\<phi>1 R\<^sub>n \<phi>2) (w [1 \<rightarrow> Suc (j + i)]) \<sim>\<^sub>C false\<^sub>n"
       by (metis One_nat_def const_af_congruent.af_prefix_false le_add2 plus_1_eq_Suc subsequence_shift)
 
     ultimately
 
     have "af (\<phi>1 R\<^sub>n \<phi>2) (prefix (Suc (j + i)) w) \<sim>\<^sub>C false\<^sub>n"
       unfolding af_subsequence_R by auto
 
     then show ?case
       by blast
   qed
 next
   case (WeakUntil_ltln \<phi>1 \<phi>2)
 
   then obtain k where "\<not> suffix k w \<Turnstile>\<^sub>n \<phi>1" and "\<forall>j\<le>k. \<not> suffix j w \<Turnstile>\<^sub>n \<phi>2"
     by fastforce
 
   then show ?case
   proof (induction k arbitrary: w)
     case 0
 
     then obtain i1 i2 where "af \<phi>1 (prefix i1 w) \<sim>\<^sub>C false\<^sub>n" and "af \<phi>2 (prefix i2 w) \<sim>\<^sub>C false\<^sub>n"
       using WeakUntil_ltln by fastforce
 
     then have "af \<phi>1 (prefix (Suc (i1 + i2)) w) \<sim>\<^sub>C false\<^sub>n" and "af \<phi>2 (prefix (Suc (i2 + i1)) w) \<sim>\<^sub>C false\<^sub>n"
       using const_af_congruent.af_prefix_false le_SucI le_add1 by blast+
 
     then have "af (\<phi>1 W\<^sub>n \<phi>2) (prefix (Suc (i1 + i2)) w) \<sim>\<^sub>C false\<^sub>n"
       unfolding af_subsequence_W by (simp add: add.commute)
 
     then show ?case
       by blast
   next
     case (Suc k)
 
     then have "\<not> suffix k (suffix 1 w) \<Turnstile>\<^sub>n \<phi>1" and "\<forall>j\<le>k. \<not> suffix j (suffix 1 w) \<Turnstile>\<^sub>n \<phi>2"
       by (simp add: Suc.prems)+
 
     then obtain i where i_def: "af (\<phi>1 W\<^sub>n \<phi>2) (prefix i (suffix 1 w)) \<sim>\<^sub>C false\<^sub>n"
       using Suc.IH by blast
 
     obtain j where "af \<phi>2 (prefix j w) \<sim>\<^sub>C false\<^sub>n"
       using WeakUntil_ltln Suc by fastforce
 
     then have "af \<phi>2 (prefix (Suc (j + i)) w) \<sim>\<^sub>C false\<^sub>n"
       using const_af_congruent.af_prefix_false le_SucI le_add1 by blast
 
     moreover
 
     from i_def have "af (\<phi>1 W\<^sub>n \<phi>2) (w [1 \<rightarrow> Suc (j + i)]) \<sim>\<^sub>C false\<^sub>n"
       by (metis One_nat_def const_af_congruent.af_prefix_false le_add2 plus_1_eq_Suc subsequence_shift)
 
     ultimately
 
     have "af (\<phi>1 W\<^sub>n \<phi>2) (prefix (Suc (j + i)) w) \<sim>\<^sub>C false\<^sub>n"
       unfolding af_subsequence_W by simp
 
     then show ?case
       by blast
   qed
 qed force+
 
 
 context ltl_equivalence
 begin
 
 lemma valid_prefix_implies_ltl:
   "af \<phi> (prefix i w) \<sim> true\<^sub>n \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>"
   using valid_prefix_implies_ltl eq_implies_lang by blast
 
 lemma ltl_implies_satisfiable_prefix:
   "w \<Turnstile>\<^sub>n \<phi> \<Longrightarrow> \<not> (af \<phi> (prefix i w) \<sim> false\<^sub>n)"
   using ltl_implies_satisfiable_prefix eq_implies_lang by blast
 
 
 lemma \<mu>LTL_implies_valid_prefix:
   "\<phi> \<in> \<mu>LTL \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> \<Longrightarrow> \<exists>i. af \<phi> (prefix i w) \<sim> true\<^sub>n"
   using \<mu>LTL_implies_valid_prefix const_implies_eq by blast
 
 lemma satisfiable_prefix_implies_\<nu>LTL:
   "\<phi> \<in> \<nu>LTL \<Longrightarrow> \<nexists>i. af \<phi> (prefix i w) \<sim> false\<^sub>n \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi>"
   using satisfiable_prefix_implies_\<nu>LTL const_implies_eq by blast
 
 
 lemma af_\<mu>LTL:
   "\<phi> \<in> \<mu>LTL \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> \<longleftrightarrow> (\<exists>i. af \<phi> (prefix i w) \<sim> true\<^sub>n)"
   using valid_prefix_implies_ltl \<mu>LTL_implies_valid_prefix by blast
 
 lemma af_\<nu>LTL:
   "\<phi> \<in> \<nu>LTL \<Longrightarrow> w \<Turnstile>\<^sub>n \<phi> \<longleftrightarrow> (\<forall>i. \<not> (af \<phi> (prefix i w) \<sim> false\<^sub>n))"
   using ltl_implies_satisfiable_prefix satisfiable_prefix_implies_\<nu>LTL by blast
 
 
 lemma af_\<mu>LTL_GF:
   "\<phi> \<in> \<mu>LTL \<Longrightarrow> w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<phi>) \<longleftrightarrow> (\<forall>i. \<exists>j. af (F\<^sub>n \<phi>) (w[i \<rightarrow> j]) \<sim> true\<^sub>n)"
 proof -
   assume "\<phi> \<in> \<mu>LTL"
 
   then have "F\<^sub>n \<phi> \<in> \<mu>LTL"
     by simp
 
   have "w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<phi>) \<longleftrightarrow> (\<forall>i. suffix i w \<Turnstile>\<^sub>n F\<^sub>n \<phi>)"
     by simp
   also have "\<dots> \<longleftrightarrow> (\<forall>i. \<exists>j. af (F\<^sub>n \<phi>) (prefix j (suffix i w)) \<sim> true\<^sub>n)"
     using af_\<mu>LTL[OF `F\<^sub>n \<phi> \<in> \<mu>LTL`] by blast
   also have "\<dots> \<longleftrightarrow> (\<forall>i. \<exists>j. af (F\<^sub>n \<phi>) (prefix (j - i) (suffix i w)) \<sim> true\<^sub>n)"
     by (metis diff_add_inverse)
   also have "\<dots> \<longleftrightarrow> (\<forall>i. \<exists>j. af (F\<^sub>n \<phi>) (w[i \<rightarrow> j]) \<sim> true\<^sub>n)"
     unfolding subsequence_prefix_suffix ..
   finally show ?thesis
     by blast
 qed
 
 lemma af_\<nu>LTL_FG:
   "\<phi> \<in> \<nu>LTL \<Longrightarrow> w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<phi>) \<longleftrightarrow> (\<exists>i. \<forall>j. \<not> (af (G\<^sub>n \<phi>) (w[i \<rightarrow> j]) \<sim> false\<^sub>n))"
 proof -
   assume "\<phi> \<in> \<nu>LTL"
 
   then have "G\<^sub>n \<phi> \<in> \<nu>LTL"
     by simp
 
   have "w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<phi>) \<longleftrightarrow> (\<exists>i. suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<phi>)"
     by force
   also have "\<dots> \<longleftrightarrow> (\<exists>i. \<forall>j. \<not> (af (G\<^sub>n \<phi>) (prefix j (suffix i w)) \<sim> false\<^sub>n))"
     using af_\<nu>LTL[OF `G\<^sub>n \<phi> \<in> \<nu>LTL`] by blast
   also have "\<dots> \<longleftrightarrow> (\<exists>i. \<forall>j. \<not> (af (G\<^sub>n \<phi>) (prefix (j - i) (suffix i w)) \<sim> false\<^sub>n))"
     by (metis diff_add_inverse)
   also have "\<dots> \<longleftrightarrow> (\<exists>i. \<forall>j. \<not> (af (G\<^sub>n \<phi>) (w[i \<rightarrow> j]) \<sim> false\<^sub>n))"
     unfolding subsequence_prefix_suffix ..
   finally show ?thesis
     by blast
 qed
 
 end
 
 text \<open>Bring Propositional Equivalence into scope\<close>
 
 interpretation af_congruent "(\<sim>\<^sub>P)"
   by unfold_locales (rule af_letter_prop_congruent)
 
 end
diff --git a/thys/LTL_Master_Theorem/Logical_Characterization/Master_Theorem.thy b/thys/LTL_Master_Theorem/Logical_Characterization/Master_Theorem.thy
--- a/thys/LTL_Master_Theorem/Logical_Characterization/Master_Theorem.thy
+++ b/thys/LTL_Master_Theorem/Logical_Characterization/Master_Theorem.thy
@@ -1,351 +1,352 @@
 (*
     Author:   Benedikt Seidl
     License:  BSD
 *)
 
 section \<open>The Master Theorem\<close>
 
 theory Master_Theorem
 imports
   Advice After
 begin
 
 subsection \<open>Checking @{term "X \<subseteq> \<G>\<F> \<phi> w"} and @{term "Y \<subseteq> \<F>\<G> \<phi> w"}\<close>
 
 lemma X_\<G>\<F>_Y_\<F>\<G>:
   assumes
     X_\<mu>: "X \<subseteq> subformulas\<^sub>\<mu> \<phi>"
   and
     Y_\<nu>: "Y \<subseteq> subformulas\<^sub>\<nu> \<phi>"
   and
     X_GF: "\<forall>\<psi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[Y]\<^sub>\<mu>)"
   and
     Y_FG: "\<forall>\<psi> \<in> Y. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[X]\<^sub>\<nu>)"
   shows
     "X \<subseteq> \<G>\<F> \<phi> w \<and> Y \<subseteq> \<F>\<G> \<phi> w"
 proof -
   \<comment> \<open>Custom induction rule with @{term size} as a partial order\<close>
   note induct = finite_ranking_induct[where f = size]
 
   have "finite (X \<union> Y)"
     using subformulas\<^sub>\<mu>_finite subformulas\<^sub>\<nu>_finite X_\<mu> Y_\<nu> finite_subset
     by blast+
 
   then show ?thesis
     using assms
   proof (induction "X \<union> Y" arbitrary: X Y \<phi> rule: induct)
     case (insert \<psi> S)
 
     note IH = insert(3)
     note insert_S = `insert \<psi> S = X \<union> Y`
     note X_\<mu> = `X \<subseteq> subformulas\<^sub>\<mu> \<phi>`
     note Y_\<nu> = `Y \<subseteq> subformulas\<^sub>\<nu> \<phi>`
     note X_GF = `\<forall>\<psi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[Y]\<^sub>\<mu>)`
     note Y_FG = `\<forall>\<psi> \<in> Y. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[X]\<^sub>\<nu>)`
 
     from X_\<mu> Y_\<nu> have "X \<inter> Y = {}"
       using subformulas\<^sub>\<mu>\<^sub>\<nu>_disjoint by fast
 
     from insert_S X_\<mu> Y_\<nu> have "\<psi> \<in> subfrmlsn \<phi>"
       using subformulas\<^sub>\<mu>_subfrmlsn subformulas\<^sub>\<nu>_subfrmlsn by blast
 
     show ?case
     proof (cases "\<psi> \<notin> S", cases "\<psi> \<in> X")
       assume "\<psi> \<notin> S" and "\<psi> \<in> X"
 
       {
         \<comment> \<open>Show @{term "X - {\<psi>} \<subseteq> \<G>\<F> \<phi> w"} and @{term "Y \<subseteq> \<F>\<G> \<phi> w"}\<close>
 
         then have "\<psi> \<notin> Y"
           using `X \<inter> Y = {}` by auto
         then have "S = (X - {\<psi>}) \<union> Y"
           using insert_S `\<psi> \<notin> S` by fast
 
         moreover
 
         have "\<forall>\<psi>' \<in> Y. \<psi>'[X - {\<psi>}]\<^sub>\<nu> = \<psi>'[X]\<^sub>\<nu>"
           using GF_advice_minus_size insert(1,2,4) `\<psi> \<notin> Y` by fast
 
         ultimately have "X - {\<psi>} \<subseteq> \<G>\<F> \<phi> w" and "Y \<subseteq> \<F>\<G> \<phi> w"
           using IH[of "X - {\<psi>}" Y \<phi>] X_\<mu> Y_\<nu> X_GF Y_FG by auto
       }
 
       moreover
 
       {
         \<comment> \<open>Show @{term "\<psi> \<in> \<G>\<F> \<phi> w"}\<close>
 
         have "w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[Y]\<^sub>\<mu>)"
           using X_GF `\<psi> \<in> X` by simp
         then have "\<exists>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n \<psi>[Y]\<^sub>\<mu>"
           unfolding GF_Inf_many by simp
 
         moreover
 
         from Y_\<nu> have "finite Y"
           using subformulas\<^sub>\<nu>_finite finite_subset by auto
 
         have "\<forall>\<phi> \<in> Y. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<phi>)"
           using `Y \<subseteq> \<F>\<G> \<phi> w` by (blast dest: \<F>\<G>_elim)
         then have "\<forall>\<phi> \<in> Y. \<forall>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<phi>"
           using FG_suffix_G by blast
         then have "\<forall>\<^sub>\<infinity>i. \<forall>\<phi> \<in> Y. suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<phi>"
           using `finite Y` eventually_ball_finite by fast
 
         ultimately
 
         have "\<exists>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n \<psi>[Y]\<^sub>\<mu> \<and> (\<forall>\<phi> \<in> Y. suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<phi>)"
           using INFM_conjI by auto
         then have "\<exists>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n \<psi>"
           by (elim frequently_elim1) (metis FG_advice_b2_helper)
         then have "w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)"
           unfolding GF_Inf_many by simp
         then have "\<psi> \<in> \<G>\<F> \<phi> w"
           unfolding \<G>\<F>_semantics using `\<psi> \<in> X` X_\<mu> by auto
       }
 
       ultimately show ?thesis
         by auto
     next
       assume "\<psi> \<notin> S" and "\<psi> \<notin> X"
       then have "\<psi> \<in> Y"
         using insert by fast
 
       {
         \<comment> \<open>Show @{term "X \<subseteq> \<G>\<F> \<phi> w"} and @{term "Y - {\<psi>} \<subseteq> \<F>\<G> \<phi> w"}\<close>
 
         then have "S \<inter> X = X"
           using insert `\<psi> \<notin> X` by fast
         then have "S = X \<union> (Y - {\<psi>})"
           using insert_S `\<psi> \<notin> S` by fast
 
         moreover
 
         have "\<forall>\<psi>' \<in> X. \<psi>'[Y - {\<psi>}]\<^sub>\<mu> = \<psi>'[Y]\<^sub>\<mu>"
           using FG_advice_minus_size insert(1,2,4) `\<psi> \<notin> X` by fast
 
         ultimately have "X \<subseteq> \<G>\<F> \<phi> w" and "Y - {\<psi>} \<subseteq> \<F>\<G> \<phi> w"
           using IH[of X "Y - {\<psi>}" \<phi>] X_\<mu> Y_\<nu> X_GF Y_FG by auto
       }
 
       moreover
 
       {
         \<comment> \<open>Show @{term "\<psi> \<in> \<F>\<G> \<phi> w"}\<close>
 
         have "w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[X]\<^sub>\<nu>)"
           using Y_FG `\<psi> \<in> Y` by simp
         then have "\<forall>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n \<psi>[X]\<^sub>\<nu>"
           unfolding FG_Alm_all by simp
 
         moreover
 
         have "\<forall>\<phi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<phi>)"
           using `X \<subseteq> \<G>\<F> \<phi> w` by (blast dest: \<G>\<F>_elim)
         then have "\<forall>\<^sub>\<infinity>i. \<forall>\<phi> \<in> X. suffix i w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<phi>)"
           by simp
 
         ultimately
 
         have "\<forall>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n \<psi>[X]\<^sub>\<nu> \<and> (\<forall>\<phi> \<in> X. suffix i w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<phi>))"
           using MOST_conjI by auto
         then have "\<forall>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n \<psi>"
           by (elim MOST_mono) (metis GF_advice_a2_helper)
         then have "w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>)"
           unfolding FG_Alm_all by simp
         then have "\<psi> \<in> \<F>\<G> \<phi> w"
           unfolding \<F>\<G>_semantics using `\<psi> \<in> Y` Y_\<nu> by auto
       }
 
       ultimately show ?thesis
         by auto
     next
       assume "\<not> \<psi> \<notin> S"
       then have "S = X \<union> Y"
         using insert by fast
       then show ?thesis
         using insert by auto
     qed
   qed fast
 qed
 
 
 lemma \<G>\<F>_implies_GF:
   "\<forall>\<psi> \<in> \<G>\<F> \<phi> w. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[\<F>\<G> \<phi> w]\<^sub>\<mu>)"
 proof safe
   fix \<psi>
   assume "\<psi> \<in> \<G>\<F> \<phi> w"
 
   then have "\<exists>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n \<psi>"
     using \<G>\<F>_elim GF_Inf_many by blast
 
   moreover
 
   have "\<psi> \<in> subfrmlsn \<phi>"
     using `\<psi> \<in> \<G>\<F> \<phi> w` \<G>\<F>_subfrmlsn by blast
 
   then have "\<And>i w. \<F>\<G> \<psi> (suffix i w) \<subseteq> \<F>\<G> \<phi> w"
     using \<F>\<G>_suffix \<F>\<G>_subset by blast
 
   ultimately have "\<exists>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n \<psi>[\<F>\<G> \<phi> w]\<^sub>\<mu>"
     by (elim frequently_elim1) (metis FG_advice_b1)
 
   then show "w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[\<F>\<G> \<phi> w]\<^sub>\<mu>)"
     unfolding GF_Inf_many by simp
 qed
 
 
 lemma \<F>\<G>_implies_FG:
   "\<forall>\<psi> \<in> \<F>\<G> \<phi> w. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[\<G>\<F> \<phi> w]\<^sub>\<nu>)"
 proof safe
   fix \<psi>
   assume "\<psi> \<in> \<F>\<G> \<phi> w"
 
   then have "\<forall>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n \<psi>"
     using \<F>\<G>_elim FG_Alm_all by blast
 
   moreover
 
   {
     have "\<psi> \<in> subfrmlsn \<phi>"
       using `\<psi> \<in> \<F>\<G> \<phi> w` \<F>\<G>_subfrmlsn by blast
 
     moreover have "\<forall>\<^sub>\<infinity>i. \<G>\<F> \<psi> (suffix i w) = \<F> \<psi> (suffix i w)"
       using suffix_\<mu>_stable unfolding \<mu>_stable_def by blast
 
     ultimately have "\<forall>\<^sub>\<infinity>i. \<F> \<psi> (suffix i w) \<subseteq> \<G>\<F> \<phi> w"
       unfolding MOST_nat_le by (metis \<G>\<F>_subset \<G>\<F>_suffix)
   }
 
   ultimately have "\<forall>\<^sub>\<infinity>i. \<F> \<psi> (suffix i w) \<subseteq> \<G>\<F> \<phi> w \<and> suffix i w \<Turnstile>\<^sub>n \<psi>"
     using eventually_conj by auto
 
   then have "\<forall>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n \<psi>[\<G>\<F> \<phi> w]\<^sub>\<nu>"
     using GF_advice_a1 by (elim eventually_mono) auto
 
   then show "w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[\<G>\<F> \<phi> w]\<^sub>\<nu>)"
     unfolding FG_Alm_all by simp
 qed
 
 
 subsection \<open>Putting the pieces together: The Master Theorem\<close>
 
 theorem master_theorem_ltr:
   assumes
     "w \<Turnstile>\<^sub>n \<phi>"
   obtains X and Y where
     "X \<subseteq> subformulas\<^sub>\<mu> \<phi>"
   and
     "Y \<subseteq> subformulas\<^sub>\<nu> \<phi>"
   and
     "\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[X]\<^sub>\<nu>"
   and
     "\<forall>\<psi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[Y]\<^sub>\<mu>)"
   and
     "\<forall>\<psi> \<in> Y. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[X]\<^sub>\<nu>)"
 proof
   show "\<G>\<F> \<phi> w \<subseteq> subformulas\<^sub>\<mu> \<phi>"
     by (rule \<G>\<F>_subformulas\<^sub>\<mu>)
 next
   show "\<F>\<G> \<phi> w \<subseteq> subformulas\<^sub>\<nu> \<phi>"
     by (rule \<F>\<G>_subformulas\<^sub>\<nu>)
 next
   obtain i where "\<G>\<F> \<phi> (suffix i w) = \<F> \<phi> (suffix i w)"
     using suffix_\<mu>_stable unfolding MOST_nat \<mu>_stable_def by fast
   then have "\<F> (af \<phi> (prefix i w)) (suffix i w) \<subseteq> \<G>\<F> \<phi> w"
     using \<G>\<F>_af \<F>_af \<G>\<F>_suffix by fast
 
   moreover
 
   have "suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)"
     using af_ltl_continuation `w \<Turnstile>\<^sub>n \<phi>` by fastforce
 
   ultimately show "\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[\<G>\<F> \<phi> w]\<^sub>\<nu>"
     using GF_advice_a1 by blast
 next
   show "\<forall>\<psi> \<in> \<G>\<F> \<phi> w. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[\<F>\<G> \<phi> w]\<^sub>\<mu>)"
     by (rule \<G>\<F>_implies_GF)
 next
   show "\<forall>\<psi> \<in> \<F>\<G> \<phi> w. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[\<G>\<F> \<phi> w]\<^sub>\<nu>)"
     by (rule \<F>\<G>_implies_FG)
 qed
 
 theorem master_theorem_rtl:
   assumes
     "X \<subseteq> subformulas\<^sub>\<mu> \<phi>"
   and
     "Y \<subseteq> subformulas\<^sub>\<nu> \<phi>"
   and
     1: "\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[X]\<^sub>\<nu>"
   and
     2: "\<forall>\<psi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[Y]\<^sub>\<mu>)"
   and
     3: "\<forall>\<psi> \<in> Y. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[X]\<^sub>\<nu>)"
   shows
     "w \<Turnstile>\<^sub>n \<phi>"
 proof -
   from 1 obtain i where "suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[X]\<^sub>\<nu>"
     by blast
 
   moreover
 
   from assms have "X \<subseteq> \<G>\<F> \<phi> w"
     using X_\<G>\<F>_Y_\<F>\<G> by blast
   then have "X \<subseteq> \<G>\<F> \<phi> (suffix i w)"
     using \<G>\<F>_suffix by fast
 
   ultimately have "suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)"
     using GF_advice_a2 \<G>\<F>_af by metis
   then show "w \<Turnstile>\<^sub>n \<phi>"
     using af_ltl_continuation by force
 qed
 
 theorem master_theorem:
   "w \<Turnstile>\<^sub>n \<phi> \<longleftrightarrow>
-    (\<exists>X \<subseteq> subformulas\<^sub>\<mu> \<phi>. \<exists>Y \<subseteq> subformulas\<^sub>\<nu> \<phi>.
-      (\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[X]\<^sub>\<nu>)
-      \<and> (\<forall>\<psi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[Y]\<^sub>\<mu>))
-      \<and> (\<forall>\<psi> \<in> Y. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[X]\<^sub>\<nu>)))"
+    (\<exists>X \<subseteq> subformulas\<^sub>\<mu> \<phi>.
+      (\<exists>Y \<subseteq> subformulas\<^sub>\<nu> \<phi>.
+        (\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[X]\<^sub>\<nu>)
+        \<and> (\<forall>\<psi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[Y]\<^sub>\<mu>))
+        \<and> (\<forall>\<psi> \<in> Y. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[X]\<^sub>\<nu>))))"
   by (metis master_theorem_ltr master_theorem_rtl)
 
 
 
 subsection \<open>The Master Theorem on Languages\<close>
 
 definition "L\<^sub>1 \<phi> X = {w. \<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[X]\<^sub>\<nu>}"
 
 definition "L\<^sub>2 X Y = {w. \<forall>\<psi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[Y]\<^sub>\<mu>)}"
 
 definition "L\<^sub>3 X Y = {w. \<forall>\<psi> \<in> Y. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[X]\<^sub>\<nu>)}"
 
 corollary master_theorem_language:
   "language_ltln \<phi> = \<Union> {L\<^sub>1 \<phi> X \<inter> L\<^sub>2 X Y \<inter> L\<^sub>3 X Y | X Y. X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<and> Y \<subseteq> subformulas\<^sub>\<nu> \<phi>}"
 proof safe
   fix w
   assume "w \<in> language_ltln \<phi>"
 
   then have "w \<Turnstile>\<^sub>n \<phi>"
     unfolding language_ltln_def by simp
 
   then obtain X Y where "X \<subseteq> subformulas\<^sub>\<mu> \<phi>" and "Y \<subseteq> subformulas\<^sub>\<nu> \<phi>"
     and "\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[X]\<^sub>\<nu>"
     and "\<forall>\<psi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[Y]\<^sub>\<mu>)"
     and "\<forall>\<psi> \<in> Y. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[X]\<^sub>\<nu>)"
     using master_theorem_ltr by metis
 
   then have "w \<in> L\<^sub>1 \<phi> X" and "w \<in> L\<^sub>2 X Y" and "w \<in> L\<^sub>3 X Y"
     unfolding L\<^sub>1_def L\<^sub>2_def L\<^sub>3_def by simp+
 
   then show "w \<in> \<Union> {L\<^sub>1 \<phi> X \<inter> L\<^sub>2 X Y \<inter> L\<^sub>3 X Y | X Y. X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<and> Y \<subseteq> subformulas\<^sub>\<nu> \<phi>}"
     using `X \<subseteq> subformulas\<^sub>\<mu> \<phi>` `Y \<subseteq> subformulas\<^sub>\<nu> \<phi>` by blast
 next
   fix w X Y
   assume "X \<subseteq> subformulas\<^sub>\<mu> \<phi>" and "Y \<subseteq> subformulas\<^sub>\<nu> \<phi>"
     and "w \<in> L\<^sub>1 \<phi> X" and "w \<in> L\<^sub>2 X Y" and "w \<in> L\<^sub>3 X Y"
 
   then show "w \<in> language_ltln \<phi>"
     unfolding language_ltln_def L\<^sub>1_def L\<^sub>2_def L\<^sub>3_def
     using master_theorem_rtl by blast
 qed
 
 end
diff --git a/thys/LTL_Master_Theorem/Logical_Characterization/Restricted_Master_Theorem.thy b/thys/LTL_Master_Theorem/Logical_Characterization/Restricted_Master_Theorem.thy
new file mode 100644
--- /dev/null
+++ b/thys/LTL_Master_Theorem/Logical_Characterization/Restricted_Master_Theorem.thy
@@ -0,0 +1,558 @@
+(*
+    Author:   Salomon Sickert
+    Author:   Benedikt Seidl
+    License:  BSD
+*)
+
+section \<open>Master Theorem with Reduced Subformulas\<close>
+
+theory Restricted_Master_Theorem
+imports
+  Master_Theorem
+begin
+
+subsection \<open>Restricted Set of Subformulas\<close>
+
+fun restricted_subformulas_inner :: "'a ltln \<Rightarrow> 'a ltln set"
+where
+  "restricted_subformulas_inner (\<phi> and\<^sub>n \<psi>) = restricted_subformulas_inner \<phi> \<union> restricted_subformulas_inner \<psi>"
+| "restricted_subformulas_inner (\<phi> or\<^sub>n \<psi>) = restricted_subformulas_inner \<phi> \<union> restricted_subformulas_inner \<psi>"
+| "restricted_subformulas_inner (X\<^sub>n \<phi>) = restricted_subformulas_inner \<phi>"
+| "restricted_subformulas_inner (\<phi> U\<^sub>n \<psi>) = subformulas\<^sub>\<nu> (\<phi> U\<^sub>n \<psi>) \<union> subformulas\<^sub>\<mu> (\<phi> U\<^sub>n \<psi>)"
+| "restricted_subformulas_inner (\<phi> R\<^sub>n \<psi>) = restricted_subformulas_inner \<phi> \<union> restricted_subformulas_inner \<psi>"
+| "restricted_subformulas_inner (\<phi> W\<^sub>n \<psi>) = restricted_subformulas_inner \<phi> \<union> restricted_subformulas_inner \<psi>"
+| "restricted_subformulas_inner (\<phi> M\<^sub>n \<psi>) = subformulas\<^sub>\<nu> (\<phi> M\<^sub>n \<psi>) \<union> subformulas\<^sub>\<mu> (\<phi> M\<^sub>n \<psi>)"
+| "restricted_subformulas_inner _ = {}"
+
+fun restricted_subformulas :: "'a ltln \<Rightarrow> 'a ltln set"
+where
+  "restricted_subformulas (\<phi> and\<^sub>n \<psi>) = restricted_subformulas \<phi> \<union> restricted_subformulas \<psi>"
+| "restricted_subformulas (\<phi> or\<^sub>n \<psi>) = restricted_subformulas \<phi> \<union> restricted_subformulas \<psi>"
+| "restricted_subformulas (X\<^sub>n \<phi>) = restricted_subformulas \<phi>"
+| "restricted_subformulas (\<phi> U\<^sub>n \<psi>) = restricted_subformulas \<phi> \<union> restricted_subformulas \<psi>"
+| "restricted_subformulas (\<phi> R\<^sub>n \<psi>) = restricted_subformulas \<phi> \<union> restricted_subformulas_inner \<psi>"
+| "restricted_subformulas (\<phi> W\<^sub>n \<psi>) = restricted_subformulas_inner \<phi> \<union> restricted_subformulas \<psi>"
+| "restricted_subformulas (\<phi> M\<^sub>n \<psi>) = restricted_subformulas \<phi> \<union> restricted_subformulas \<psi>"
+| "restricted_subformulas _ = {}"
+
+lemma GF_advice_restricted_subformulas_inner:
+  "restricted_subformulas_inner (\<phi>[X]\<^sub>\<nu>) = {}"
+  by (induction \<phi>) simp_all
+
+lemma GF_advice_restricted_subformulas:
+  "restricted_subformulas (\<phi>[X]\<^sub>\<nu>) = {}"
+  by (induction \<phi>) (simp_all add: GF_advice_restricted_subformulas_inner)
+
+lemma restricted_subformulas_inner_subset:
+  "restricted_subformulas_inner \<phi> \<subseteq> subformulas\<^sub>\<nu> \<phi> \<union> subformulas\<^sub>\<mu> \<phi>"
+  by (induction \<phi>) auto
+
+lemma restricted_subformulas_subset':
+  "restricted_subformulas \<phi> \<subseteq> restricted_subformulas_inner \<phi>"
+  by (induction \<phi>) (insert restricted_subformulas_inner_subset, auto)
+
+lemma restricted_subformulas_subset:
+  "restricted_subformulas \<phi> \<subseteq> subformulas\<^sub>\<nu> \<phi> \<union> subformulas\<^sub>\<mu> \<phi>"
+  using restricted_subformulas_inner_subset restricted_subformulas_subset' by auto
+
+lemma restricted_subformulas_size:
+  "\<psi> \<in> restricted_subformulas \<phi> \<Longrightarrow> size \<psi> < size \<phi>"
+proof -
+  have "\<And>\<phi>. restricted_subformulas_inner \<phi> \<subseteq> subfrmlsn \<phi>"
+    using restricted_subformulas_inner_subset subformulas\<^sub>\<mu>\<^sub>\<nu>_subfrmlsn by blast
+
+  then have inner: "\<And>\<psi> \<phi>. \<psi> \<in> restricted_subformulas_inner \<phi> \<Longrightarrow> size \<psi> \<le> size \<phi>"
+    using subfrmlsn_size dual_order.strict_implies_order
+    by blast
+
+  show "\<psi> \<in> restricted_subformulas \<phi> \<Longrightarrow> size \<psi> < size \<phi>"
+    by (induction \<phi> arbitrary: \<psi>) (fastforce dest: inner)+
+qed
+
+lemma restricted_subformulas_notin:
+  "\<phi> \<notin> restricted_subformulas \<phi>"
+  using restricted_subformulas_size by auto
+
+lemma restricted_subformulas_superset:
+  "\<psi> \<in> restricted_subformulas \<phi> \<Longrightarrow> subformulas\<^sub>\<nu> \<psi> \<union> subformulas\<^sub>\<mu> \<psi> \<subseteq> restricted_subformulas \<phi>"
+proof -
+  assume "\<psi> \<in> restricted_subformulas \<phi>"
+
+  then obtain \<chi> x where
+    "\<psi> \<in> restricted_subformulas_inner \<chi>" and "(x R\<^sub>n \<chi>) \<in> subformulas\<^sub>\<nu> \<phi> \<or> (\<chi> W\<^sub>n x) \<in> subformulas\<^sub>\<nu> \<phi> "
+    by (induction \<phi>) auto
+
+  moreover
+
+  have "\<And>\<psi>\<^sub>1 \<psi>\<^sub>2. (\<psi>\<^sub>1 R\<^sub>n \<psi>\<^sub>2) \<in> subformulas\<^sub>\<nu> \<phi> \<Longrightarrow> restricted_subformulas_inner \<psi>\<^sub>2 \<subseteq> restricted_subformulas \<phi>"
+    "\<And>\<psi>\<^sub>1 \<psi>\<^sub>2. (\<psi>\<^sub>1 W\<^sub>n \<psi>\<^sub>2) \<in> subformulas\<^sub>\<nu> \<phi> \<Longrightarrow> restricted_subformulas_inner \<psi>\<^sub>1 \<subseteq> restricted_subformulas \<phi>"
+    by (induction \<phi>) (simp_all; insert restricted_subformulas_subset', blast)+
+
+  moreover
+
+  have "subformulas\<^sub>\<nu> \<psi> \<union> subformulas\<^sub>\<mu> \<psi> \<subseteq>  restricted_subformulas_inner \<chi>"
+    using `\<psi> \<in> restricted_subformulas_inner \<chi>`
+  proof (induction \<chi>)
+    case (Until_ltln \<chi>1 \<chi>2)
+    then show ?case
+      apply (cases "\<psi> = \<chi>1 U\<^sub>n \<chi>2")
+       apply auto[1]
+      apply simp
+      apply (cases "\<psi> \<in> subformulas\<^sub>\<nu> \<chi>1")
+       apply (meson le_supI1 le_supI2 subformulas\<^sub>\<mu>_subset subformulas\<^sub>\<nu>_subfrmlsn subformulas\<^sub>\<nu>_subset subset_eq subset_insertI2)
+      apply (cases "\<psi> \<in> subformulas\<^sub>\<nu> \<chi>2")
+       apply (meson le_supI1 le_supI2 subformulas\<^sub>\<mu>_subset subformulas\<^sub>\<nu>_subfrmlsn subformulas\<^sub>\<nu>_subset subset_eq subset_insertI2)
+      apply (cases "\<psi> \<in> subformulas\<^sub>\<mu> \<chi>1")
+       apply (metis (no_types, hide_lams) Un_insert_right subformulas\<^sub>\<mu>_subfrmlsn subformulas\<^sub>\<mu>_subset subformulas\<^sub>\<nu>_subset subsetD sup.coboundedI2 sup_commute)
+      apply simp
+      by (metis (no_types, hide_lams) Un_insert_right subformulas\<^sub>\<mu>_subfrmlsn subformulas\<^sub>\<mu>_subset subformulas\<^sub>\<nu>_subset subsetD sup.coboundedI2 sup_commute)
+  next
+    case (Release_ltln \<chi>1 \<chi>2)
+    then show ?case by simp blast
+  next
+    case (WeakUntil_ltln \<chi>1 \<chi>2)
+    then show ?case by simp blast
+  next
+    case (StrongRelease_ltln \<chi>1 \<chi>2)
+    then show ?case
+      apply (cases "\<psi> = \<chi>1 M\<^sub>n \<chi>2")
+       apply auto[1]
+      apply simp
+      apply (cases "\<psi> \<in> subformulas\<^sub>\<nu> \<chi>1")
+       apply (meson le_supI1 le_supI2 subformulas\<^sub>\<mu>_subset subformulas\<^sub>\<nu>_subfrmlsn subformulas\<^sub>\<nu>_subset subset_eq subset_insertI2)
+      apply (cases "\<psi> \<in> subformulas\<^sub>\<nu> \<chi>2")
+       apply (meson le_supI1 le_supI2 subformulas\<^sub>\<mu>_subset subformulas\<^sub>\<nu>_subfrmlsn subformulas\<^sub>\<nu>_subset subset_eq subset_insertI2)
+      apply (cases "\<psi> \<in> subformulas\<^sub>\<mu> \<chi>1")
+       apply (metis (no_types, hide_lams) Un_insert_right subformulas\<^sub>\<mu>_subfrmlsn subformulas\<^sub>\<mu>_subset subformulas\<^sub>\<nu>_subset subsetD sup.coboundedI2 sup_commute)
+      apply simp
+      by (metis (no_types, hide_lams) Un_insert_right subformulas\<^sub>\<mu>_subfrmlsn subformulas\<^sub>\<mu>_subset subformulas\<^sub>\<nu>_subset subsetD sup.coboundedI2 sup_commute)
+  qed auto
+
+  ultimately
+
+  show "subformulas\<^sub>\<nu> \<psi> \<union> subformulas\<^sub>\<mu> \<psi> \<subseteq> restricted_subformulas \<phi>"
+    by blast
+qed
+
+lemma restricted_subformulas_W_\<mu>:
+  "subformulas\<^sub>\<mu> \<phi> \<subseteq> restricted_subformulas (\<phi> W\<^sub>n \<psi>)"
+  by (induction \<phi>) auto
+
+lemma restricted_subformulas_R_\<mu>:
+  "subformulas\<^sub>\<mu> \<psi> \<subseteq> restricted_subformulas (\<phi> R\<^sub>n \<psi>)"
+  by (induction \<psi>) auto
+
+lemma restrict_af_letter:
+  "restricted_subformulas (af_letter \<phi> \<sigma>) = restricted_subformulas \<phi>"
+proof (induction \<phi>)
+  case (Release_ltln \<phi>1 \<phi>2)
+  then show ?case
+    using restricted_subformulas_subset' by simp blast
+next
+  case (WeakUntil_ltln \<phi>1 \<phi>2)
+  then show ?case
+    using restricted_subformulas_subset' by simp blast
+qed auto
+
+lemma restrict_af:
+  "restricted_subformulas (af \<phi> w) = restricted_subformulas \<phi>"
+  by (induction w rule: rev_induct) (auto simp: restrict_af_letter)
+
+
+subsection \<open>Restricted Master Theorem / Lemmas\<close>
+
+lemma delay_2:
+  assumes "\<mu>_stable \<phi> w"
+  assumes "w \<Turnstile>\<^sub>n \<phi>"
+  shows "\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>]\<^sub>\<nu>"
+  using assms
+proof (induction \<phi> arbitrary: w)
+  case (Prop_ltln x)
+  then show ?case
+    by (metis GF_advice.simps(10) GF_advice_af prefix_suffix)
+next
+  case (Nprop_ltln x)
+  then show ?case
+    by (metis GF_advice.simps(11) GF_advice_af prefix_suffix)
+next
+  case (And_ltln \<phi>1 \<phi>2)
+
+  let ?X  = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas (\<phi>1 and\<^sub>n \<phi>2)"
+  let ?X1 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>1"
+  let ?X2 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>2"
+
+  have "?X1 \<subseteq> ?X" and "?X2 \<subseteq> ?X"
+    by auto
+
+  moreover
+
+  obtain i j where "suffix i w \<Turnstile>\<^sub>n af \<phi>1 (prefix i w)[?X1]\<^sub>\<nu>"
+    and "suffix j w \<Turnstile>\<^sub>n af \<phi>2 (prefix j w)[?X2]\<^sub>\<nu>"
+    using \<mu>_stable_subfrmlsn[OF \<open>\<mu>_stable (\<phi>1 and\<^sub>n \<phi>2) w\<close>] And_ltln by fastforce
+
+  ultimately
+
+  obtain k where "suffix k w \<Turnstile>\<^sub>n af \<phi>1 (prefix k w)[?X]\<^sub>\<nu>"
+    and "suffix k w \<Turnstile>\<^sub>n af \<phi>2 (prefix k w)[?X]\<^sub>\<nu>"
+    using GF_advice_sync_and GF_advice_monotone by blast
+
+  thus ?case
+    unfolding af_decompose semantics_ltln.simps(5) GF_advice.simps by blast
+next
+  case (Or_ltln \<phi>1 \<phi>2)
+  let ?X  = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas (\<phi>1 and\<^sub>n \<phi>2)"
+  let ?X1 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>1"
+  let ?X2 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>2"
+
+  have "?X1 \<subseteq> ?X" and "?X2 \<subseteq> ?X"
+    by auto
+
+  moreover
+
+  obtain i j where "suffix i w \<Turnstile>\<^sub>n af \<phi>1 (prefix i w)[?X1]\<^sub>\<nu> \<or> suffix j w \<Turnstile>\<^sub>n af \<phi>2 (prefix j w)[?X2]\<^sub>\<nu>"
+    using \<mu>_stable_subfrmlsn[OF \<open>\<mu>_stable (\<phi>1 or\<^sub>n \<phi>2) w\<close>] Or_ltln by fastforce
+
+  ultimately
+
+  obtain k where "suffix k w \<Turnstile>\<^sub>n af \<phi>1 (prefix k w)[?X]\<^sub>\<nu> \<or> suffix k w \<Turnstile>\<^sub>n af \<phi>2 (prefix k w)[?X]\<^sub>\<nu>"
+    using GF_advice_monotone by blast
+
+  thus ?case
+    unfolding af_decompose semantics_ltln.simps(6) GF_advice.simps by auto
+next
+  case (Next_ltln \<phi>)
+  then have stable: "\<mu>_stable \<phi> (suffix 1 w)"
+    and suffix: "suffix 1 w \<Turnstile>\<^sub>n \<phi>"
+    using \<F>_suffix \<G>\<F>_\<F>_subset \<G>\<F>_suffix
+    by (simp_all add: \<mu>_stable_def) fast
+  show ?case
+    by (metis (no_types, lifting) Next_ltln.IH[OF stable suffix, unfolded suffix_suffix prefix_suffix_subsequence GF_suffix] One_nat_def add.commute af_simps(3) foldl_Nil foldl_append restricted_subformulas.simps(3) subsequence_append subsequence_singleton)
+next
+  case (Until_ltln \<phi>1 \<phi>2)
+  let ?X  = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas (\<phi>1 U\<^sub>n \<phi>2)"
+  let ?X1 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>1"
+  let ?X2 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>2"
+
+  have stable_1: "\<And>i. \<mu>_stable \<phi>1 (suffix i w)"
+    and stable_2: "\<And>i. \<mu>_stable \<phi>2 (suffix i w)"
+    using \<mu>_stable_subfrmlsn[OF Until_ltln.prems(1)] by (simp add: \<mu>_stable_suffix)+
+
+  obtain i where "\<And>j. j < i \<Longrightarrow> suffix j w \<Turnstile>\<^sub>n \<phi>1" and "suffix i w \<Turnstile>\<^sub>n \<phi>2"
+    using Until_ltln by auto
+
+  then have "\<And>j. j < i \<Longrightarrow> \<exists>k. suffix (j + k) w \<Turnstile>\<^sub>n af \<phi>1 (w [j \<rightarrow> k + j])[?X1]\<^sub>\<nu>"
+    and "\<exists>k. suffix (i + k) w \<Turnstile>\<^sub>n af \<phi>2 (w [i \<rightarrow> k + i])[?X2]\<^sub>\<nu>"
+    using Until_ltln.IH(1)[OF stable_1, unfolded suffix_suffix prefix_suffix_subsequence GF_suffix]
+    using Until_ltln.IH(2)[OF stable_2, unfolded suffix_suffix prefix_suffix_subsequence GF_suffix]
+    by blast+
+
+  moreover
+
+  have "?X1 \<subseteq> ?X"
+    and "?X2 \<subseteq> ?X"
+    by auto
+
+  ultimately
+
+  obtain k where "k \<ge> i"
+    and "suffix k w \<Turnstile>\<^sub>n af \<phi>2 (w [i \<rightarrow> k])[?X]\<^sub>\<nu>"
+    and "\<And>j. j < i \<Longrightarrow> suffix k w \<Turnstile>\<^sub>n af \<phi>1 (w [j \<rightarrow> k])[?X]\<^sub>\<nu>"
+    using GF_advice_sync_less[of i w \<phi>1 ?X \<phi>2] GF_advice_monotone[of _ ?X] by meson
+
+  hence "suffix (Suc k) w \<Turnstile>\<^sub>n af (\<phi>1 U\<^sub>n \<phi>2) (prefix (Suc k) w)[?X]\<^sub>\<nu>"
+    by (rule af_subsequence_U_GF_advice)
+
+  then show ?case
+    by blast
+next
+  case (WeakUntil_ltln \<phi>1 \<phi>2)
+
+  let ?X  = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas (\<phi>1 W\<^sub>n \<phi>2)"
+  let ?X1 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>1"
+  let ?X2 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>2"
+
+  have stable_1: "\<And>i. \<mu>_stable \<phi>1 (suffix i w)"
+    and stable_2: "\<And>i. \<mu>_stable \<phi>2 (suffix i w)"
+    using \<mu>_stable_subfrmlsn[OF WeakUntil_ltln.prems(1)] by (simp add: \<mu>_stable_suffix)+
+
+  {
+    assume Until_ltln: "w \<Turnstile>\<^sub>n \<phi>1 U\<^sub>n \<phi>2"
+    then obtain i where "\<And>j. j < i \<Longrightarrow> suffix j w \<Turnstile>\<^sub>n \<phi>1" and "suffix i w \<Turnstile>\<^sub>n \<phi>2"
+      by auto
+
+    then have "\<And>j. j < i \<Longrightarrow> \<exists>k. suffix (j + k) w \<Turnstile>\<^sub>n af \<phi>1 (w [j \<rightarrow> k + j])[?X1]\<^sub>\<nu>"
+      and "\<exists>k. suffix (i + k) w \<Turnstile>\<^sub>n af \<phi>2 (w [i \<rightarrow> k + i])[?X2]\<^sub>\<nu>"
+      using WeakUntil_ltln.IH(1)[OF stable_1, unfolded suffix_suffix prefix_suffix_subsequence GF_suffix]
+      using WeakUntil_ltln.IH(2)[OF stable_2, unfolded suffix_suffix prefix_suffix_subsequence GF_suffix]
+      by blast+
+
+    moreover
+
+    have "?X1 \<subseteq> ?X"
+      and "?X2 \<subseteq> ?X"
+      using restricted_subformulas_subset' by force+
+
+    ultimately
+
+    obtain k where "k \<ge> i"
+      and "suffix k w \<Turnstile>\<^sub>n af \<phi>2 (w [i \<rightarrow> k])[?X]\<^sub>\<nu>"
+      and "\<And>j. j < i \<Longrightarrow> suffix k w \<Turnstile>\<^sub>n af \<phi>1 (w [j \<rightarrow> k])[?X]\<^sub>\<nu>"
+      using GF_advice_sync_less[of i w \<phi>1 ?X \<phi>2] GF_advice_monotone[of _ ?X] by meson
+
+    hence "suffix (Suc k) w \<Turnstile>\<^sub>n af (\<phi>1 W\<^sub>n \<phi>2) (prefix (Suc k) w)[?X]\<^sub>\<nu>"
+      by (rule af_subsequence_W_GF_advice)
+    hence ?case
+      by blast
+  }
+  moreover
+  {
+    assume Globally_ltln: "w \<Turnstile>\<^sub>n G\<^sub>n \<phi>1"
+
+    {
+      fix j
+      have "suffix j w \<Turnstile>\<^sub>n \<phi>1"
+        using Globally_ltln by simp
+      then have "suffix j w \<Turnstile>\<^sub>n \<phi>1[{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)}]\<^sub>\<nu>"
+        by (metis stable_1 GF_advice_a1 \<G>\<F>_suffix \<mu>_stable_def \<G>\<F>_elim mem_Collect_eq subsetI)
+      then have "suffix j w \<Turnstile>\<^sub>n \<phi>1[?X]\<^sub>\<nu>"
+        by (metis GF_advice_inter restricted_subformulas_W_\<mu> le_infI2)
+    }
+
+    then have "w \<Turnstile>\<^sub>n (\<phi>1 W\<^sub>n \<phi>2)[?X]\<^sub>\<nu>"
+      by simp
+    then have ?case
+      using GF_advice_af_2 by blast
+  }
+  ultimately
+  show ?case
+    using WeakUntil_ltln.prems(2) ltln_weak_to_strong(1) by blast
+next
+  case (Release_ltln \<phi>1 \<phi>2)
+
+  let ?X  = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas (\<phi>1 R\<^sub>n \<phi>2)"
+  let ?X1 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>1"
+  let ?X2 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>2"
+
+  have stable_1: "\<And>i. \<mu>_stable \<phi>1 (suffix i w)"
+    and stable_2: "\<And>i. \<mu>_stable \<phi>2 (suffix i w)"
+    using \<mu>_stable_subfrmlsn[OF Release_ltln.prems(1)] by (simp add: \<mu>_stable_suffix)+
+
+  {
+    assume Until_ltln: "w \<Turnstile>\<^sub>n \<phi>1 M\<^sub>n \<phi>2"
+    then obtain i where "\<And>j. j \<le> i \<Longrightarrow> suffix j w \<Turnstile>\<^sub>n \<phi>2" and "suffix i w \<Turnstile>\<^sub>n \<phi>1"
+      by auto
+
+    then have "\<And>j. j \<le> i \<Longrightarrow> \<exists>k. suffix (j + k) w \<Turnstile>\<^sub>n af \<phi>2 (w [j \<rightarrow> k + j])[?X2]\<^sub>\<nu>"
+      and "\<exists>k. suffix (i + k) w \<Turnstile>\<^sub>n af \<phi>1 (w [i \<rightarrow> k + i])[?X1]\<^sub>\<nu>"
+      using Release_ltln.IH(1)[OF stable_1, unfolded suffix_suffix prefix_suffix_subsequence GF_suffix]
+      using Release_ltln.IH(2)[OF stable_2, unfolded suffix_suffix prefix_suffix_subsequence GF_suffix]
+      by blast+
+
+    moreover
+
+    have "?X1 \<subseteq> ?X"
+      and "?X2 \<subseteq> ?X"
+      using restricted_subformulas_subset' by force+
+
+    ultimately
+
+    obtain k where "k \<ge> i"
+      and "suffix k w \<Turnstile>\<^sub>n af \<phi>1 (w [i \<rightarrow> k])[?X]\<^sub>\<nu>"
+      and "\<And>j. j \<le> i \<Longrightarrow> suffix k w \<Turnstile>\<^sub>n af \<phi>2 (w [j \<rightarrow> k])[?X]\<^sub>\<nu>"
+      using GF_advice_sync_lesseq[of i w \<phi>2 ?X \<phi>1] GF_advice_monotone[of _ ?X] by meson
+
+    hence "suffix (Suc k) w \<Turnstile>\<^sub>n af (\<phi>1 R\<^sub>n \<phi>2) (prefix (Suc k) w)[?X]\<^sub>\<nu>"
+      by (rule af_subsequence_R_GF_advice)
+    hence ?case
+      by blast
+  }
+  moreover
+  {
+    assume Globally_ltln: "w \<Turnstile>\<^sub>n G\<^sub>n \<phi>2"
+
+    {
+      fix j
+      have "suffix j w \<Turnstile>\<^sub>n \<phi>2"
+        using Globally_ltln by simp
+      then have "suffix j w \<Turnstile>\<^sub>n \<phi>2[{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)}]\<^sub>\<nu>"
+        by (metis stable_2 GF_advice_a1 \<G>\<F>_suffix \<mu>_stable_def \<G>\<F>_elim mem_Collect_eq subsetI)
+      then have "suffix j w \<Turnstile>\<^sub>n \<phi>2[?X]\<^sub>\<nu>"
+        by (metis GF_advice_inter restricted_subformulas_R_\<mu> le_infI2)
+    }
+
+    then have "w \<Turnstile>\<^sub>n (\<phi>1 R\<^sub>n \<phi>2)[?X]\<^sub>\<nu>"
+      by simp
+    then have ?case
+      using GF_advice_af_2 by blast
+  }
+  ultimately
+  show ?case
+    using Release_ltln.prems(2) ltln_weak_to_strong(3) by blast
+next
+  case (StrongRelease_ltln \<phi>1 \<phi>2)
+
+  let ?X  = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas (\<phi>1 M\<^sub>n \<phi>2)"
+  let ?X1 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>1"
+  let ?X2 = "{\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} \<inter> restricted_subformulas \<phi>2"
+
+  have stable_1: "\<And>i. \<mu>_stable \<phi>1 (suffix i w)"
+    and stable_2: "\<And>i. \<mu>_stable \<phi>2 (suffix i w)"
+    using \<mu>_stable_subfrmlsn[OF StrongRelease_ltln.prems(1)] by (simp add: \<mu>_stable_suffix)+
+
+  obtain i where "\<And>j. j \<le> i \<Longrightarrow> suffix j w \<Turnstile>\<^sub>n \<phi>2" and "suffix i w \<Turnstile>\<^sub>n \<phi>1"
+    using StrongRelease_ltln by auto
+
+  then have "\<And>j. j \<le> i \<Longrightarrow> \<exists>k. suffix (j + k) w \<Turnstile>\<^sub>n af \<phi>2 (w [j \<rightarrow> k + j])[?X2]\<^sub>\<nu>"
+    and "\<exists>k. suffix (i + k) w \<Turnstile>\<^sub>n af \<phi>1 (w [i \<rightarrow> k + i])[?X1]\<^sub>\<nu>"
+    using StrongRelease_ltln.IH(1)[OF stable_1, unfolded suffix_suffix prefix_suffix_subsequence GF_suffix]
+    using StrongRelease_ltln.IH(2)[OF stable_2, unfolded suffix_suffix prefix_suffix_subsequence GF_suffix]
+    by blast+
+
+  moreover
+
+  have "?X1 \<subseteq> ?X"
+    and "?X2 \<subseteq> ?X"
+    by auto
+
+  ultimately
+
+  obtain k where "k \<ge> i"
+    and "suffix k w \<Turnstile>\<^sub>n af \<phi>1 (w [i \<rightarrow> k])[?X]\<^sub>\<nu>"
+    and "\<And>j. j \<le> i \<Longrightarrow> suffix k w \<Turnstile>\<^sub>n af \<phi>2 (w [j \<rightarrow> k])[?X]\<^sub>\<nu>"
+    using GF_advice_sync_lesseq[of i w \<phi>2 ?X \<phi>1] GF_advice_monotone[of _ ?X] by meson
+
+  hence "suffix (Suc k) w \<Turnstile>\<^sub>n af (\<phi>1 M\<^sub>n \<phi>2) (prefix (Suc k) w)[?X]\<^sub>\<nu>"
+    by (rule af_subsequence_M_GF_advice)
+
+  then show ?case
+    by blast
+qed simp+
+
+theorem master_theorem_restricted:
+  "w \<Turnstile>\<^sub>n \<phi> \<longleftrightarrow>
+    (\<exists>X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<inter> restricted_subformulas \<phi>.
+       (\<exists>Y \<subseteq> subformulas\<^sub>\<nu> \<phi> \<inter> restricted_subformulas \<phi>.
+         (\<exists>i. (suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[X]\<^sub>\<nu>)
+          \<and> (\<forall>\<psi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[Y]\<^sub>\<mu>))
+          \<and> (\<forall>\<psi> \<in> Y. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[X]\<^sub>\<nu>)))))"
+  (is "?lhs \<longleftrightarrow> ?rhs")
+proof
+  assume ?lhs
+
+  obtain i where "\<mu>_stable \<phi> (suffix i w)"
+   by (metis MOST_nat less_Suc_eq suffix_\<mu>_stable)
+
+  hence stable: "\<mu>_stable (af \<phi> (prefix i w)) (suffix i w)"
+    by (simp add: \<F>_af \<G>\<F>_af \<mu>_stable_def)
+
+  let ?\<phi>' = "af \<phi> (prefix i w)"
+  let ?X' = "\<G>\<F> \<phi> w \<inter> restricted_subformulas \<phi>"
+  let ?Y' = "\<F>\<G> \<phi> w \<inter> restricted_subformulas \<phi>"
+
+  have 1: "suffix i w \<Turnstile>\<^sub>n ?\<phi>'"
+    using `?lhs` af_ltl_continuation by force
+
+  have 2: "\<And>j. af (af \<phi> (prefix i w)) (prefix j (suffix i w)) = af \<phi> (prefix (i + j) w)"
+    by (simp add: subsequence_append)
+
+  have 3: "\<G>\<F> \<phi> w = \<G>\<F> \<phi> (suffix i w)"
+    using \<G>\<F>_af \<G>\<F>_suffix by blast
+
+  have "\<exists>j. suffix (i + j) w \<Turnstile>\<^sub>n af (?\<phi>') (prefix j (suffix i w))[?X']\<^sub>\<nu>"
+    using delay_2[OF stable 1] unfolding suffix_suffix 2 restrict_af 3 unfolding \<G>\<F>_semantics'
+    by (metis (no_types, lifting) GF_advice_inter_subformulas af_subformulas\<^sub>\<mu> inf_assoc inf_commute)
+
+  hence "\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[?X']\<^sub>\<nu>"
+    using 2 by auto
+
+  moreover
+
+  {
+    fix \<psi>
+    have "\<And>X. \<psi> \<in> restricted_subformulas \<phi> \<Longrightarrow> \<psi>[X \<inter> restricted_subformulas \<phi>]\<^sub>\<mu> = \<psi>[X]\<^sub>\<mu>"
+      by (metis le_supE restricted_subformulas_superset FG_advice_inter inf.coboundedI2)
+    hence "\<psi> \<in> ?X' \<Longrightarrow>  w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[?Y']\<^sub>\<mu>)"
+      using \<G>\<F>_implies_GF by force
+  }
+
+  moreover
+
+  {
+    fix \<psi>
+    have "\<And>X. \<psi> \<in> restricted_subformulas \<phi> \<Longrightarrow> \<psi>[X \<inter> restricted_subformulas \<phi>]\<^sub>\<nu> = \<psi>[X]\<^sub>\<nu>"
+      by (metis le_supE restricted_subformulas_superset GF_advice_inter inf.coboundedI2)
+    hence "\<psi> \<in> ?Y' \<Longrightarrow> w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[?X']\<^sub>\<nu>)"
+      using \<F>\<G>_implies_FG by force
+  }
+
+  moreover
+
+  have "?X' \<subseteq> subformulas\<^sub>\<mu> \<phi> \<inter> restricted_subformulas \<phi>"
+    using \<G>\<F>_subformulas\<^sub>\<mu> by blast
+
+  moreover
+
+  have "?Y' \<subseteq> subformulas\<^sub>\<nu> \<phi> \<inter> restricted_subformulas \<phi>"
+    using \<F>\<G>_subformulas\<^sub>\<nu> by blast
+
+  ultimately show ?rhs
+    by meson
+qed (insert master_theorem, fast)
+
+
+corollary master_theorem_restricted_language:
+  "language_ltln \<phi> = \<Union> {L\<^sub>1 \<phi> X \<inter> L\<^sub>2 X Y \<inter> L\<^sub>3 X Y | X Y. X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<inter> restricted_subformulas \<phi> \<and> Y \<subseteq> subformulas\<^sub>\<nu> \<phi> \<inter> restricted_subformulas \<phi>}"
+proof safe
+  fix w
+  assume "w \<in> language_ltln \<phi>"
+
+  then have "w \<Turnstile>\<^sub>n \<phi>"
+    unfolding language_ltln_def by simp
+
+  then obtain X Y where
+        1: "X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<inter> restricted_subformulas \<phi>"
+    and 2: "Y \<subseteq> subformulas\<^sub>\<nu> \<phi> \<inter> restricted_subformulas \<phi>"
+    and "\<exists>i. suffix i w \<Turnstile>\<^sub>n af \<phi> (prefix i w)[X]\<^sub>\<nu>"
+    and "\<forall>\<psi> \<in> X. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>[Y]\<^sub>\<mu>)"
+    and "\<forall>\<psi> \<in> Y. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>[X]\<^sub>\<nu>)"
+    using master_theorem_restricted by metis
+
+  then have "w \<in> L\<^sub>1 \<phi> X" and "w \<in> L\<^sub>2 X Y" and "w \<in> L\<^sub>3 X Y"
+    unfolding L\<^sub>1_def L\<^sub>2_def L\<^sub>3_def by simp+
+
+  then show "w \<in> \<Union> {L\<^sub>1 \<phi> X \<inter> L\<^sub>2 X Y \<inter> L\<^sub>3 X Y | X Y. X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<inter> restricted_subformulas \<phi> \<and> Y \<subseteq> subformulas\<^sub>\<nu> \<phi> \<inter> restricted_subformulas \<phi>}"
+    using 1 2 by blast
+next
+  fix w X Y
+  assume "X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<inter> restricted_subformulas \<phi>" and "Y \<subseteq> subformulas\<^sub>\<nu> \<phi> \<inter> restricted_subformulas \<phi>"
+    and "w \<in> L\<^sub>1 \<phi> X" and "w \<in> L\<^sub>2 X Y" and "w \<in> L\<^sub>3 X Y"
+
+  then show "w \<in> language_ltln \<phi>"
+    unfolding language_ltln_def L\<^sub>1_def L\<^sub>2_def L\<^sub>3_def
+    using master_theorem_restricted by blast
+qed
+
+
+subsection \<open>Definitions with Lists for Code Export\<close>
+
+definition restricted_advice_sets :: "'a ltln \<Rightarrow> ('a ltln list \<times> 'a ltln list) list"
+where
+  "restricted_advice_sets \<phi> = List.product (subseqs (List.filter (\<lambda>x. x \<in> restricted_subformulas \<phi>) (subformulas\<^sub>\<mu>_list \<phi>))) (subseqs (List.filter (\<lambda>x. x \<in> restricted_subformulas \<phi>) (subformulas\<^sub>\<nu>_list \<phi>)))"
+
+lemma subseqs_subformulas\<^sub>\<mu>_restricted_list:
+  "X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<inter> restricted_subformulas \<phi> \<longleftrightarrow> (\<exists>xs. X = set xs \<and> xs \<in> set (subseqs (List.filter (\<lambda>x. x \<in> restricted_subformulas \<phi>) (subformulas\<^sub>\<mu>_list \<phi>))))"
+  by (metis in_set_subseqs inf_commute inter_set_filter subformulas\<^sub>\<mu>_list_set subset_subseq)
+
+lemma subseqs_subformulas\<^sub>\<nu>_restricted_list:
+  "Y \<subseteq> subformulas\<^sub>\<nu> \<phi> \<inter> restricted_subformulas \<phi> \<longleftrightarrow> (\<exists>ys. Y = set ys \<and> ys \<in> set (subseqs (List.filter (\<lambda>x. x \<in> restricted_subformulas \<phi>) (subformulas\<^sub>\<nu>_list \<phi>))))"
+  by (metis in_set_subseqs inf_commute inter_set_filter subformulas\<^sub>\<nu>_list_set subset_subseq)
+
+lemma restricted_advice_sets_subformulas:
+  "X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<inter> restricted_subformulas \<phi> \<and> Y \<subseteq> subformulas\<^sub>\<nu> \<phi> \<inter> restricted_subformulas \<phi> \<longleftrightarrow> (\<exists>xs ys. X = set xs \<and> Y = set ys \<and> (xs, ys) \<in> set (restricted_advice_sets \<phi>))"
+  unfolding restricted_advice_sets_def set_product subseqs_subformulas\<^sub>\<mu>_restricted_list subseqs_subformulas\<^sub>\<nu>_restricted_list by blast
+
+lemma restricted_advice_sets_not_empty:
+  "restricted_advice_sets \<phi> \<noteq> []"
+  unfolding restricted_advice_sets_def using subseqs_not_empty product_not_empty by blast
+
+end
diff --git a/thys/LTL_Master_Theorem/Logical_Characterization/Syntactic_Fragments_and_Stability.thy b/thys/LTL_Master_Theorem/Logical_Characterization/Syntactic_Fragments_and_Stability.thy
--- a/thys/LTL_Master_Theorem/Logical_Characterization/Syntactic_Fragments_and_Stability.thy
+++ b/thys/LTL_Master_Theorem/Logical_Characterization/Syntactic_Fragments_and_Stability.thy
@@ -1,516 +1,548 @@
 (*
     Author:   Benedikt Seidl
     License:  BSD
 *)
 
 section \<open>Syntactic Fragments and Stability\<close>
 
 theory Syntactic_Fragments_and_Stability
 imports
   LTL.LTL "HOL-Library.Sublist"
 begin
 
 \<comment> \<open>We use prefix and suffix on infinite words.\<close>
 hide_const Sublist.prefix Sublist.suffix
 
 subsection \<open>The fragments @{term \<mu>LTL} and @{term \<nu>LTL}\<close>
 
 fun is_\<mu>LTL :: "'a ltln \<Rightarrow> bool"
 where
   "is_\<mu>LTL true\<^sub>n = True"
 | "is_\<mu>LTL false\<^sub>n = True"
 | "is_\<mu>LTL prop\<^sub>n(_) = True"
 | "is_\<mu>LTL nprop\<^sub>n(_) = True"
 | "is_\<mu>LTL (\<phi> and\<^sub>n \<psi>) = (is_\<mu>LTL \<phi> \<and> is_\<mu>LTL \<psi>)"
 | "is_\<mu>LTL (\<phi> or\<^sub>n \<psi>) = (is_\<mu>LTL \<phi> \<and> is_\<mu>LTL \<psi>)"
 | "is_\<mu>LTL (X\<^sub>n \<phi>) = is_\<mu>LTL \<phi>"
 | "is_\<mu>LTL (\<phi> U\<^sub>n \<psi>) = (is_\<mu>LTL \<phi> \<and> is_\<mu>LTL \<psi>)"
 | "is_\<mu>LTL (\<phi> M\<^sub>n \<psi>) = (is_\<mu>LTL \<phi> \<and> is_\<mu>LTL \<psi>)"
 | "is_\<mu>LTL _ = False"
 
 fun is_\<nu>LTL :: "'a ltln \<Rightarrow> bool"
 where
   "is_\<nu>LTL true\<^sub>n = True"
 | "is_\<nu>LTL false\<^sub>n = True"
 | "is_\<nu>LTL prop\<^sub>n(_) = True"
 | "is_\<nu>LTL nprop\<^sub>n(_) = True"
 | "is_\<nu>LTL (\<phi> and\<^sub>n \<psi>) = (is_\<nu>LTL \<phi> \<and> is_\<nu>LTL \<psi>)"
 | "is_\<nu>LTL (\<phi> or\<^sub>n \<psi>) = (is_\<nu>LTL \<phi> \<and> is_\<nu>LTL \<psi>)"
 | "is_\<nu>LTL (X\<^sub>n \<phi>) = is_\<nu>LTL \<phi>"
 | "is_\<nu>LTL (\<phi> W\<^sub>n \<psi>) = (is_\<nu>LTL \<phi> \<and> is_\<nu>LTL \<psi>)"
 | "is_\<nu>LTL (\<phi> R\<^sub>n \<psi>) = (is_\<nu>LTL \<phi> \<and> is_\<nu>LTL \<psi>)"
 | "is_\<nu>LTL _ = False"
 
 definition \<mu>LTL :: "'a ltln set" where
   "\<mu>LTL = {\<phi>. is_\<mu>LTL \<phi>}"
 
 definition \<nu>LTL :: "'a ltln set" where
   "\<nu>LTL = {\<phi>. is_\<nu>LTL \<phi>}"
 
 lemma \<mu>LTL_simp[simp]:
   "\<phi> \<in> \<mu>LTL \<longleftrightarrow> is_\<mu>LTL \<phi>"
   unfolding \<mu>LTL_def by simp
 
 lemma \<nu>LTL_simp[simp]:
   "\<phi> \<in> \<nu>LTL \<longleftrightarrow> is_\<nu>LTL \<phi>"
   unfolding \<nu>LTL_def by simp
 
 
 
 subsubsection \<open>Subformulas in @{term \<mu>LTL} and @{term \<nu>LTL}\<close>
 
 fun subformulas\<^sub>\<mu> :: "'a ltln \<Rightarrow> 'a ltln set"
 where
   "subformulas\<^sub>\<mu> (\<phi> and\<^sub>n \<psi>) = subformulas\<^sub>\<mu> \<phi> \<union> subformulas\<^sub>\<mu> \<psi>"
 | "subformulas\<^sub>\<mu> (\<phi> or\<^sub>n \<psi>) = subformulas\<^sub>\<mu> \<phi> \<union> subformulas\<^sub>\<mu> \<psi>"
 | "subformulas\<^sub>\<mu> (X\<^sub>n \<phi>) = subformulas\<^sub>\<mu> \<phi>"
 | "subformulas\<^sub>\<mu> (\<phi> U\<^sub>n \<psi>) = {\<phi> U\<^sub>n \<psi>} \<union> subformulas\<^sub>\<mu> \<phi> \<union> subformulas\<^sub>\<mu> \<psi>"
 | "subformulas\<^sub>\<mu> (\<phi> R\<^sub>n \<psi>) = subformulas\<^sub>\<mu> \<phi> \<union> subformulas\<^sub>\<mu> \<psi>"
 | "subformulas\<^sub>\<mu> (\<phi> W\<^sub>n \<psi>) = subformulas\<^sub>\<mu> \<phi> \<union> subformulas\<^sub>\<mu> \<psi>"
 | "subformulas\<^sub>\<mu> (\<phi> M\<^sub>n \<psi>) = {\<phi> M\<^sub>n \<psi>} \<union> subformulas\<^sub>\<mu> \<phi> \<union> subformulas\<^sub>\<mu> \<psi>"
 | "subformulas\<^sub>\<mu> _ = {}"
 
 fun subformulas\<^sub>\<nu> :: "'a ltln \<Rightarrow> 'a ltln set"
 where
   "subformulas\<^sub>\<nu> (\<phi> and\<^sub>n \<psi>) = subformulas\<^sub>\<nu> \<phi> \<union> subformulas\<^sub>\<nu> \<psi>"
 | "subformulas\<^sub>\<nu> (\<phi> or\<^sub>n \<psi>) = subformulas\<^sub>\<nu> \<phi> \<union> subformulas\<^sub>\<nu> \<psi>"
 | "subformulas\<^sub>\<nu> (X\<^sub>n \<phi>) = subformulas\<^sub>\<nu> \<phi>"
 | "subformulas\<^sub>\<nu> (\<phi> U\<^sub>n \<psi>) = subformulas\<^sub>\<nu> \<phi> \<union> subformulas\<^sub>\<nu> \<psi>"
 | "subformulas\<^sub>\<nu> (\<phi> R\<^sub>n \<psi>) = {\<phi> R\<^sub>n \<psi>} \<union> subformulas\<^sub>\<nu> \<phi> \<union> subformulas\<^sub>\<nu> \<psi>"
 | "subformulas\<^sub>\<nu> (\<phi> W\<^sub>n \<psi>) = {\<phi> W\<^sub>n \<psi>} \<union> subformulas\<^sub>\<nu> \<phi> \<union> subformulas\<^sub>\<nu> \<psi>"
 | "subformulas\<^sub>\<nu> (\<phi> M\<^sub>n \<psi>) = subformulas\<^sub>\<nu> \<phi> \<union> subformulas\<^sub>\<nu> \<psi>"
 | "subformulas\<^sub>\<nu> _ = {}"
 
-abbreviation "ltln_U \<equiv> {\<phi> U\<^sub>n \<psi> | \<phi> \<psi>. True}"
-abbreviation "ltln_R \<equiv> {\<phi> R\<^sub>n \<psi> | \<phi> \<psi>. True}"
-abbreviation "ltln_W \<equiv> {\<phi> W\<^sub>n \<psi> | \<phi> \<psi>. True}"
-abbreviation "ltln_M \<equiv> {\<phi> M\<^sub>n \<psi> | \<phi> \<psi>. True}"
-
 lemma subformulas\<^sub>\<mu>_semantics:
-  "subformulas\<^sub>\<mu> \<phi> = subfrmlsn \<phi> \<inter> (ltln_U \<union> ltln_M)"
+  "subformulas\<^sub>\<mu> \<phi> = {\<psi> \<in> subfrmlsn \<phi>. \<exists>\<psi>\<^sub>1 \<psi>\<^sub>2. \<psi> = \<psi>\<^sub>1 U\<^sub>n \<psi>\<^sub>2 \<or> \<psi> = \<psi>\<^sub>1 M\<^sub>n \<psi>\<^sub>2}"
   by (induction \<phi>) auto
 
 lemma subformulas\<^sub>\<nu>_semantics:
-  "subformulas\<^sub>\<nu> \<phi> = subfrmlsn \<phi> \<inter> (ltln_R \<union> ltln_W)"
+  "subformulas\<^sub>\<nu> \<phi> = {\<psi> \<in> subfrmlsn \<phi>. \<exists>\<psi>\<^sub>1 \<psi>\<^sub>2. \<psi> = \<psi>\<^sub>1 R\<^sub>n \<psi>\<^sub>2 \<or> \<psi> = \<psi>\<^sub>1 W\<^sub>n \<psi>\<^sub>2}"
   by (induction \<phi>) auto
 
 lemma subformulas\<^sub>\<mu>_subfrmlsn:
   "subformulas\<^sub>\<mu> \<phi> \<subseteq> subfrmlsn \<phi>"
   by (induction \<phi>) auto
 
 lemma subformulas\<^sub>\<nu>_subfrmlsn:
   "subformulas\<^sub>\<nu> \<phi> \<subseteq> subfrmlsn \<phi>"
   by (induction \<phi>) auto
 
 lemma subformulas\<^sub>\<mu>_finite:
   "finite (subformulas\<^sub>\<mu> \<phi>)"
   by (induction \<phi>) auto
 
 lemma subformulas\<^sub>\<nu>_finite:
   "finite (subformulas\<^sub>\<nu> \<phi>)"
   by (induction \<phi>) auto
 
 lemma subformulas\<^sub>\<mu>_subset:
   "\<psi> \<in> subfrmlsn \<phi> \<Longrightarrow> subformulas\<^sub>\<mu> \<psi> \<subseteq> subformulas\<^sub>\<mu> \<phi>"
   by (induction \<phi>) auto
 
 lemma subformulas\<^sub>\<nu>_subset:
   "\<psi> \<in> subfrmlsn \<phi> \<Longrightarrow> subformulas\<^sub>\<nu> \<psi> \<subseteq> subformulas\<^sub>\<nu> \<phi>"
   by (induction \<phi>) auto
 
 lemma subfrmlsn_\<mu>LTL:
   "\<phi> \<in> \<mu>LTL \<Longrightarrow> subfrmlsn \<phi> \<subseteq> \<mu>LTL"
   by (induction \<phi>) auto
 
 lemma subfrmlsn_\<nu>LTL:
   "\<phi> \<in> \<nu>LTL \<Longrightarrow> subfrmlsn \<phi> \<subseteq> \<nu>LTL"
   by (induction \<phi>) auto
 
 lemma subformulas\<^sub>\<mu>\<^sub>\<nu>_disjoint:
   "subformulas\<^sub>\<mu> \<phi> \<inter> subformulas\<^sub>\<nu> \<phi> = {}"
   unfolding subformulas\<^sub>\<mu>_semantics subformulas\<^sub>\<nu>_semantics
   by fastforce
 
 lemma subformulas\<^sub>\<mu>\<^sub>\<nu>_subfrmlsn:
   "subformulas\<^sub>\<mu> \<phi> \<union> subformulas\<^sub>\<nu> \<phi> \<subseteq> subfrmlsn \<phi>"
   using subformulas\<^sub>\<mu>_subfrmlsn subformulas\<^sub>\<nu>_subfrmlsn by blast
 
 lemma subformulas\<^sub>\<mu>\<^sub>\<nu>_card:
   "card (subformulas\<^sub>\<mu> \<phi> \<union> subformulas\<^sub>\<nu> \<phi>) = card (subformulas\<^sub>\<mu> \<phi>) + card (subformulas\<^sub>\<nu> \<phi>)"
   by (simp add: subformulas\<^sub>\<mu>\<^sub>\<nu>_disjoint subformulas\<^sub>\<mu>_finite subformulas\<^sub>\<nu>_finite card_Un_disjoint)
 
 
-text \<open>The $\mu$- and $\nu$-subformulas as lists:\<close>
-
-fun subformulas\<^sub>\<mu>_list :: "'a ltln \<Rightarrow> 'a ltln list"
-where
-  "subformulas\<^sub>\<mu>_list (\<phi> and\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>)"
-| "subformulas\<^sub>\<mu>_list (\<phi> or\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>)"
-| "subformulas\<^sub>\<mu>_list (X\<^sub>n \<phi>) = subformulas\<^sub>\<mu>_list \<phi>"
-| "subformulas\<^sub>\<mu>_list (\<phi> U\<^sub>n \<psi>) = List.insert (\<phi> U\<^sub>n \<psi>) (List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>))"
-| "subformulas\<^sub>\<mu>_list (\<phi> R\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>)"
-| "subformulas\<^sub>\<mu>_list (\<phi> W\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>)"
-| "subformulas\<^sub>\<mu>_list (\<phi> M\<^sub>n \<psi>) = List.insert (\<phi> M\<^sub>n \<psi>) (List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>))"
-| "subformulas\<^sub>\<mu>_list _ = []"
-
-fun subformulas\<^sub>\<nu>_list :: "'a ltln \<Rightarrow> 'a ltln list"
-where
-  "subformulas\<^sub>\<nu>_list (\<phi> and\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>)"
-| "subformulas\<^sub>\<nu>_list (\<phi> or\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>)"
-| "subformulas\<^sub>\<nu>_list (X\<^sub>n \<phi>) = subformulas\<^sub>\<nu>_list \<phi>"
-| "subformulas\<^sub>\<nu>_list (\<phi> U\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>)"
-| "subformulas\<^sub>\<nu>_list (\<phi> R\<^sub>n \<psi>) = List.insert (\<phi> R\<^sub>n \<psi>) (List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>))"
-| "subformulas\<^sub>\<nu>_list (\<phi> W\<^sub>n \<psi>) = List.insert (\<phi> W\<^sub>n \<psi>) (List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>))"
-| "subformulas\<^sub>\<nu>_list (\<phi> M\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>)"
-| "subformulas\<^sub>\<nu>_list _ = []"
-
-lemma subformulas\<^sub>\<mu>_list_set:
-  "set (subformulas\<^sub>\<mu>_list \<phi>) = subformulas\<^sub>\<mu> \<phi>"
-  by (induction \<phi>) auto
-
-lemma subformulas\<^sub>\<nu>_list_set:
-  "set (subformulas\<^sub>\<nu>_list \<phi>) = subformulas\<^sub>\<nu> \<phi>"
-  by (induction \<phi>) auto
-
-lemma subformulas\<^sub>\<mu>_list_distinct:
-  "distinct (subformulas\<^sub>\<mu>_list \<phi>)"
-  by (induction \<phi>) auto
-
-lemma subformulas\<^sub>\<nu>_list_distinct:
-  "distinct (subformulas\<^sub>\<nu>_list \<phi>)"
-  by (induction \<phi>) auto
-
-lemma subformulas\<^sub>\<mu>_list_length:
-  "length (subformulas\<^sub>\<mu>_list \<phi>) = card (subformulas\<^sub>\<mu> \<phi>)"
-  by (metis subformulas\<^sub>\<mu>_list_set subformulas\<^sub>\<mu>_list_distinct distinct_card)
-
-lemma subformulas\<^sub>\<nu>_list_length:
-  "length (subformulas\<^sub>\<nu>_list \<phi>) = card (subformulas\<^sub>\<nu> \<phi>)"
-  by (metis subformulas\<^sub>\<nu>_list_set subformulas\<^sub>\<nu>_list_distinct distinct_card)
-
-
-
-subsection \<open>List of Advice Sets\<close>
-
-definition advice_sets :: "'a ltln \<Rightarrow> ('a ltln list \<times> 'a ltln list) list"
-where
-  "advice_sets \<phi> = List.product (subseqs (subformulas\<^sub>\<mu>_list \<phi>)) (subseqs (subformulas\<^sub>\<nu>_list \<phi>))"
-
-lemma subset_subseq:
-  "X \<subseteq> set ys \<longleftrightarrow> (\<exists>xs. X = set xs \<and> subseq xs ys)"
-  by (metis (no_types, lifting) Pow_iff image_iff in_set_subseqs subseqs_powset)
-
-lemma subseqs_subformulas\<^sub>\<mu>_list:
-  "X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<longleftrightarrow> (\<exists>xs. X = set xs \<and> xs \<in> set (subseqs (subformulas\<^sub>\<mu>_list \<phi>)))"
-  by (metis subset_subseq subformulas\<^sub>\<mu>_list_set in_set_subseqs)
-
-lemma subseqs_subformulas\<^sub>\<nu>_list:
-  "Y \<subseteq> subformulas\<^sub>\<nu> \<phi> \<longleftrightarrow> (\<exists>ys. Y = set ys \<and> ys \<in> set (subseqs (subformulas\<^sub>\<nu>_list \<phi>)))"
-  by (metis subset_subseq subformulas\<^sub>\<nu>_list_set in_set_subseqs)
-
-lemma advice_sets_subformulas:
-  "X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<and> Y \<subseteq> subformulas\<^sub>\<nu> \<phi> \<longleftrightarrow> (\<exists>xs ys. X = set xs \<and> Y = set ys \<and> (xs, ys) \<in> set (advice_sets \<phi>))"
-  unfolding advice_sets_def set_product subseqs_subformulas\<^sub>\<mu>_list subseqs_subformulas\<^sub>\<nu>_list by blast
-
-(* TODO add to HOL/List.thy *)
-lemma subseqs_not_empty:
-  "subseqs xs \<noteq> []"
-  by (metis empty_iff list.set(1) subseqs_refl)
-
-(* TODO add to HOL/List.thy *)
-lemma product_not_empty:
-  "xs \<noteq> [] \<Longrightarrow> ys \<noteq> [] \<Longrightarrow> List.product xs ys \<noteq> []"
-  by (induction xs) simp_all
-
-lemma advice_sets_not_empty:
-  "advice_sets \<phi> \<noteq> []"
-  unfolding advice_sets_def using subseqs_not_empty product_not_empty by blast
-
-lemma advice_sets_length:
-  "length (advice_sets \<phi>) \<le> 2 ^ card (subfrmlsn \<phi>)"
-  unfolding advice_sets_def length_product length_subseqs subformulas\<^sub>\<mu>_list_length subformulas\<^sub>\<nu>_list_length power_add[symmetric]
-  by (metis Suc_1 card_mono lessI power_increasing_iff subformulas\<^sub>\<mu>\<^sub>\<nu>_card subformulas\<^sub>\<mu>\<^sub>\<nu>_subfrmlsn subfrmlsn_finite)
-
-lemma advice_sets_element_length:
-  "(xs, ys) \<in> set (advice_sets \<phi>) \<Longrightarrow> length xs \<le> card (subfrmlsn \<phi>)"
-  "(xs, ys) \<in> set (advice_sets \<phi>) \<Longrightarrow> length ys \<le> card (subfrmlsn \<phi>)"
-  unfolding advice_sets_def set_product
-  by (metis SigmaD1 card_mono in_set_subseqs list_emb_length order_trans subformulas\<^sub>\<mu>_list_length subformulas\<^sub>\<mu>_subfrmlsn subfrmlsn_finite)
-     (metis SigmaD2 card_mono in_set_subseqs list_emb_length order_trans subformulas\<^sub>\<nu>_list_length subformulas\<^sub>\<nu>_subfrmlsn subfrmlsn_finite)
-
-lemma advice_sets_element_subfrmlsn:
-  "(xs, ys) \<in> set (advice_sets \<phi>) \<Longrightarrow> set xs \<subseteq> subformulas\<^sub>\<mu> \<phi>"
-  "(xs, ys) \<in> set (advice_sets \<phi>) \<Longrightarrow> set ys \<subseteq> subformulas\<^sub>\<nu> \<phi>"
-  unfolding advice_sets_def set_product
-  by (meson SigmaD1 subseqs_subformulas\<^sub>\<mu>_list)
-     (meson SigmaD2 subseqs_subformulas\<^sub>\<nu>_list)
-
-
-
 subsection \<open>Stability\<close>
 
 definition "GF_singleton w \<phi> \<equiv> if w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<phi>) then {\<phi>} else {}"
 definition "F_singleton w \<phi> \<equiv> if w \<Turnstile>\<^sub>n F\<^sub>n \<phi> then {\<phi>} else {}"
 
 declare GF_singleton_def [simp] F_singleton_def [simp]
 
 fun \<G>\<F> :: "'a ltln \<Rightarrow> 'a set word \<Rightarrow> 'a ltln set"
 where
   "\<G>\<F> (\<phi> and\<^sub>n \<psi>) w = \<G>\<F> \<phi> w \<union> \<G>\<F> \<psi> w"
 | "\<G>\<F> (\<phi> or\<^sub>n \<psi>) w = \<G>\<F> \<phi> w \<union> \<G>\<F> \<psi> w"
 | "\<G>\<F> (X\<^sub>n \<phi>) w = \<G>\<F> \<phi> w"
 | "\<G>\<F> (\<phi> U\<^sub>n \<psi>) w = GF_singleton w (\<phi> U\<^sub>n \<psi>) \<union> \<G>\<F> \<phi> w \<union> \<G>\<F> \<psi> w"
 | "\<G>\<F> (\<phi> R\<^sub>n \<psi>) w = \<G>\<F> \<phi> w \<union> \<G>\<F> \<psi> w"
 | "\<G>\<F> (\<phi> W\<^sub>n \<psi>) w = \<G>\<F> \<phi> w \<union> \<G>\<F> \<psi> w"
 | "\<G>\<F> (\<phi> M\<^sub>n \<psi>) w = GF_singleton w (\<phi> M\<^sub>n \<psi>) \<union> \<G>\<F> \<phi> w \<union> \<G>\<F> \<psi> w"
 | "\<G>\<F> _ _ = {}"
 
 fun \<F> :: "'a ltln \<Rightarrow> 'a set word \<Rightarrow> 'a ltln set"
 where
   "\<F> (\<phi> and\<^sub>n \<psi>) w = \<F> \<phi> w \<union> \<F> \<psi> w"
 | "\<F> (\<phi> or\<^sub>n \<psi>) w = \<F> \<phi> w \<union> \<F> \<psi> w"
 | "\<F> (X\<^sub>n \<phi>) w = \<F> \<phi> w"
 | "\<F> (\<phi> U\<^sub>n \<psi>) w = F_singleton w (\<phi> U\<^sub>n \<psi>) \<union> \<F> \<phi> w \<union> \<F> \<psi> w"
 | "\<F> (\<phi> R\<^sub>n \<psi>) w = \<F> \<phi> w \<union> \<F> \<psi> w"
 | "\<F> (\<phi> W\<^sub>n \<psi>) w = \<F> \<phi> w \<union> \<F> \<psi> w"
 | "\<F> (\<phi> M\<^sub>n \<psi>) w = F_singleton w (\<phi> M\<^sub>n \<psi>) \<union> \<F> \<phi> w \<union> \<F> \<psi> w"
 | "\<F> _ _ = {}"
 
 
 lemma \<G>\<F>_semantics:
   "\<G>\<F> \<phi> w = {\<psi>. \<psi> \<in> subformulas\<^sub>\<mu> \<phi> \<and> w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)}"
   by (induction \<phi>) force+
 
 lemma \<F>_semantics:
   "\<F> \<phi> w = {\<psi>. \<psi> \<in> subformulas\<^sub>\<mu> \<phi> \<and> w \<Turnstile>\<^sub>n F\<^sub>n \<psi>}"
   by (induction \<phi>) force+
 
 lemma \<G>\<F>_semantics':
   "\<G>\<F> \<phi> w = subformulas\<^sub>\<mu> \<phi> \<inter> {\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)}"
   unfolding \<G>\<F>_semantics by auto
 
 lemma \<F>_semantics':
   "\<F> \<phi> w = subformulas\<^sub>\<mu> \<phi> \<inter> {\<psi>. w \<Turnstile>\<^sub>n F\<^sub>n \<psi>}"
   unfolding \<F>_semantics by auto
 
 lemma \<G>\<F>_\<F>_subset:
   "\<G>\<F> \<phi> w \<subseteq> \<F> \<phi> w"
   unfolding \<G>\<F>_semantics \<F>_semantics by force
 
 
 lemma \<G>\<F>_finite:
   "finite (\<G>\<F> \<phi> w)"
   by (induction \<phi>) auto
 
 lemma \<G>\<F>_subformulas\<^sub>\<mu>:
   "\<G>\<F> \<phi> w \<subseteq> subformulas\<^sub>\<mu> \<phi>"
   unfolding \<G>\<F>_semantics by force
 
 lemma \<G>\<F>_subfrmlsn:
   "\<G>\<F> \<phi> w \<subseteq> subfrmlsn \<phi>"
   using \<G>\<F>_subformulas\<^sub>\<mu> subformulas\<^sub>\<mu>_subfrmlsn by blast
 
 lemma \<G>\<F>_elim:
   "\<psi> \<in> \<G>\<F> \<phi> w \<Longrightarrow> w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)"
   unfolding \<G>\<F>_semantics by simp
 
 lemma \<G>\<F>_suffix(* [simp] *):
   "\<G>\<F> \<phi> (suffix i w) = \<G>\<F> \<phi> w"
 proof
   show "\<G>\<F> \<phi> w \<subseteq> \<G>\<F> \<phi> (suffix i w)"
     unfolding \<G>\<F>_semantics by auto
 next
   show "\<G>\<F> \<phi> (suffix i w) \<subseteq> \<G>\<F> \<phi> w"
     unfolding \<G>\<F>_semantics GF_Inf_many
   proof auto
     fix \<psi>
     assume "\<exists>\<^sub>\<infinity>j. suffix (i + j) w \<Turnstile>\<^sub>n \<psi>"
     then have "\<exists>\<^sub>\<infinity>j. suffix (j + i) w \<Turnstile>\<^sub>n \<psi>"
       by (simp add: algebra_simps)
     then show "\<exists>\<^sub>\<infinity>j. suffix j w \<Turnstile>\<^sub>n \<psi>"
       using INFM_nat_add by blast
   qed
 qed
 
 lemma \<G>\<F>_subset:
   "\<psi> \<in> subfrmlsn \<phi> \<Longrightarrow> \<G>\<F> \<psi> w \<subseteq> \<G>\<F> \<phi> w"
   unfolding \<G>\<F>_semantics using subformulas\<^sub>\<mu>_subset by blast
 
 
 lemma \<F>_finite:
   "finite (\<F> \<phi> w)"
   by (induction \<phi>) auto
 
 lemma \<F>_subformulas\<^sub>\<mu>:
   "\<F> \<phi> w \<subseteq> subformulas\<^sub>\<mu> \<phi>"
   unfolding \<F>_semantics by force
 
 lemma \<F>_subfrmlsn:
   "\<F> \<phi> w \<subseteq> subfrmlsn \<phi>"
   using \<F>_subformulas\<^sub>\<mu> subformulas\<^sub>\<mu>_subfrmlsn by blast
 
 lemma \<F>_elim:
   "\<psi> \<in> \<F> \<phi> w \<Longrightarrow> w \<Turnstile>\<^sub>n F\<^sub>n \<psi>"
   unfolding \<F>_semantics by simp
 
 lemma \<F>_suffix:
   "\<F> \<phi> (suffix i w) \<subseteq> \<F> \<phi> w"
   unfolding \<F>_semantics by auto
 
 lemma \<F>_subset:
   "\<psi> \<in> subfrmlsn \<phi> \<Longrightarrow> \<F> \<psi> w \<subseteq> \<F> \<phi> w"
   unfolding \<F>_semantics using subformulas\<^sub>\<mu>_subset by blast
 
 
 definition "\<mu>_stable \<phi> w \<longleftrightarrow> \<G>\<F> \<phi> w = \<F> \<phi> w"
 
 lemma suffix_\<mu>_stable:
   "\<forall>\<^sub>\<infinity>i. \<mu>_stable \<phi> (suffix i w)"
 proof -
   have "\<forall>\<psi> \<in> subformulas\<^sub>\<mu> \<phi>. \<forall>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>) \<longleftrightarrow> suffix i w \<Turnstile>\<^sub>n F\<^sub>n \<psi>"
     using Alm_all_GF_F by blast
 
   then have "\<forall>\<^sub>\<infinity>i. \<forall>\<psi> \<in> subformulas\<^sub>\<mu> \<phi>. suffix i w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>) \<longleftrightarrow> suffix i w \<Turnstile>\<^sub>n F\<^sub>n \<psi>"
     using subformulas\<^sub>\<mu>_finite eventually_ball_finite by fast
 
   then have "\<forall>\<^sub>\<infinity>i. {\<psi> \<in> subformulas\<^sub>\<mu> \<phi>. suffix i w \<Turnstile>\<^sub>n G\<^sub>n (F\<^sub>n \<psi>)} = {\<psi> \<in> subformulas\<^sub>\<mu> \<phi>. suffix i w \<Turnstile>\<^sub>n F\<^sub>n \<psi>}"
     by (rule MOST_mono) (blast intro: Collect_cong)
 
   then show ?thesis
     unfolding \<mu>_stable_def \<G>\<F>_semantics \<F>_semantics
     by (rule MOST_mono) simp
 qed
 
+lemma \<mu>_stable_subfrmlsn:
+  "\<mu>_stable \<phi> w \<Longrightarrow> \<psi> \<in> subfrmlsn \<phi> \<Longrightarrow> \<mu>_stable \<psi> w"
+proof -
+  assume a1: "\<psi> \<in> subfrmlsn \<phi>" and a2: "\<mu>_stable \<phi> w"
+  have "subformulas\<^sub>\<mu> \<psi> \<subseteq> subformulas\<^sub>\<mu> \<phi>"
+    using a1 by (simp add: subformulas\<^sub>\<mu>_subset)
+  moreover
+  have "\<G>\<F> \<phi> w = \<F> \<phi> w"
+    using a2 by (meson \<mu>_stable_def)
+  ultimately show ?thesis
+    by (metis (no_types) Un_commute \<F>_semantics' \<G>\<F>_semantics' \<mu>_stable_def inf_left_commute inf_sup_absorb sup.orderE)
+qed
+
+lemma \<mu>_stable_suffix:
+  "\<mu>_stable \<phi> w \<Longrightarrow> \<mu>_stable \<phi> (suffix i w)"
+  by (metis \<F>_suffix \<G>\<F>_\<F>_subset \<G>\<F>_suffix \<mu>_stable_def subset_antisym)
+
 
 definition "FG_singleton w \<phi> \<equiv> if w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<phi>) then {\<phi>} else {}"
 definition "G_singleton w \<phi> \<equiv> if w \<Turnstile>\<^sub>n G\<^sub>n \<phi> then {\<phi>} else {}"
 
 declare FG_singleton_def [simp] G_singleton_def [simp]
 
 fun \<F>\<G> :: "'a ltln \<Rightarrow> 'a set word \<Rightarrow> 'a ltln set"
 where
   "\<F>\<G> (\<phi> and\<^sub>n \<psi>) w = \<F>\<G> \<phi> w \<union> \<F>\<G> \<psi> w"
 | "\<F>\<G> (\<phi> or\<^sub>n \<psi>) w = \<F>\<G> \<phi> w \<union> \<F>\<G> \<psi> w"
 | "\<F>\<G> (X\<^sub>n \<phi>) w = \<F>\<G> \<phi> w"
 | "\<F>\<G> (\<phi> U\<^sub>n \<psi>) w = \<F>\<G> \<phi> w \<union> \<F>\<G> \<psi> w"
 | "\<F>\<G> (\<phi> R\<^sub>n \<psi>) w = FG_singleton w (\<phi> R\<^sub>n \<psi>) \<union> \<F>\<G> \<phi> w \<union> \<F>\<G> \<psi> w"
 | "\<F>\<G> (\<phi> W\<^sub>n \<psi>) w = FG_singleton w (\<phi> W\<^sub>n \<psi>) \<union> \<F>\<G> \<phi> w \<union> \<F>\<G> \<psi> w"
 | "\<F>\<G> (\<phi> M\<^sub>n \<psi>) w = \<F>\<G> \<phi> w \<union> \<F>\<G> \<psi> w"
 | "\<F>\<G> _ _ = {}"
 
 fun \<G> :: "'a ltln \<Rightarrow> 'a set word \<Rightarrow> 'a ltln set"
 where
   "\<G> (\<phi> and\<^sub>n \<psi>) w = \<G> \<phi> w \<union> \<G> \<psi> w"
 | "\<G> (\<phi> or\<^sub>n \<psi>) w = \<G> \<phi> w \<union> \<G> \<psi> w"
 | "\<G> (X\<^sub>n \<phi>) w = \<G> \<phi> w"
 | "\<G> (\<phi> U\<^sub>n \<psi>) w = \<G> \<phi> w \<union> \<G> \<psi> w"
 | "\<G> (\<phi> R\<^sub>n \<psi>) w = G_singleton w (\<phi> R\<^sub>n \<psi>) \<union> \<G> \<phi> w \<union> \<G> \<psi> w"
 | "\<G> (\<phi> W\<^sub>n \<psi>) w = G_singleton w (\<phi> W\<^sub>n \<psi>) \<union> \<G> \<phi> w \<union> \<G> \<psi> w"
 | "\<G> (\<phi> M\<^sub>n \<psi>) w = \<G> \<phi> w \<union> \<G> \<psi> w"
 | "\<G> _ _ = {}"
 
 
 lemma \<F>\<G>_semantics:
   "\<F>\<G> \<phi> w = {\<psi> \<in> subformulas\<^sub>\<nu> \<phi>. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>)}"
   by (induction \<phi>) force+
 
 lemma \<G>_semantics:
   "\<G> \<phi> w \<equiv> {\<psi> \<in> subformulas\<^sub>\<nu> \<phi>. w \<Turnstile>\<^sub>n G\<^sub>n \<psi>}"
   by (induction \<phi>) force+
 
 lemma \<F>\<G>_semantics':
   "\<F>\<G> \<phi> w = subformulas\<^sub>\<nu> \<phi> \<inter> {\<psi>. w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>)}"
   unfolding \<F>\<G>_semantics by auto
 
 lemma \<G>_semantics':
   "\<G> \<phi> w = subformulas\<^sub>\<nu> \<phi> \<inter> {\<psi>. w \<Turnstile>\<^sub>n G\<^sub>n \<psi>}"
   unfolding \<G>_semantics by auto
 
 lemma \<G>_\<F>\<G>_subset:
   "\<G> \<phi> w \<subseteq> \<F>\<G> \<phi> w"
   unfolding \<G>_semantics \<F>\<G>_semantics by force
 
 lemma \<F>\<G>_finite:
   "finite (\<F>\<G> \<phi> w)"
   by (induction \<phi>) auto
 
 lemma \<F>\<G>_subformulas\<^sub>\<nu>:
   "\<F>\<G> \<phi> w \<subseteq> subformulas\<^sub>\<nu> \<phi>"
   unfolding \<F>\<G>_semantics by force
 
 lemma \<F>\<G>_subfrmlsn:
   "\<F>\<G> \<phi> w \<subseteq> subfrmlsn \<phi>"
   using \<F>\<G>_subformulas\<^sub>\<nu> subformulas\<^sub>\<nu>_subfrmlsn by blast
 
 lemma \<F>\<G>_elim:
   "\<psi> \<in> \<F>\<G> \<phi> w \<Longrightarrow> w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>)"
   unfolding \<F>\<G>_semantics by simp
 
 lemma \<F>\<G>_suffix:
   "\<F>\<G> \<phi> (suffix i w) = \<F>\<G> \<phi> w"
 proof
   show "\<F>\<G> \<phi> (suffix i w) \<subseteq> \<F>\<G> \<phi> w"
     unfolding \<F>\<G>_semantics by auto
 next
   show "\<F>\<G> \<phi> w \<subseteq> \<F>\<G> \<phi> (suffix i w)"
     unfolding \<F>\<G>_semantics FG_Alm_all
   proof auto
     fix \<psi>
     assume "\<forall>\<^sub>\<infinity>j. suffix j w \<Turnstile>\<^sub>n \<psi>"
     then have "\<forall>\<^sub>\<infinity>j. suffix (j + i) w \<Turnstile>\<^sub>n \<psi>"
       using MOST_nat_add by meson
     then show "\<forall>\<^sub>\<infinity>j. suffix (i + j) w \<Turnstile>\<^sub>n \<psi>"
       by (simp add: algebra_simps)
   qed
 qed
 
 lemma \<F>\<G>_subset:
   "\<psi> \<in> subfrmlsn \<phi> \<Longrightarrow> \<F>\<G> \<psi> w \<subseteq> \<F>\<G> \<phi> w"
   unfolding \<F>\<G>_semantics using subformulas\<^sub>\<nu>_subset by blast
 
 
 lemma \<G>_finite:
   "finite (\<G> \<phi> w)"
   by (induction \<phi>) auto
 
 lemma \<G>_subformulas\<^sub>\<nu>:
   "\<G> \<phi> w \<subseteq> subformulas\<^sub>\<nu> \<phi>"
   unfolding \<G>_semantics by force
 
 lemma \<G>_subfrmlsn:
   "\<G> \<phi> w \<subseteq> subfrmlsn \<phi>"
   using \<G>_subformulas\<^sub>\<nu> subformulas\<^sub>\<nu>_subfrmlsn by blast
 
 lemma \<G>_elim:
   "\<psi> \<in> \<G> \<phi> w \<Longrightarrow> w \<Turnstile>\<^sub>n G\<^sub>n \<psi>"
   unfolding \<G>_semantics by simp
 
 lemma \<G>_suffix:
   "\<G> \<phi> w \<subseteq> \<G> \<phi> (suffix i w)"
   unfolding \<G>_semantics by auto
 
 lemma \<G>_subset:
   "\<psi> \<in> subfrmlsn \<phi> \<Longrightarrow> \<G> \<psi> w \<subseteq> \<G> \<phi> w"
   unfolding \<G>_semantics using subformulas\<^sub>\<nu>_subset by blast
 
 
 definition "\<nu>_stable \<phi> w \<longleftrightarrow> \<F>\<G> \<phi> w = \<G> \<phi> w"
 
 lemma suffix_\<nu>_stable:
   "\<forall>\<^sub>\<infinity>j. \<nu>_stable \<phi> (suffix j w)"
 proof -
   have "\<forall>\<psi> \<in> subformulas\<^sub>\<nu> \<phi>. \<forall>\<^sub>\<infinity>i. suffix i w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>) \<longleftrightarrow> suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<psi>"
     using Alm_all_FG_G by blast
 
   then have "\<forall>\<^sub>\<infinity>i. \<forall>\<psi> \<in> subformulas\<^sub>\<nu> \<phi>. suffix i w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>) \<longleftrightarrow> suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<psi>"
     using subformulas\<^sub>\<nu>_finite eventually_ball_finite by fast
 
   then have "\<forall>\<^sub>\<infinity>i. {\<psi> \<in> subformulas\<^sub>\<nu> \<phi>. suffix i w \<Turnstile>\<^sub>n F\<^sub>n (G\<^sub>n \<psi>)} = {\<psi> \<in> subformulas\<^sub>\<nu> \<phi>. suffix i w \<Turnstile>\<^sub>n G\<^sub>n \<psi>}"
     by (rule MOST_mono) (blast intro: Collect_cong)
 
   then show ?thesis
     unfolding \<nu>_stable_def \<F>\<G>_semantics \<G>_semantics
     by (rule MOST_mono) simp
 qed
 
+lemma \<nu>_stable_subfrmlsn:
+  "\<nu>_stable \<phi> w \<Longrightarrow> \<psi> \<in> subfrmlsn \<phi> \<Longrightarrow> \<nu>_stable \<psi> w"
+proof -
+  assume a1: "\<psi> \<in> subfrmlsn \<phi>" and a2: "\<nu>_stable \<phi> w"
+  have "subformulas\<^sub>\<nu> \<psi> \<subseteq> subformulas\<^sub>\<nu> \<phi>"
+    using a1 by (simp add: subformulas\<^sub>\<nu>_subset)
+  moreover
+  have "\<F>\<G> \<phi> w = \<G> \<phi> w"
+    using a2 by (meson \<nu>_stable_def)
+  ultimately show ?thesis
+    by (metis (no_types) Un_commute \<G>_semantics' \<F>\<G>_semantics' \<nu>_stable_def inf_left_commute inf_sup_absorb sup.orderE)
+qed
+
+lemma \<nu>_stable_suffix:
+  "\<nu>_stable \<phi> w \<Longrightarrow> \<nu>_stable \<phi> (suffix i w)"
+  by (metis \<F>\<G>_suffix \<G>_\<F>\<G>_subset \<G>_suffix \<nu>_stable_def antisym_conv)
+
+
+subsection \<open>Definitions with Lists for Code Export\<close>
+
+text \<open>The \<open>\<mu>\<close>- and \<open>\<nu>\<close>-subformulas as lists:\<close>
+
+fun subformulas\<^sub>\<mu>_list :: "'a ltln \<Rightarrow> 'a ltln list"
+where
+  "subformulas\<^sub>\<mu>_list (\<phi> and\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>)"
+| "subformulas\<^sub>\<mu>_list (\<phi> or\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>)"
+| "subformulas\<^sub>\<mu>_list (X\<^sub>n \<phi>) = subformulas\<^sub>\<mu>_list \<phi>"
+| "subformulas\<^sub>\<mu>_list (\<phi> U\<^sub>n \<psi>) = List.insert (\<phi> U\<^sub>n \<psi>) (List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>))"
+| "subformulas\<^sub>\<mu>_list (\<phi> R\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>)"
+| "subformulas\<^sub>\<mu>_list (\<phi> W\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>)"
+| "subformulas\<^sub>\<mu>_list (\<phi> M\<^sub>n \<psi>) = List.insert (\<phi> M\<^sub>n \<psi>) (List.union (subformulas\<^sub>\<mu>_list \<phi>) (subformulas\<^sub>\<mu>_list \<psi>))"
+| "subformulas\<^sub>\<mu>_list _ = []"
+
+fun subformulas\<^sub>\<nu>_list :: "'a ltln \<Rightarrow> 'a ltln list"
+where
+  "subformulas\<^sub>\<nu>_list (\<phi> and\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>)"
+| "subformulas\<^sub>\<nu>_list (\<phi> or\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>)"
+| "subformulas\<^sub>\<nu>_list (X\<^sub>n \<phi>) = subformulas\<^sub>\<nu>_list \<phi>"
+| "subformulas\<^sub>\<nu>_list (\<phi> U\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>)"
+| "subformulas\<^sub>\<nu>_list (\<phi> R\<^sub>n \<psi>) = List.insert (\<phi> R\<^sub>n \<psi>) (List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>))"
+| "subformulas\<^sub>\<nu>_list (\<phi> W\<^sub>n \<psi>) = List.insert (\<phi> W\<^sub>n \<psi>) (List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>))"
+| "subformulas\<^sub>\<nu>_list (\<phi> M\<^sub>n \<psi>) = List.union (subformulas\<^sub>\<nu>_list \<phi>) (subformulas\<^sub>\<nu>_list \<psi>)"
+| "subformulas\<^sub>\<nu>_list _ = []"
+
+lemma subformulas\<^sub>\<mu>_list_set:
+  "set (subformulas\<^sub>\<mu>_list \<phi>) = subformulas\<^sub>\<mu> \<phi>"
+  by (induction \<phi>) auto
+
+lemma subformulas\<^sub>\<nu>_list_set:
+  "set (subformulas\<^sub>\<nu>_list \<phi>) = subformulas\<^sub>\<nu> \<phi>"
+  by (induction \<phi>) auto
+
+lemma subformulas\<^sub>\<mu>_list_distinct:
+  "distinct (subformulas\<^sub>\<mu>_list \<phi>)"
+  by (induction \<phi>) auto
+
+lemma subformulas\<^sub>\<nu>_list_distinct:
+  "distinct (subformulas\<^sub>\<nu>_list \<phi>)"
+  by (induction \<phi>) auto
+
+lemma subformulas\<^sub>\<mu>_list_length:
+  "length (subformulas\<^sub>\<mu>_list \<phi>) = card (subformulas\<^sub>\<mu> \<phi>)"
+  by (metis subformulas\<^sub>\<mu>_list_set subformulas\<^sub>\<mu>_list_distinct distinct_card)
+
+lemma subformulas\<^sub>\<nu>_list_length:
+  "length (subformulas\<^sub>\<nu>_list \<phi>) = card (subformulas\<^sub>\<nu> \<phi>)"
+  by (metis subformulas\<^sub>\<nu>_list_set subformulas\<^sub>\<nu>_list_distinct distinct_card)
+
+
+text \<open>
+  We define the list of advice sets as the product of all subsequences
+  of the \<open>\<mu>\<close>- and \<open>\<nu>\<close>-subformulas of a formula.
+\<close>
+
+definition advice_sets :: "'a ltln \<Rightarrow> ('a ltln list \<times> 'a ltln list) list"
+where
+  "advice_sets \<phi> = List.product (subseqs (subformulas\<^sub>\<mu>_list \<phi>)) (subseqs (subformulas\<^sub>\<nu>_list \<phi>))"
+
+lemma subset_subseq:
+  "X \<subseteq> set ys \<longleftrightarrow> (\<exists>xs. X = set xs \<and> subseq xs ys)"
+  by (metis (no_types, lifting) Pow_iff image_iff in_set_subseqs subseqs_powset)
+
+lemma subseqs_subformulas\<^sub>\<mu>_list:
+  "X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<longleftrightarrow> (\<exists>xs. X = set xs \<and> xs \<in> set (subseqs (subformulas\<^sub>\<mu>_list \<phi>)))"
+  by (metis subset_subseq subformulas\<^sub>\<mu>_list_set in_set_subseqs)
+
+lemma subseqs_subformulas\<^sub>\<nu>_list:
+  "Y \<subseteq> subformulas\<^sub>\<nu> \<phi> \<longleftrightarrow> (\<exists>ys. Y = set ys \<and> ys \<in> set (subseqs (subformulas\<^sub>\<nu>_list \<phi>)))"
+  by (metis subset_subseq subformulas\<^sub>\<nu>_list_set in_set_subseqs)
+
+lemma advice_sets_subformulas:
+  "X \<subseteq> subformulas\<^sub>\<mu> \<phi> \<and> Y \<subseteq> subformulas\<^sub>\<nu> \<phi> \<longleftrightarrow> (\<exists>xs ys. X = set xs \<and> Y = set ys \<and> (xs, ys) \<in> set (advice_sets \<phi>))"
+  unfolding advice_sets_def set_product subseqs_subformulas\<^sub>\<mu>_list subseqs_subformulas\<^sub>\<nu>_list by blast
+
+(* TODO add to HOL/List.thy *)
+lemma subseqs_not_empty:
+  "subseqs xs \<noteq> []"
+  by (metis empty_iff list.set(1) subseqs_refl)
+
+(* TODO add to HOL/List.thy *)
+lemma product_not_empty:
+  "xs \<noteq> [] \<Longrightarrow> ys \<noteq> [] \<Longrightarrow> List.product xs ys \<noteq> []"
+  by (induction xs) simp_all
+
+lemma advice_sets_not_empty:
+  "advice_sets \<phi> \<noteq> []"
+  unfolding advice_sets_def using subseqs_not_empty product_not_empty by blast
+
+lemma advice_sets_length:
+  "length (advice_sets \<phi>) \<le> 2 ^ card (subfrmlsn \<phi>)"
+  unfolding advice_sets_def length_product length_subseqs subformulas\<^sub>\<mu>_list_length subformulas\<^sub>\<nu>_list_length power_add[symmetric]
+  by (metis Suc_1 card_mono lessI power_increasing_iff subformulas\<^sub>\<mu>\<^sub>\<nu>_card subformulas\<^sub>\<mu>\<^sub>\<nu>_subfrmlsn subfrmlsn_finite)
+
+lemma advice_sets_element_length:
+  "(xs, ys) \<in> set (advice_sets \<phi>) \<Longrightarrow> length xs \<le> card (subfrmlsn \<phi>)"
+  "(xs, ys) \<in> set (advice_sets \<phi>) \<Longrightarrow> length ys \<le> card (subfrmlsn \<phi>)"
+  unfolding advice_sets_def set_product
+  by (metis SigmaD1 card_mono in_set_subseqs list_emb_length order_trans subformulas\<^sub>\<mu>_list_length subformulas\<^sub>\<mu>_subfrmlsn subfrmlsn_finite)
+     (metis SigmaD2 card_mono in_set_subseqs list_emb_length order_trans subformulas\<^sub>\<nu>_list_length subformulas\<^sub>\<nu>_subfrmlsn subfrmlsn_finite)
+
+lemma advice_sets_element_subfrmlsn:
+  "(xs, ys) \<in> set (advice_sets \<phi>) \<Longrightarrow> set xs \<subseteq> subformulas\<^sub>\<mu> \<phi>"
+  "(xs, ys) \<in> set (advice_sets \<phi>) \<Longrightarrow> set ys \<subseteq> subformulas\<^sub>\<nu> \<phi>"
+  unfolding advice_sets_def set_product
+  by (meson SigmaD1 subseqs_subformulas\<^sub>\<mu>_list)
+     (meson SigmaD2 subseqs_subformulas\<^sub>\<nu>_list)
+
 end
diff --git a/thys/LTL_Master_Theorem/ROOT b/thys/LTL_Master_Theorem/ROOT
--- a/thys/LTL_Master_Theorem/ROOT
+++ b/thys/LTL_Master_Theorem/ROOT
@@ -1,24 +1,25 @@
 chapter AFP
 
 session LTL_Master_Theorem (AFP) = "Transition_Systems_and_Automata" +
   options [timeout = 600]
   sessions
     LTL
     Deriving
   directories
     "Logical_Characterization"
     "LTL_to_DRA"
   theories
     "Logical_Characterization/Master_Theorem"
     "Logical_Characterization/Asymmetric_Master_Theorem"
+    "Logical_Characterization/Restricted_Master_Theorem"
 
     "LTL_to_DRA/DRA_Construction"
     "LTL_to_DRA/DRA_Instantiation"
     "LTL_to_DRA/DRA_Implementation"
 
     Code_Export
   document_files
     "root.tex"
     "root.bib"
   export_files (in ".") [1]
     "LTL_Master_Theorem.Code_Export:**"