diff --git a/thys/Efficient-Mergesort/Natural_Mergesort.thy b/thys/Efficient-Mergesort/Natural_Mergesort.thy
--- a/thys/Efficient-Mergesort/Natural_Mergesort.thy
+++ b/thys/Efficient-Mergesort/Natural_Mergesort.thy
@@ -1,163 +1,163 @@
 (* Author: Christian Sternagel *)
 
 theory Natural_Mergesort
   imports "HOL-Data_Structures.Sorting"
 begin
 
 subsection \<open>Auxiliary Results\<close>
 
 lemma C_merge_adj':
   "C_merge_adj xss \<le> length (concat xss)"
 proof (induct xss rule: C_merge_adj.induct)
   case (3 xs ys zss)
   then show ?case using C_merge_ub [of xs ys] by simp
 qed simp_all
 
 lemma length_concat_merge_adj:
   "length (concat (merge_adj xss)) = length (concat xss)"
   by (induct xss rule: merge_adj.induct) (simp_all add: length_merge)
 
 lemma C_merge_all':
   "C_merge_all xss \<le> length (concat xss) * \<lceil>log 2 (length xss)\<rceil>"
 proof (induction xss rule: C_merge_all.induct)
   case (3 xs ys zss)
   let ?xss = "xs # ys # zss"
   let ?m = "length (concat ?xss)"
 
   have *: "\<lceil>log 2 (real n + 2)\<rceil> = \<lceil>log 2 (Suc n div 2 + 1)\<rceil> + 1" for n :: nat
     using ceiling_log2_div2 [of "n + 2"] by (simp add: algebra_simps)
 
   have "C_merge_all ?xss = C_merge_adj ?xss + C_merge_all (merge_adj ?xss)" by simp
   also have "\<dots> \<le> ?m + C_merge_all (merge_adj ?xss)"
     using C_merge_adj' [of ?xss] by auto
   also have "\<dots> \<le> ?m + length (concat (merge_adj ?xss)) * \<lceil>log 2 (length (merge_adj ?xss))\<rceil>"
     using "3.IH" by simp
   also have "\<dots> = ?m + ?m * \<lceil>log 2 (length (merge_adj ?xss))\<rceil>"
     by (simp only: length_concat_merge_adj)
   also have "\<dots> \<le> ?m * \<lceil>log 2 (length ?xss)\<rceil>"
     by (auto simp: * algebra_simps)
   finally show ?case by simp
 qed simp_all
 
 
 subsection \<open>Definition of Natural Mergesort\<close>
 
 text \<open>
   Partition input into ascending and descending subsequences.
   (The latter are reverted on the fly.)
 \<close>
 fun runs :: "('a::linorder) list \<Rightarrow> 'a list list" and
     asc :: "'a \<Rightarrow> ('a list \<Rightarrow> 'a list) \<Rightarrow> 'a list \<Rightarrow> 'a list list" and
     desc :: "'a \<Rightarrow> 'a list \<Rightarrow> 'a list \<Rightarrow> 'a list list"
   where
     "runs (a # b # xs) = (if a > b then desc b [a] xs else asc b ((#) a) xs)"
   | "runs [x] = [[x]]"
   | "runs [] = []"
   | "asc a as (b # bs) = (if \<not> a > b then asc b (as \<circ> (#) a) bs else as [a] # runs (b # bs))"
   | "asc a as [] = [as [a]]"
   | "desc a as (b # bs) = (if a > b then desc b (a # as) bs else (a # as) # runs (b # bs))"
   | "desc a as [] = [a # as]"
 
 definition nmsort :: "('a::linorder) list \<Rightarrow> 'a list"
   where
     "nmsort xs = merge_all (runs xs)"
 
 
 subsection \<open>Functional Correctness\<close>
 
 definition "ascP f = (\<forall>xs ys. f (xs @ ys) = f xs @ ys)"
 
 lemma ascP_Cons [simp]: "ascP ((#) x)" by (simp add: ascP_def)
 
 lemma ascP_comp_Cons [simp]: "ascP f \<Longrightarrow> ascP (f \<circ> (#) x)"
   by (auto simp: ascP_def simp flip: append_Cons)
 
 lemma ascP_simp [simp]:
   assumes "ascP f"
   shows "f [x] = f [] @ [x]"
   using assms [unfolded ascP_def, THEN spec, THEN spec, of "[]" "[x]"] by simp
 
 lemma
-  shows mset_runs: "\<Union># (image_mset mset (mset (runs xs))) = mset xs"
-    and mset_asc: "ascP f \<Longrightarrow> \<Union># (image_mset mset (mset (asc x f ys))) = {#x#} + mset (f []) + mset ys"
-    and mset_desc: "\<Union># (image_mset mset (mset (desc x xs ys))) = {#x#} + mset xs + mset ys"
+  shows mset_runs: "\<Sum>\<^sub># (image_mset mset (mset (runs xs))) = mset xs"
+    and mset_asc: "ascP f \<Longrightarrow> \<Sum>\<^sub># (image_mset mset (mset (asc x f ys))) = {#x#} + mset (f []) + mset ys"
+    and mset_desc: "\<Sum>\<^sub># (image_mset mset (mset (desc x xs ys))) = {#x#} + mset xs + mset ys"
   by (induct xs and x f ys and x xs ys rule: runs_asc_desc.induct) auto
 
 lemma mset_nmsort:
   "mset (nmsort xs) = mset xs"
   by (auto simp: mset_merge_all nmsort_def mset_runs)
 
 lemma
   shows sorted_runs: "\<forall>x\<in>set (runs xs). sorted x"
     and sorted_asc: "ascP f \<Longrightarrow> sorted (f []) \<Longrightarrow> \<forall>x\<in>set (f []). x \<le> a \<Longrightarrow> \<forall>x\<in>set (asc a f ys). sorted x"
     and sorted_desc: "sorted xs \<Longrightarrow> \<forall>x\<in>set xs. a \<le> x \<Longrightarrow> \<forall>x\<in>set (desc a xs ys). sorted x"
   by (induct xs and a f ys and a xs ys rule: runs_asc_desc.induct)
     (auto simp: sorted_append not_less dest: order_trans, fastforce)
 
 lemma sorted_nmsort:
   "sorted (nmsort xs)"
   by (auto intro: sorted_merge_all simp: nmsort_def sorted_runs)
 
 
 subsection \<open>Running Time Analysis\<close>
 
 fun C_runs :: "('a::linorder) list \<Rightarrow> nat" and
     C_asc :: "('a::linorder) \<Rightarrow> 'a list \<Rightarrow> nat" and
     C_desc :: "('a::linorder) \<Rightarrow> 'a list \<Rightarrow> nat"
   where
     "C_runs (a # b # xs) = 1 + (if a > b then C_desc b xs else C_asc b xs)"
   | "C_runs xs = 0"
   | "C_asc a (b # bs) = 1 + (if \<not> a > b then C_asc b bs else C_runs (b # bs))"
   | "C_asc a [] = 0"
   | "C_desc a (b # bs) = 1 + (if a > b then C_desc b bs else C_runs (b # bs))"
   | "C_desc a [] = 0"
 
 fun C_nmsort :: "('a::linorder) list \<Rightarrow> nat"
   where
     "C_nmsort xs = C_runs xs + C_merge_all (runs xs)"
 
 lemma
   fixes a :: "'a::linorder" and xs ys :: "'a list"
   shows C_runs: "C_runs xs \<le> length xs - 1"
     and C_asc: "C_asc a ys \<le> length ys"
     and C_desc: "C_desc a ys \<le> length ys"
   by (induct xs and a ys and a ys rule: C_runs_C_asc_C_desc.induct) auto
 
 lemma
   shows length_runs: "length (runs xs) \<le> length xs"
     and length_asc: "ascP f \<Longrightarrow> length (asc a f ys) \<le> 1 + length ys"
     and length_desc: "length (desc a xs ys) \<le> 1 + length ys"
   by (induct xs and a f ys and a xs ys rule: runs_asc_desc.induct) auto
 
 lemma
   shows length_concat_runs [simp]: "length (concat (runs xs)) = length xs"
     and length_concat_asc: "ascP f \<Longrightarrow> length (concat (asc a f ys)) = 1 + length (f []) + length ys"
     and length_concat_desc: "length (concat (desc a xs ys)) = 1 + length xs + length ys"
   by (induct xs and a f ys and a xs ys rule: runs_asc_desc.induct) auto
 
 lemma log2_mono:
   "x > 0 \<Longrightarrow> x \<le> y \<Longrightarrow> log 2 x \<le> log 2 y"
   by auto
 
 lemma
   shows runs_ne: "xs \<noteq> [] \<Longrightarrow> runs xs \<noteq> []"
     and "ascP f \<Longrightarrow> asc a f ys \<noteq> []"
     and "desc a xs ys \<noteq> []"
   by (induct xs and a f ys and a xs ys rule: runs_asc_desc.induct) simp_all
 
 lemma C_nmsort:
   assumes [simp]: "length xs = n"
   shows "C_nmsort xs \<le> n + n * \<lceil>log 2 n\<rceil>"
 proof -
   have [simp]: "xs = [] \<longleftrightarrow> length xs = 0" by blast
   have "int (C_merge_all (runs xs)) \<le> int n * \<lceil>log 2 (length (runs xs))\<rceil>"
     using C_merge_all' [of "runs xs"] by simp
   also have "\<dots> \<le> int n * \<lceil>log 2 n\<rceil>"
     using length_runs [of xs]
     by (cases n) (auto intro!: runs_ne mult_mono ceiling_mono log2_mono)
   finally have "int (C_merge_all (runs xs)) \<le> int n * \<lceil>log 2 n\<rceil>" .
   moreover have "C_runs xs \<le> n" using C_runs [of xs] by auto
   ultimately show ?thesis by (auto intro: add_mono)
 qed
 
 end
diff --git a/thys/Knuth_Bendix_Order/KBO.thy b/thys/Knuth_Bendix_Order/KBO.thy
--- a/thys/Knuth_Bendix_Order/KBO.thy
+++ b/thys/Knuth_Bendix_Order/KBO.thy
@@ -1,1227 +1,1227 @@
 section \<open>KBO\<close>
 
 text \<open>
   Below, we formalize a variant of KBO that includes subterm coefficient functions.
 
   A more standard definition is obtained by setting all subterm coefficients to 1.
   For this special case it would be possible to define more efficient code-equations that
   do not have to evaluate subterm coefficients at all.
 \<close>
 
 theory KBO
   imports
     Lexicographic_Extension
     Term_Aux
     Polynomial_Factorization.Missing_List
 begin
 
 subsection \<open>Subterm Coefficient Functions\<close>
 
 text \<open>
   Given a function @{term scf}, associating positions with subterm coefficients, and
   a list @{term xs}, the function @{term scf_list} yields an expanded list where  each
   element of @{term xs} is replicated a number of times according to its subterm coefficient.
 \<close>
 definition scf_list :: "(nat \<Rightarrow> nat) \<Rightarrow> 'a list \<Rightarrow> 'a list"
   where
     "scf_list scf xs = concat (map (\<lambda>(x, i). replicate (scf i) x) (zip xs [0 ..< length xs]))"
 
 lemma set_scf_list [simp]:
   assumes "\<forall>i < length xs. scf i > 0"
   shows "set (scf_list scf xs) = set xs"
   using assms by (auto simp: scf_list_def set_zip set_conv_nth[of xs])
 
 lemma scf_list_subset: "set (scf_list scf xs) \<subseteq> set xs"
   by (auto simp: scf_list_def set_zip)
 
 lemma scf_list_empty [simp]:
   "scf_list scf [] = []" by (auto simp: scf_list_def)
 
 lemma scf_list_bef_i_aft [simp]:
   "scf_list scf (bef @ i # aft) =
     scf_list scf bef @ replicate (scf (length bef)) i @
     scf_list (\<lambda> i. scf (Suc (length bef + i))) aft"
   unfolding scf_list_def
 proof (induct aft rule: List.rev_induct)
   case (snoc a aft)
   define bia where "bia = bef @ i # aft"
   have bia: "bef @ i # aft @ [a] = bia @ [a]" by (simp add: bia_def)
   have zip: "zip (bia @ [a]) [0..<length (bia @ [a])]
    = zip bia [0..<length bia] @ [(a, length bia)]" by simp
   have concat:
     "concat (map (\<lambda>(x, i). replicate (scf i) x) (zip bia [0..<length bia] @ [(a, length bia)])) =
       concat (map (\<lambda>(x, i). replicate (scf i) x) (zip bia [0..<length bia])) @
       replicate (scf (length bia)) a" by simp
   show ?case
     unfolding bia zip concat
     unfolding bia_def snoc
     by simp
 qed simp
 
 lemma scf_list_map [simp]:
   "scf_list scf (map f xs) = map f (scf_list scf xs)"
   by (induct xs rule: List.rev_induct) (auto simp: scf_list_def)
 
 text \<open>
   The function @{term scf_term} replicates each argument a number of times according to its
   subterm coefficient function.
 \<close>
 fun scf_term :: "('f \<times> nat \<Rightarrow> nat \<Rightarrow> nat) \<Rightarrow> ('f, 'v) term \<Rightarrow> ('f, 'v) term"
   where
     "scf_term scf (Var x) = (Var x)" |
     "scf_term scf (Fun f ts) = Fun f (scf_list (scf (f, length ts)) (map (scf_term scf) ts))"
 
 lemma vars_term_scf_subset:
   "vars_term (scf_term scf s) \<subseteq> vars_term s"
 proof (induct s)
   case (Fun f ss)
   have "vars_term (scf_term scf (Fun f ss)) =
     (\<Union>x\<in>set (scf_list (scf (f, length ss)) ss). vars_term (scf_term scf x))" by auto
   also have "\<dots> \<subseteq> (\<Union>x\<in>set ss. vars_term (scf_term scf x))"
     using scf_list_subset [of _ ss] by blast
   also have "\<dots> \<subseteq> (\<Union>x\<in>set ss. vars_term x)" using Fun by auto
   finally show ?case by auto
 qed auto
 
 lemma scf_term_subst:
   "scf_term scf (t \<cdot> \<sigma>) = scf_term scf t \<cdot> (\<lambda> x. scf_term scf (\<sigma> x))"
 proof (induct t)
   case (Fun f ts)
   { fix t
     assume "t \<in> set (scf_list (scf (f, length ts)) ts)"
     with scf_list_subset [of _ ts] have "t \<in> set ts" by auto
     then have "scf_term scf (t \<cdot> \<sigma>) = scf_term scf t \<cdot> (\<lambda>x. scf_term scf (\<sigma> x))"  by (rule Fun) }
   then show ?case by auto
 qed auto
 
 
 subsection \<open>Weight Functions\<close>
 
 locale weight_fun =
   fixes w :: "'f \<times> nat \<Rightarrow> nat"
     and w0 :: nat
     and scf :: "'f \<times> nat \<Rightarrow> nat \<Rightarrow> nat"
 begin
 
 text \<open>
   The \<^emph>\<open>weight\<close> of a term is computed recursively, where variables have weight @{term w0}
   and the weight of a compound term is computed by adding the weight of its root symbol
   @{term "w (f, n)"} to the weighted sum where weights of arguments are multiplied
   according to their subterm coefficients.
 \<close>
 fun weight :: "('f, 'v) term \<Rightarrow> nat"
   where
     "weight (Var x) = w0" |
     "weight (Fun f ts) =
     (let n = length ts; scff = scf (f, n) in
     w (f, n) + sum_list (map (\<lambda> (ti, i). weight ti * scff i) (zip ts [0 ..< n])))"
 
 text \<open>
   Alternatively, we can replicate arguments via @{const scf_list}.
   The advantage is that then both @{const weight} and @{const scf_term} are defined
   via @{const scf_list}.
 \<close>
 lemma weight_simp [simp]:
   "weight (Fun f ts) = w (f, length ts) + sum_list (map weight (scf_list (scf (f, length ts)) ts))"
 proof -
   define scff where "scff = (scf (f, length ts) :: nat \<Rightarrow> nat)"
   have "(\<Sum>(ti, i) \<leftarrow> zip ts [0..<length ts]. weight ti * scff i) =
    sum_list (map weight (scf_list scff ts))"
   proof (induct ts rule: List.rev_induct)
     case (snoc t ts)
     moreover
     { fix n
       have "sum_list (replicate n (weight t)) = n * weight t" by (induct n) auto }
     ultimately show ?case by (simp add: scf_list_def)
   qed simp
   then show ?thesis by (simp add: Let_def scff_def)
 qed
 
 declare weight.simps(2)[simp del]
 
 abbreviation "SCF \<equiv> scf_term scf"
 
 lemma sum_list_scf_list:
   assumes "\<And> i. i < length ts \<Longrightarrow> f i > 0"
   shows "sum_list (map weight ts) \<le> sum_list (map weight (scf_list f ts))"
   using assms unfolding scf_list_def
 proof (induct ts rule: List.rev_induct)
   case (snoc t ts)
   have "sum_list (map weight ts) \<le>
     sum_list (map weight (concat (map (\<lambda>(x, i). replicate (f i) x) (zip ts [0..<length ts]))))"
     by (auto intro!: snoc)
   moreover
   from snoc(2) [of "length ts"] obtain n where "f (length ts) = Suc n" by (auto elim: lessE)
   ultimately show ?case by simp
 qed simp
 
 end
 
 
 subsection \<open>Definition of KBO\<close>
 
 text \<open>
   The precedence is given by three parameters:
 
   \<^item> a predicate @{term pr_strict} for strict decrease between two function symbols,
   \<^item> a predicate @{term pr_weak} for weak decrease between two function symbols, and
   \<^item> a function indicating whether a symbol is least in the precedence.
 \<close>
 locale kbo = weight_fun w w0 scf
   for w w0 and scf :: "'f \<times> nat \<Rightarrow> nat \<Rightarrow> nat" +
   fixes least :: "'f \<Rightarrow> bool"
     and pr_strict :: "'f \<times> nat \<Rightarrow> 'f \<times> nat \<Rightarrow> bool"
     and pr_weak :: "'f \<times> nat \<Rightarrow> 'f \<times> nat \<Rightarrow> bool"
 begin
 
 text \<open>
   The result of @{term kbo} is a pair of Booleans encoding strict/weak decrease.
 
   Interestingly, the bound on the lengths of the lists in the lexicographic extension is not 
   required for KBO.
 \<close>
 fun kbo :: "('f, 'v) term \<Rightarrow> ('f, 'v) term \<Rightarrow> bool \<times> bool"
   where
     "kbo s t = (if (vars_term_ms (SCF t) \<subseteq># vars_term_ms (SCF s) \<and> weight t \<le> weight s)
       then if (weight t < weight s)
         then (True, True)
         else (case s of
           Var y \<Rightarrow> (False, (case t of Var x \<Rightarrow> x = y | Fun g ts \<Rightarrow> ts = [] \<and> least g))
         | Fun f ss \<Rightarrow> (case t of
             Var x \<Rightarrow> (True, True)
           | Fun g ts \<Rightarrow> if pr_strict (f, length ss) (g, length ts)
             then (True, True)
             else if pr_weak (f, length ss) (g, length ts)
             then lex_ext_unbounded kbo ss ts
             else (False, False)))
       else (False, False))"
 
 text \<open>Abbreviations for strict (S) and nonstrict (NS) KBO.\<close>
 abbreviation "S \<equiv> \<lambda> s t. fst (kbo s t)"
 abbreviation "NS \<equiv> \<lambda> s t. snd (kbo s t)"
 
 text \<open>
   For code-generation we do not compute the weights of @{term s} and @{term t} repeatedly.
 \<close>
 lemma kbo_code: "kbo s t = (let wt = weight t; ws = weight s in
     if (vars_term_ms (SCF t) \<subseteq># vars_term_ms (SCF s) \<and> wt \<le> ws)
     then if wt < ws
       then (True, True)
       else (case s of
         Var y \<Rightarrow> (False, (case t of Var x \<Rightarrow> True | Fun g ts \<Rightarrow> ts = [] \<and> least g))
       | Fun f ss \<Rightarrow> (case t of
           Var x \<Rightarrow> (True, True)
         | Fun g ts \<Rightarrow> let ff = (f, length ss); gg = (g, length ts) in
           if pr_strict ff gg
           then (True, True)
           else if pr_weak ff gg
             then lex_ext_unbounded kbo ss ts
             else (False, False)))
     else (False, False))"
   unfolding kbo.simps[of s t] Let_def
   by (auto simp del: kbo.simps split: term.splits)
 
 end
 
 declare kbo.kbo_code[code]
 declare weight_fun.weight.simps[code]
 
 lemma mset_replicate_mono:
   assumes "m1 \<subseteq># m2"
-  shows "\<Union># (mset (replicate n m1)) \<subseteq># \<Union># (mset (replicate n m2))"
+  shows "\<Sum>\<^sub># (mset (replicate n m1)) \<subseteq># \<Sum>\<^sub># (mset (replicate n m2))"
 proof (induct n)
   case (Suc n)
-  have "\<Union># (mset (replicate (Suc n) m1)) =
-    \<Union># (mset (replicate n m1)) + m1" by simp
-  also have "\<dots> \<subseteq># \<Union># (mset (replicate n m1)) + m2" using \<open>m1 \<subseteq># m2\<close> by auto
-  also have "\<dots> \<subseteq># \<Union># (mset (replicate n m2)) + m2" using Suc by auto
+  have "\<Sum>\<^sub># (mset (replicate (Suc n) m1)) =
+    \<Sum>\<^sub># (mset (replicate n m1)) + m1" by simp
+  also have "\<dots> \<subseteq># \<Sum>\<^sub># (mset (replicate n m1)) + m2" using \<open>m1 \<subseteq># m2\<close> by auto
+  also have "\<dots> \<subseteq># \<Sum>\<^sub># (mset (replicate n m2)) + m2" using Suc by auto
   finally show ?case by (simp add: union_commute)
 qed simp
 
 text \<open>
   While the locale @{locale kbo} only fixes its parameters, we now demand that these
   parameters are sensible, e.g., encoding a well-founded precedence, etc.
 \<close>
 locale admissible_kbo =
   kbo w w0 scf least pr_strict pr_weak
   for w w0 pr_strict pr_weak and least :: "'f \<Rightarrow> bool" and scf +
   assumes w0: "w (f, 0) \<ge> w0" "w0 > 0"
     and adm: "w (f, 1) = 0 \<Longrightarrow> pr_weak (f, 1) (g, n)"
     and least: "least f = (w (f, 0) = w0 \<and> (\<forall> g. w (g, 0) = w0 \<longrightarrow> pr_weak (g, 0) (f, 0)))"
     and scf: "i < n \<Longrightarrow> scf (f, n) i > 0"
     and pr_weak_refl [simp]: "pr_weak fn fn"
     and pr_weak_trans: "pr_weak fn gm \<Longrightarrow> pr_weak gm hk \<Longrightarrow> pr_weak fn hk"
     and pr_strict: "pr_strict fn gm \<longleftrightarrow> pr_weak fn gm \<and> \<not> pr_weak gm fn"
     and pr_SN: "SN {(fn, gm). pr_strict fn gm}"
 begin
 
 lemma weight_w0: "weight t \<ge> w0"
 proof (induct t)
   case (Fun f ts)
   show ?case
   proof (cases ts)
     case Nil
     with w0(1) have "w0 \<le> w (f, length ts)" by auto
     then show ?thesis by auto
   next
     case (Cons s ss)
     then obtain i where i: "i < length ts" by auto
     from scf[OF this] have scf: "0 < scf (f, length ts) i" by auto
     then obtain n where scf: "scf (f, length ts) i = Suc n" by (auto elim: lessE)
     from id_take_nth_drop[OF i] i obtain bef aft where ts: "ts = bef @ ts ! i # aft" and ii: "length bef = i" by auto
     define tsi where "tsi = ts ! i"
     note ts = ts[folded tsi_def]
     from i have tsi: "tsi \<in> set ts" unfolding tsi_def by auto
     from Fun[OF this] have w0: "w0 \<le> weight tsi" .
     show ?thesis using scf ii w0 unfolding ts
       by simp
   qed
 qed simp
 
 lemma weight_gt_0: "weight t > 0"
   using weight_w0 [of t] and w0 by arith
 
 lemma weight_0 [iff]: "weight t = 0 \<longleftrightarrow> False"
   using weight_gt_0 [of t] by auto
 
 lemma not_S_Var: "\<not> S (Var x) t"
   using weight_w0[of t] by (cases t, auto)
 
 lemma S_imp_NS: "S s t \<Longrightarrow> NS s t"
 proof (induct s t rule: kbo.induct)
   case (1 s t)
   from 1(2) have S: "S s t" .
   from S have w: "vars_term_ms (SCF t) \<subseteq># vars_term_ms (SCF s) \<and> weight t \<le> weight s"
     by (auto split: if_splits)
   note S = S w
   note IH = 1(1)[OF w]
   show ?case
   proof (cases "weight t < weight s")
     case True
     with S show ?thesis by simp
   next
     case False
     note IH = IH[OF False]
     note S = S False
     from not_S_Var[of _ t] S
     obtain f ss where s: "s = Fun f ss" by (cases s, auto)
     note IH = IH[OF s]
     show ?thesis
     proof (cases t)
       case (Var x)
       from S show ?thesis by (auto, insert Var s, auto)
     next
       case (Fun g ts)
       note IH = IH[OF Fun]
       let ?f = "(f, length ss)"
       let ?g = "(g, length ts)"
       let ?lex = "lex_ext_unbounded kbo ss ts"
       from S[simplified, unfolded s Fun] have disj: "pr_strict ?f ?g \<or> pr_weak ?f ?g \<and> fst ?lex" by (auto split: if_splits)
       show ?thesis
       proof (cases "pr_strict ?f ?g")
         case True
         then show ?thesis using S s Fun by auto
       next
         case False
         with disj have fg: "pr_weak ?f ?g" and lex: "fst ?lex" by auto
         note IH = IH[OF False fg]
         from lex have "fst (lex_ext kbo (length ss + length ts) ss ts)"
           unfolding lex_ext_def Let_def by auto
         from lex_ext_stri_imp_nstri[OF this] have lex: "snd ?lex"
           unfolding lex_ext_def Let_def by auto
         with False fg S s Fun show ?thesis by auto
       qed
     qed
   qed
 qed
 
 
 subsection \<open>Reflexivity and Irreflexivity\<close>
 
 lemma NS_refl: "NS s s"
 proof (induct s)
   case (Fun f ss)
   have "snd (lex_ext kbo (length ss) ss ss)"
     by (rule all_nstri_imp_lex_nstri, insert Fun[unfolded set_conv_nth], auto)
   then have "snd (lex_ext_unbounded kbo ss ss)" unfolding lex_ext_def Let_def by simp
   then show ?case by auto
 qed simp
 
 lemma pr_strict_irrefl: "\<not> pr_strict fn fn"
   unfolding pr_strict by auto
 
 lemma S_irrefl: "\<not> S t t"
 proof (induct t)
   case (Var x) then show ?case by (rule not_S_Var)
 next
   case (Fun f ts)
   from pr_strict_irrefl have "\<not> pr_strict (f, length ts) (f, length ts)" .
   moreover
   { assume "fst (lex_ext_unbounded kbo ts ts)"
     then obtain i where "i < length ts" and "S (ts ! i) (ts ! i)"
       unfolding lex_ext_unbounded_iff by auto
     with Fun have False by auto }
   ultimately show ?case by auto
 qed
 
 
 subsection \<open>Monotonicity (a.k.a. Closure under Contexts)\<close>
 
 lemma S_mono_one:
   assumes S: "S s t"
   shows "S (Fun f (ss1 @ s # ss2)) (Fun f (ss1 @ t # ss2))"
 proof -
   let ?ss = "ss1 @ s # ss2"
   let ?ts = "ss1 @ t # ss2"
   let ?s = "Fun f ?ss"
   let ?t = "Fun f ?ts"
   from S have w: "weight t \<le> weight s" and v: "vars_term_ms (SCF t) \<subseteq># vars_term_ms (SCF s)" 
     by (auto split: if_splits)
   have v': "vars_term_ms (SCF ?t) \<subseteq># vars_term_ms (SCF ?s)" using mset_replicate_mono[OF v] by simp
   have w': "weight ?t \<le> weight ?s" using sum_list_replicate_mono[OF w] by simp
   have lex: "fst (lex_ext_unbounded kbo ?ss ?ts)"
     unfolding lex_ext_unbounded_iff fst_conv
     by (rule disjI1, rule exI[of _ "length ss1"], insert S NS_refl, auto simp del: kbo.simps simp: nth_append)
   show ?thesis using v' w' lex by simp
 qed
 
 lemma S_ctxt: "S s t \<Longrightarrow> S (C\<langle>s\<rangle>) (C\<langle>t\<rangle>)"
   by (induct C, auto simp del: kbo.simps intro: S_mono_one)
 
 lemma NS_mono_one:
   assumes NS: "NS s t" shows "NS (Fun f (ss1 @ s # ss2)) (Fun f (ss1 @ t # ss2))"
 proof -
   let ?ss = "ss1 @ s # ss2"
   let ?ts = "ss1 @ t # ss2"
   let ?s = "Fun f ?ss"
   let ?t = "Fun f ?ts"
   from NS have w: "weight t \<le> weight s" and v: "vars_term_ms (SCF t) \<subseteq># vars_term_ms (SCF s)"
     by (auto split: if_splits)
   have v': "vars_term_ms (SCF ?t) \<subseteq># vars_term_ms (SCF ?s)" using mset_replicate_mono[OF v] by simp
   have w': "weight ?t \<le> weight ?s" using sum_list_replicate_mono[OF w] by simp
   have lex: "snd (lex_ext_unbounded kbo ?ss ?ts)"
     unfolding lex_ext_unbounded_iff snd_conv
   proof (intro disjI2 conjI allI impI)
     fix i
     assume "i < length (ss1 @ t # ss2)"
     then show "NS (?ss ! i) (?ts ! i)" using NS NS_refl
       by (cases "i = length ss1", auto simp del: kbo.simps simp: nth_append)
   qed simp
   show ?thesis using v' w' lex by simp
 qed
 
 lemma NS_ctxt: "NS s t \<Longrightarrow> NS (C\<langle>s\<rangle>) (C\<langle>t\<rangle>)"
   by (induct C, auto simp del: kbo.simps intro: NS_mono_one)
 
 
 subsection \<open>The Subterm Property\<close>
 
 lemma NS_Var_imp_eq_least: "NS (Var x) t \<Longrightarrow> t = Var x \<or> (\<exists> f. t = Fun f [] \<and> least f)"
   by (cases t, insert weight_w0[of t], auto split: if_splits)
 
 lemma kbo_supt_one: "NS s (t :: ('f, 'v) term) \<Longrightarrow> S (Fun f (bef @ s # aft)) t"
 proof (induct t arbitrary: f s bef aft)
   case (Var x)
   note NS = this
   let ?ss = "bef @ s # aft"
   let ?t = "Var x"
   have "length bef < length ?ss" by auto
   from scf[OF this, of f] obtain n where scf:"scf (f, length ?ss) (length bef) = Suc n" by (auto elim: lessE)
   obtain X where "vars_term_ms (SCF (Fun f ?ss)) = vars_term_ms (SCF s) + X"
     by (simp add: o_def scf[simplified])
   then have vs: "vars_term_ms (SCF s) \<subseteq># vars_term_ms (SCF (Fun f ?ss))" by simp
   from NS have vt: "vars_term_ms (SCF ?t) \<subseteq># vars_term_ms (SCF s)" by (auto split: if_splits)
   from vt vs have v: "vars_term_ms (SCF ?t) \<subseteq># vars_term_ms (SCF (Fun f ?ss))" by (rule subset_mset.order_trans)
   from weight_w0[of "Fun f ?ss"] v show ?case by simp
 next
   case (Fun g ts f s bef aft)
   let ?t = "Fun g ts"
   let ?ss = "bef @ s # aft"
   note NS = Fun(2)
   note IH = Fun(1)
   have "length bef < length ?ss" by auto
   from scf[OF this, of f] obtain n where scff:"scf (f, length ?ss) (length bef) = Suc n" by (auto elim: lessE)
   note scff = scff[simplified]
   obtain X where "vars_term_ms (SCF (Fun f ?ss)) = vars_term_ms (SCF s) + X"
     by (simp add: o_def scff)
   then have vs: "vars_term_ms (SCF s) \<subseteq># vars_term_ms (SCF (Fun f ?ss))" by simp
   have ws: "weight s \<le> sum_list (map weight (scf_list (scf (f, length ?ss)) ?ss))"
     by (simp add: scff)
   from NS have wt: "weight ?t \<le> weight s" and
     vt: "vars_term_ms (SCF ?t) \<subseteq># vars_term_ms (SCF s)" by (auto split: if_splits)
   from ws wt have w: "weight ?t \<le> sum_list (map weight (scf_list (scf (f, length ?ss)) ?ss))" by simp
   from vt vs have v: "vars_term_ms (SCF ?t) \<subseteq># vars_term_ms (SCF (Fun f ?ss))" by auto
   then have v': "(vars_term_ms (SCF ?t) \<subseteq># vars_term_ms (SCF (Fun f ?ss))) = True" by simp
   show ?case
   proof (cases "weight ?t = weight (Fun f ?ss)")
     case False
     with w v show ?thesis by auto
   next
     case True
     from wt[unfolded True] weight_gt_0[of s]
     have wf: "w (f, length ?ss) = 0"
       and lsum: "sum_list (map weight (scf_list (scf (f, length ?ss)) bef)) = 0"
       "sum_list (map weight (scf_list (\<lambda> i. (scf (f, length ?ss) (Suc (length bef) + i))) aft)) = 0"
       and n: "n = 0"
       by (auto simp: scff)
     have "sum_list (map weight bef) \<le> sum_list (map weight (scf_list (scf (f, length ?ss)) bef))"
       by (rule sum_list_scf_list, rule scf, auto)
     with lsum(1) have "sum_list (map weight bef) = 0" by arith
     then have bef: "bef = []" using weight_gt_0[of "hd bef"] by (cases bef, auto)
     have "sum_list (map weight aft) \<le> sum_list (map weight (scf_list (\<lambda> i. (scf (f, length ?ss) (Suc (length bef) + i))) aft))"
       by (rule sum_list_scf_list, rule scf, auto)
     with lsum(2) have "sum_list (map weight aft) = 0" by arith
     then have aft: "aft = []" using weight_gt_0[of "hd aft"] by (cases aft, auto)
     note scff = scff[unfolded bef aft n, simplified]
     from bef aft
     have ba: "bef @ s # aft = [s]" by simp
     with wf have wf: "w (f, 1) = 0" by auto
     from wf have wst: "weight s = weight ?t" using scff unfolding True[unfolded ba]
       by (simp add: scf_list_def)
     let ?g = "(g, length ts)"
     let ?f = "(f, 1)"
     show ?thesis
     proof (cases "pr_strict ?f ?g")
       case True
       with w v show ?thesis unfolding ba by simp
     next
       case False
       note admf = adm[OF wf]
       from admf have pg: "pr_weak ?f ?g" .
       from pg False[unfolded pr_strict] have "pr_weak ?g ?f" by auto
       from pr_weak_trans[OF this admf] have g: "\<And> h k. pr_weak ?g (h, k)" .
       show ?thesis
       proof (cases ts)
         case Nil
         have "fst (lex_ext_unbounded kbo [s] ts)"
           unfolding Nil lex_ext_unbounded_iff by auto
         with pg w v show ?thesis unfolding ba by simp
       next
         case (Cons t tts)
         {
           fix x
           assume s: "s = Var x"
           from NS_Var_imp_eq_least[OF NS[unfolded s Cons]] have False by auto
         }
         then obtain h ss where s: "s = Fun h ss" by (cases s, auto)
         from NS wst g[of h "length ss"] pr_strict[of "(h, length ss)" "(g, length ts)"] have lex: "snd (lex_ext_unbounded kbo ss ts)"
           unfolding s by (auto split: if_splits)
         from lex obtain s0 sss where ss: "ss = s0 # sss" unfolding Cons lex_ext_unbounded_iff snd_conv by (cases ss, auto)
         from lex[unfolded ss Cons] have "S s0 t \<or> NS s0 t"
           by (cases "kbo s0 t", simp add: lex_ext_unbounded.simps del: kbo.simps split: if_splits)
         with S_imp_NS[of s0 t] have "NS s0 t" by blast
         from IH[OF _ this, of h Nil sss] have S: "S s t" unfolding Cons s ss by simp
         have "fst (lex_ext_unbounded kbo [s] ts)" unfolding Cons
           unfolding lex_ext_unbounded_iff fst_conv
           by (rule disjI1[OF exI[of _ 0]], insert S, auto simp del: kbo.simps)
         then have lex: "fst (lex_ext_unbounded kbo [s] ts) = True" by simp
         note all = lex wst[symmetric] S pg scff v'
         note all = all[unfolded ba, unfolded s ss Cons]
         have w: "weight (Fun f [t]) = weight (t :: ('f, 'v) term)" for t
           using wf scff by (simp add: scf_list_def)
         show ?thesis unfolding ba unfolding s ss Cons
           unfolding kbo.simps[of "Fun f [Fun h (s0 # sss)]"]
           unfolding all w using all by simp
       qed
     qed
   qed
 qed
 
 lemma S_supt:
   assumes supt: "s \<rhd> t"
   shows "S s t"
 proof -
   from supt obtain C where s: "s = C\<langle>t\<rangle>" and C: "C \<noteq> \<box>" by auto
   show ?thesis unfolding s using C
   proof (induct C arbitrary: t)
     case (More f bef C aft t)
     show ?case
     proof (cases "C = \<box>")
       case True
       from kbo_supt_one[OF NS_refl, of f bef t aft] show ?thesis unfolding True by simp
     next
       case False
       from kbo_supt_one[OF S_imp_NS[OF More(1)[OF False]], of f bef t aft]
       show ?thesis by simp
     qed
   qed simp
 qed
 
 lemma NS_supteq:
   assumes "s \<unrhd> t"
   shows "NS s t"
   using S_imp_NS[OF S_supt[of s t]] NS_refl[of s] using assms[unfolded subterm.le_less]
   by blast
 
 subsection \<open>Least Elements\<close>
 
 lemma NS_all_least:
   assumes l: "least f"
   shows "NS t (Fun f [])"
 proof (induct t)
   case (Var x)
   show ?case using l[unfolded least] l
     by auto
 next
   case (Fun g ts)
   show ?case
   proof (cases ts)
     case (Cons s ss)
     with Fun[of s] have "NS s (Fun f [])" by auto
     from S_imp_NS[OF kbo_supt_one[OF this, of g Nil ss]] show ?thesis unfolding Cons by simp
   next
     case Nil
     from weight_w0[of "Fun g []"] have w: "weight (Fun g []) \<ge> weight (Fun f [])"
       using l[unfolded least] by auto
     from lex_ext_least_1
     have "snd (lex_ext kbo 0 [] [])" .
     then have lex: "snd (lex_ext_unbounded kbo [] [])" unfolding lex_ext_def Let_def by simp
     then show ?thesis using w l[unfolded least] unfolding Fun Nil by (auto simp: empty_le)
   qed
 qed
 
 lemma not_S_least:
   assumes l: "least f"
   shows "\<not> S (Fun f []) t"
 proof (cases t)
   case (Fun g ts)
   show ?thesis unfolding Fun
   proof
     assume S: "S (Fun f []) (Fun g ts)"
     from S[unfolded Fun, simplified]
     have w: "w (g, length ts) + sum_list (map weight (scf_list (scf (g, length ts)) ts)) \<le> weight (Fun f [])"
       by (auto split: if_splits)
     show False
     proof (cases ts)
       case Nil
       with w have "w (g, 0) \<le> weight (Fun f [])" by simp
       also have "weight (Fun f []) \<le> w0" using l[unfolded least] by simp
       finally have g: "w (g, 0) = w0" using  w0(1)[of g] by auto
       with w Nil l[unfolded least] have gf: "w (g, 0) = w (f, 0)" by simp
       with S have p: "pr_weak (f, 0) (g, 0)" unfolding Nil
         by (simp split: if_splits add: pr_strict)
       with l[unfolded least, THEN conjunct2, rule_format, OF g] have p2: "pr_weak (g, 0) (f, 0)" by auto
       from p p2 gf S have "fst (lex_ext_unbounded kbo [] ts)" unfolding Nil
         by (auto simp: pr_strict)
       then show False unfolding lex_ext_unbounded_iff by auto
     next
       case (Cons s ss)
       then have ts: "ts = [] @ s # ss" by auto
       from scf[of 0 "length ts" g] obtain n where scff: "scf (g, length ts) 0 = Suc n" unfolding Cons by (auto elim: lessE)
       let ?e = "sum_list (map weight (
           scf_list (\<lambda>i. scf (g, Suc (length ss)) (Suc i)) ss
           ))"
       have "w0 + sum_list (map weight (replicate n s)) \<le> weight s + sum_list (map weight (replicate n s))"
         using weight_w0[of s] by auto
       also have "\<dots> = sum_list (map weight (replicate (scf (g, length ts) 0) s))" unfolding scff by simp
       also have "w (g, length ts) + \<dots> + ?e \<le> w0" using w l[unfolded least] unfolding ts scf_list_bef_i_aft by auto
       finally have "w0 + sum_list (map weight (replicate n s)) + w (g, length ts) + ?e \<le> w0" by arith
       then have wg: "w (g, length ts) = 0" and null: "?e = 0" "sum_list (map weight (replicate n s)) = 0" by auto
       from null(2) weight_gt_0[of s] have n: "n = 0" by (cases n, auto)
       have "sum_list (map weight ss) \<le> ?e"
         by (rule sum_list_scf_list, rule scf, auto)
       from this[unfolded null] weight_gt_0[of "hd ss"] have ss: "ss = []" by (cases ss, auto)
       with Cons have ts: "ts = [s]" by simp
       note scff = scff[unfolded ts n, simplified]
       from wg ts have wg: "w (g, 1) = 0" by auto
       from adm[OF wg, rule_format, of f] have "pr_weak (g, 1) (f, 0)" by auto
       with S[unfolded Fun ts] l[unfolded least] weight_w0[of s] scff
       have "fst (lex_ext_unbounded kbo [] [s])"
         by (auto split: if_splits simp: scf_list_def pr_strict)
       then show ?thesis unfolding lex_ext_unbounded_iff by auto
     qed
   qed
 qed simp
 
 lemma NS_least_least:
   assumes l: "least f"
     and NS: "NS (Fun f []) t"
   shows "\<exists> g. t = Fun g [] \<and> least g"
 proof (cases t)
   case (Var x)
   show ?thesis using NS unfolding Var by simp
 next
   case (Fun g ts)
   from NS[unfolded Fun, simplified]
   have w: "w (g, length ts) + sum_list (map weight (scf_list (scf (g, length ts)) ts)) \<le> weight (Fun f [])"
     by (auto split: if_splits)
   show ?thesis
   proof (cases ts)
     case Nil
     with w have "w (g, 0) \<le> weight (Fun f [])" by simp
     also have "weight (Fun f []) \<le> w0" using l[unfolded least] by simp
     finally have g: "w (g, 0) = w0" using  w0(1)[of g] by auto
     with w Nil l[unfolded least] have gf: "w (g, 0) = w (f, 0)" by simp
     with NS[unfolded Fun] have p: "pr_weak (f, 0) (g, 0)" unfolding Nil
       by (simp split: if_splits add: pr_strict)
     have least: "least g" unfolding least
     proof (rule conjI[OF g], intro allI)
       fix h
       from l[unfolded least] have "w (h, 0) = w0 \<longrightarrow> pr_weak (h, 0) (f, 0)" by blast
       with pr_weak_trans p show "w (h, 0) = w0 \<longrightarrow> pr_weak (h, 0) (g, 0)" by blast
     qed
     show ?thesis
       by (rule exI[of _ g], unfold Fun Nil, insert least, auto)
   next
     case (Cons s ss)
     then have ts: "ts = [] @ s # ss" by auto
     from scf[of 0 "length ts" g] obtain n where scff: "scf (g, length ts) 0 = Suc n" unfolding Cons by (auto elim: lessE)
     let ?e = "sum_list (map weight (
         scf_list (\<lambda>i. scf (g, Suc (length ss)) (Suc i)) ss
       ))"
     have "w0 + sum_list (map weight (replicate n s)) \<le> weight s + sum_list (map weight (replicate n s))"
       using weight_w0[of s] by auto
     also have "\<dots> = sum_list (map weight (replicate (scf (g, length ts) 0) s))" unfolding scff by simp
     also have "w (g, length ts) + \<dots> + ?e \<le> w0" using w l[unfolded least] unfolding ts scf_list_bef_i_aft by auto
     finally have "w0 + sum_list (map weight (replicate n s)) + w (g, length ts) + ?e \<le> w0" by arith
     then have wg: "w (g, length ts) = 0" and null: "?e = 0" "sum_list (map weight (replicate n s)) = 0" by auto
     from null(2) weight_gt_0[of s] have n: "n = 0" by (cases n, auto)
     have "sum_list (map weight ss) \<le> ?e"
       by (rule sum_list_scf_list, rule scf, auto)
     from this[unfolded null] weight_gt_0[of "hd ss"] have ss: "ss = []" by (cases ss, auto)
     with Cons have ts: "ts = [s]" by simp
     note scff = scff[unfolded ts n, simplified]
     from wg ts have wg: "w (g, 1) = 0" by auto
     from adm[OF wg, rule_format, of f] have "pr_weak (g, 1) (f, 0)" by auto
     with NS[unfolded Fun ts] l[unfolded least] weight_w0[of s] scff
     have "snd (lex_ext_unbounded kbo [] [s])"
       by (auto split: if_splits simp: scf_list_def pr_strict)
     then show ?thesis unfolding lex_ext_unbounded_iff snd_conv by auto
   qed
 qed
 
 
 subsection \<open>Stability (a.k.a. Closure under Substitutions\<close>
 
 lemma weight_subst: "weight (t \<cdot> \<sigma>) =
   weight t + sum_mset (image_mset (\<lambda> x. weight (\<sigma> x) - w0) (vars_term_ms (SCF t)))"
 proof (induct t)
   case (Var x)
   show ?case using weight_w0[of "\<sigma> x"] by auto
 next
   case (Fun f ts)
   let ?ts = "scf_list (scf (f, length ts)) ts"
   define sts where "sts = ?ts"
   have id: "map (\<lambda> t. weight (t \<cdot> \<sigma>)) ?ts = map (\<lambda> t. weight t + sum_mset (image_mset (\<lambda> x. weight (\<sigma> x) - w0) (vars_term_ms (scf_term scf t)))) ?ts"
     by (rule map_cong[OF refl Fun], insert scf_list_subset[of _ ts], auto)
   show ?case
     by (simp add: o_def id, unfold sts_def[symmetric], induct sts, auto)
 qed
 
 lemma weight_stable_le:
   assumes ws: "weight s \<le> weight t"
     and vs: "vars_term_ms (SCF s) \<subseteq># vars_term_ms (SCF t)"
   shows "weight (s \<cdot> \<sigma>) \<le> weight (t \<cdot> \<sigma>)"
 proof -
   from vs[unfolded mset_subset_eq_exists_conv] obtain u where vt: "vars_term_ms (SCF t) = vars_term_ms (SCF s) + u" ..
   show ?thesis unfolding weight_subst vt using ws by auto
 qed
 
 lemma weight_stable_lt:
   assumes ws: "weight s < weight t"
     and vs: "vars_term_ms (SCF s) \<subseteq># vars_term_ms (SCF t)"
  shows "weight (s \<cdot> \<sigma>) < weight (t \<cdot> \<sigma>)"
 proof -
   from vs[unfolded mset_subset_eq_exists_conv] obtain u where vt: "vars_term_ms (SCF t) = vars_term_ms (SCF s) + u" ..
   show ?thesis unfolding weight_subst vt using ws by auto
 qed
 
 text \<open>KBO is stable, i.e., closed under substitutions.\<close>
 lemma kbo_stable:
   fixes \<sigma> :: "('f, 'v) subst"
   assumes "NS s t"
   shows "(S s t \<longrightarrow> S (s \<cdot> \<sigma>) (t \<cdot> \<sigma>)) \<and> NS (s \<cdot> \<sigma>) (t \<cdot> \<sigma>)" (is "?P s t")
   using assms
 proof (induct s arbitrary: t)
   case (Var y t)
   then have not: "\<not> S (Var y) t" using not_S_Var[of y t] by auto
   from NS_Var_imp_eq_least[OF Var]
   have "t = Var y \<or> (\<exists> f. t = Fun f [] \<and> least f)" by simp
   then obtain f where "t = Var y \<or> t = Fun f [] \<and> least f" by auto
   then have "NS (Var y \<cdot> \<sigma>) (t \<cdot> \<sigma>)"
   proof
     assume "t = Var y"
     then show ?thesis using NS_refl[of "t \<cdot> \<sigma>"] by auto
   next
     assume "t = Fun f [] \<and> least f"
     with NS_all_least[of f "Var y \<cdot> \<sigma>"] show ?thesis by auto
   qed
   with not show ?case by blast
 next
   case (Fun f ss t)
   note NS = Fun(2)
   note IH = Fun(1)
   let ?s = "Fun f ss"
   define s where "s = ?s"
   let ?ss = "map (\<lambda> s. s \<cdot> \<sigma>) ss"
   from NS have v: "vars_term_ms (SCF t) \<subseteq># vars_term_ms (SCF ?s)" and w: "weight t \<le> weight ?s"
     by (auto split: if_splits)
   from weight_stable_le[OF w v] have w\<sigma>: "weight (t \<cdot> \<sigma>) \<le> weight (?s \<cdot> \<sigma>)" by auto
   from vars_term_ms_subst_mono[OF v, of "\<lambda> x. SCF (\<sigma> x)"] have v\<sigma>: "vars_term_ms (SCF (t \<cdot> \<sigma>)) \<subseteq># vars_term_ms (SCF (?s \<cdot> \<sigma>))"
     unfolding scf_term_subst .
   show ?case
   proof (cases "weight (t \<cdot> \<sigma>) < weight (?s \<cdot> \<sigma>)")
     case True
     with v\<sigma> show ?thesis by auto
   next
     case False
     with weight_stable_lt[OF _ v, of \<sigma>] w have w: "weight t = weight ?s" by arith
     show ?thesis
     proof (cases t)
       case (Var y)
       from set_mset_mono[OF v, folded s_def]
       have "y \<in> vars_term (SCF s)" unfolding Var by (auto simp: o_def)
       also have "\<dots> \<subseteq> vars_term s" by (rule vars_term_scf_subset)
       finally have "y \<in> vars_term s" by auto
       from supteq_Var[OF this] have "?s \<rhd> Var y" unfolding s_def Fun by auto
       from S_supt[OF supt_subst[OF this]] have S: "S (?s \<cdot> \<sigma>) (t \<cdot> \<sigma>)" unfolding Var .
       from S_imp_NS[OF S] S show ?thesis by auto
     next
       case (Fun g ts) note t = this
       let ?f = "(f, length ss)"
       let ?g = "(g, length ts)"
       let ?ts = "map (\<lambda> s. s \<cdot> \<sigma>) ts"
       show ?thesis
       proof (cases "pr_strict ?f ?g")
         case True
         then have S: "S (?s \<cdot> \<sigma>) (t \<cdot> \<sigma>)" using w\<sigma> v\<sigma> unfolding t by simp
         from S S_imp_NS[OF S] show ?thesis by simp
       next
         case False note prec = this
         show ?thesis
         proof (cases "pr_weak ?f ?g")
           case False
           with v w prec have "\<not> NS ?s t" unfolding t by (auto simp del: vars_term_ms.simps)
           with NS show ?thesis by blast
         next
           case True
           from v w have "vars_term_ms (SCF t) \<subseteq># vars_term_ms (SCF ?s) \<and> weight t \<le> weight ?s" "\<not> weight t < weight ?s" by auto
           {
             fix i
             assume i: "i < length ss" "i < length ts"
               and S: "S (ss ! i) (ts ! i)"
             have "S (map (\<lambda>s. s \<cdot> \<sigma>) ss ! i) (map (\<lambda>s. s \<cdot> \<sigma>) ts ! i)"
               using IH[OF _ S_imp_NS[OF S]] S i unfolding set_conv_nth by (force simp del: kbo.simps)
           } note IH_S = this
           {
             fix i
             assume i: "i < length ss" "i < length ts"
               and NS: "NS (ss ! i) (ts ! i)"
             have "NS (map (\<lambda>s. s \<cdot> \<sigma>) ss ! i) (map (\<lambda>s. s \<cdot> \<sigma>) ts ! i)"
               using IH[OF _ NS] i unfolding set_conv_nth by (force simp del: kbo.simps)
           } note IH_NS = this
           {
             assume "S ?s t"
             with prec v w True have lex: "fst (lex_ext_unbounded kbo ss ts)"
               unfolding s_def t by simp
             have "fst (lex_ext_unbounded kbo ?ss ?ts)"
               by (rule lex_ext_unbounded_map_S[OF _ _ lex], insert IH_NS IH_S, blast+)
             with v\<sigma> w\<sigma> prec True have "S (?s \<cdot> \<sigma>) (t \<cdot> \<sigma>)"
               unfolding t by auto
           }
           moreover
           {
             from NS prec v w True have lex: "snd (lex_ext_unbounded kbo ss ts)"
               unfolding t by simp
             have "snd (lex_ext_unbounded kbo ?ss ?ts)"
               by (rule lex_ext_unbounded_map_NS[OF _ _ lex], insert IH_S IH_NS, blast)
             with v\<sigma> w\<sigma> prec True have "NS (?s \<cdot> \<sigma>) (t \<cdot> \<sigma>)"
               unfolding t by auto
           }
           ultimately show ?thesis by auto
         qed
       qed
     qed
   qed
 qed
 
 lemma S_subst:
   "S s t \<Longrightarrow> S (s \<cdot> (\<sigma> :: ('f, 'v) subst)) (t \<cdot> \<sigma>)"
   using kbo_stable[OF S_imp_NS, of s t \<sigma>] by auto
 
 lemma NS_subst: "NS s t \<Longrightarrow> NS (s \<cdot> (\<sigma> :: ('f, 'v) subst)) (t \<cdot> \<sigma>)" using kbo_stable[of s t \<sigma>] by auto
 
 
 subsection \<open>Transitivity and Compatibility\<close>
 
 lemma kbo_trans: "(S s t \<longrightarrow> NS t u \<longrightarrow> S s u) \<and>
   (NS s t \<longrightarrow> S t u \<longrightarrow> S s u) \<and>
   (NS s t \<longrightarrow> NS t u \<longrightarrow> NS s u)"
   (is "?P s t u")
 proof (induct s arbitrary: t u)
   case (Var x t u)
   from not_S_Var[of x t] have nS: "\<not> S (Var x) t" .
   show ?case
   proof (cases "NS (Var x) t")
     case False
     with nS show ?thesis by blast
   next
     case True
     from NS_Var_imp_eq_least[OF this] obtain f where
       "t = Var x \<or> t = Fun f [] \<and> least f" by blast
     then show ?thesis
     proof
       assume "t = Var x"
       then show ?thesis using nS by blast
     next
       assume "t = Fun f [] \<and> least f"
       then have t: "t = Fun f []" and least: "least f" by auto
       from not_S_least[OF least] have nS': "\<not> S t u" unfolding t .
       show ?thesis
       proof (cases "NS t u")
         case True
         with NS_least_least[OF least, of u] t obtain h where
           u: "u = Fun h []" and least: "least h" by auto
         from NS_all_least[OF least] have NS: "NS (Var x) u" unfolding u .
         with nS nS' show ?thesis by blast
       next
         case False
         with S_imp_NS[of t u] show ?thesis by blast
       qed
     qed
   qed
 next
   case (Fun f ss t u) note IH = this
   let ?s = "Fun f ss"
   show ?case
   proof (cases "NS ?s t")
     case False
     with S_imp_NS[of ?s t] show ?thesis by blast
   next
     case True note st = this
     then have vst: "vars_term_ms (SCF t) \<subseteq># vars_term_ms (SCF ?s)" and wst: "weight t \<le> weight ?s"
       by (auto split: if_splits)
     show ?thesis
     proof (cases "NS t u")
       case False
       with S_imp_NS[of t u] show ?thesis by blast
     next
       case True note tu = this
       then have vtu: "vars_term_ms (SCF u) \<subseteq># vars_term_ms (SCF t)" and wtu: "weight u \<le> weight t"
         by (auto split: if_splits)
       from vst vtu have v: "vars_term_ms (SCF u) \<subseteq># vars_term_ms (SCF ?s)" by simp
       from wst wtu have w: "weight u \<le> weight ?s" by simp
       show ?thesis
       proof (cases "weight u < weight ?s")
         case True
         with v show ?thesis by auto
       next
         case False
         with wst wtu have wst: "weight t = weight ?s" and wtu: "weight u = weight t" and w: "weight u = weight ?s" by arith+
         show ?thesis
         proof (cases u)
           case (Var z)
           with v w show ?thesis by auto
         next
           case (Fun h us) note u = this
           show ?thesis
           proof (cases t)
             case (Fun g ts) note t = this
             let ?f = "(f, length ss)"
             let ?g = "(g, length ts)"
             let ?h = "(h, length us)"
             from st t wst have fg: "pr_weak ?f ?g" by (simp split: if_splits add: pr_strict)
             from tu t u wtu have gh: "pr_weak ?g ?h" by (simp split: if_splits add: pr_strict)
             from pr_weak_trans[OF fg gh] have fh: "pr_weak ?f ?h" .
             show ?thesis
             proof (cases "pr_strict ?f ?h")
               case True
               with w v u show ?thesis by auto
             next
               case False
               let ?lex = "lex_ext_unbounded kbo"
               from False fh have hf: "pr_weak ?h ?f" unfolding pr_strict by auto
               from pr_weak_trans[OF hf fg] have hg: "pr_weak ?h ?g" .
               from hg have gh2: "\<not> pr_strict ?g ?h" unfolding pr_strict by auto
               from pr_weak_trans[OF gh hf] have gf: "pr_weak ?g ?f" .
               from gf have fg2: "\<not> pr_strict ?f ?g" unfolding pr_strict by auto
               from st t wst fg2 have st: "snd (?lex ss ts)"
                 by (auto split: if_splits)
               from tu t u wtu gh2 have tu: "snd (?lex ts us)"
                 by (auto split: if_splits)
               {
                 fix s t u
                 assume "s \<in> set ss"
                 from IH[OF this, of t u]
                 have "(NS s t \<and> S t u \<longrightarrow> S s u) \<and>
                   (S s t \<and> NS t u \<longrightarrow> S s u) \<and>
                   (NS s t \<and> NS t u \<longrightarrow> NS s u) \<and>
                   (S s t \<and> S t u \<longrightarrow> S s u)"
                   using S_imp_NS[of s t] by blast
               } note IH = this
               let ?b = "length ss + length ts + length us"
               note lex = lex_ext_compat[of ss ts us kbo ?b, OF IH]
               let ?lexb = "lex_ext kbo ?b"
               note conv = lex_ext_def Let_def
               from st have st: "snd (?lexb ss ts)" unfolding conv by simp
               from tu have tu: "snd (?lexb ts us)" unfolding conv by simp
               from lex st tu have su: "snd (?lexb ss us)" by blast
               then have su: "snd (?lex ss us)" unfolding conv by simp
               from w v u su fh have NS: "NS ?s u" by simp
               {
                 assume st: "S ?s t"
                 with t wst fg fg2 have st: "fst (?lex ss ts)"
                   by (auto split: if_splits)
                 then have st: "fst (?lexb ss ts)" unfolding conv by simp
                 from lex st tu have su: "fst (?lexb ss us)" by blast
                 then have su: "fst (?lex ss us)" unfolding conv by simp
                 from w v u su fh have S: "S ?s u" by simp
               } note S_left = this
               {
                 assume tu: "S t u"
                 with t u wtu gh2 have tu: "fst (?lex ts us)"
                   by (auto split: if_splits)
                 then have tu: "fst (?lexb ts us)" unfolding conv by simp
                 from lex st tu have su: "fst (?lexb ss us)" by blast
                 then have su: "fst (?lex ss us)" unfolding conv by simp
                 from w v u su fh have S: "S ?s u" by simp
               } note S_right = this
               from NS S_left S_right show ?thesis by blast
             qed
           next
             case (Var x) note t = this
             from tu weight_w0[of u] have least: "least h" and u: "u = Fun h []" unfolding t u
               by (auto split: if_splits)
             from NS_all_least[OF least] have NS: "NS ?s u" unfolding u .
             from not_S_Var have nS': "\<not> S t u" unfolding t .
             show ?thesis
             proof (cases "S ?s t")
               case False
               with nS' NS show ?thesis by blast
             next
               case True
               then have "vars_term_ms (SCF t) \<subseteq># vars_term_ms (SCF ?s)"
                 by (auto split: if_splits)
               from set_mset_mono[OF this, unfolded set_mset_vars_term_ms t]
               have "x \<in> vars_term (SCF ?s)" by simp
               also have "\<dots> \<subseteq> vars_term ?s" by (rule vars_term_scf_subset)
               finally obtain s sss where ss: "ss = s # sss" by (cases ss, auto)
               from kbo_supt_one[OF NS_all_least[OF least, of s], of f Nil sss]
               have "S ?s u" unfolding ss u by simp
               with NS show ?thesis by blast
             qed
           qed
         qed
       qed
     qed
   qed
 qed
 
 lemma S_trans: "S s t \<Longrightarrow> S t u \<Longrightarrow> S s u" using S_imp_NS[of s t] kbo_trans[of s t u] by blast
 lemma NS_trans: "NS s t \<Longrightarrow> NS t u \<Longrightarrow> NS s u" using kbo_trans[of s t u] by blast
 lemma NS_S_compat: "NS s t \<Longrightarrow> S t u \<Longrightarrow> S s u" using kbo_trans[of s t u] by blast
 lemma S_NS_compat: "S s t \<Longrightarrow> NS t u \<Longrightarrow> S s u" using kbo_trans[of s t u] by blast
 
 
 subsection \<open>Strong Normalization (a.k.a. Well-Foundedness)\<close>
 
 lemma kbo_strongly_normalizing:
   fixes s :: "('f, 'v) term"
   shows "SN_on {(s, t). S s t} {s}"
 proof -
   let ?SN = "\<lambda> t :: ('f, 'v) term. SN_on {(s, t). S s t} {t}"
   let ?m1 = "\<lambda> (f, ss). weight (Fun f ss)"
   let ?m2 = "\<lambda> (f, ss). (f, length ss)"
   let ?rel' = "lex_two {(fss, gts). ?m1 fss > ?m1 gts} {(fss, gts). ?m1 fss \<ge> ?m1 gts} {(fss, gts). pr_strict (?m2 fss) (?m2 gts)}"
   let ?rel = "inv_image ?rel' (\<lambda> x. (x, x))"
   have SN_rel: "SN ?rel"
     by (rule SN_inv_image, rule lex_two, insert SN_inv_image[OF pr_SN, of ?m2]  SN_inv_image[OF SN_nat_gt, of ?m1],
         auto simp: inv_image_def)
   note conv = SN_on_all_reducts_SN_on_conv
   show "?SN s"
   proof (induct s)
     case (Var x)
     show ?case unfolding conv[of _ "Var x"] using not_S_Var[of x] by auto
   next
     case (Fun f ss)
     then have subset: "set ss \<subseteq> {s. ?SN s}" by blast
     let ?P = "\<lambda> (f, ss). set ss \<subseteq> {s. ?SN s} \<longrightarrow> ?SN (Fun f ss)"
     {
       fix fss
       have "?P fss"
       proof (induct fss rule: SN_induct[OF SN_rel])
         case (1 fss)
         obtain f ss where fss: "fss = (f, ss)" by force
         {
           fix g ts
           assume "?m1 (f, ss) > ?m1 (g, ts) \<or> ?m1 (f, ss) \<ge> ?m1 (g, ts) \<and> pr_strict (?m2 (f, ss)) (?m2 (g, ts))"
             and "set ts \<subseteq> {s. ?SN s}"
           then have "?SN (Fun g ts)"
             using 1[rule_format, of "(g, ts)", unfolded fss split] by auto
         } note IH = this[unfolded split]
         show ?case unfolding fss split
         proof
           assume SN_s: "set ss \<subseteq> {s. ?SN s}"
           let ?f = "(f, length ss)"
           let ?s = "Fun f ss"
           let ?SNt = "\<lambda> g ts. ?SN (Fun g ts)"
           let ?sym = "\<lambda> g ts. (g, length ts)"
           let ?lex = "lex_ext kbo (weight ?s)"
           let ?lexu = "lex_ext_unbounded kbo"
           let ?lex_SN = "{(ys, xs). (\<forall> y \<in> set ys. ?SN y) \<and> fst (?lex ys xs)}"
           from lex_ext_SN[of kbo "weight ?s", OF NS_S_compat]
           have SN: "SN ?lex_SN" .
           {
             fix g and ts :: "('f, 'v) term list"
             assume "pr_weak ?f (?sym g ts) \<and> weight (Fun g ts) \<le> weight ?s \<and> set ts \<subseteq> {s. ?SN s}"
             then have "?SNt g ts"
             proof (induct ts arbitrary: g rule: SN_induct[OF SN])
               case (1 ts g)
               note inner_IH = 1(1)
               let ?g = "(g, length ts)"
               let ?t = "Fun g ts"
               from 1(2) have fg: "pr_weak ?f ?g" and w: "weight ?t \<le> weight ?s"  and SN: "set ts \<subseteq> {s. ?SN s}" by auto
               show "?SNt g ts" unfolding conv[of _ ?t]
               proof (intro allI impI)
                 fix u
                 assume "(?t, u) \<in> {(s, t). S s t}"
                 then have tu: "S ?t u" by auto
                 then show "?SN u"
                 proof (induct u)
                   case (Var x)
                   then show ?case using not_S_Var[of x] unfolding conv[of _ "Var x"] by auto
                 next
                   case (Fun h us)
                   let ?h = "(h, length us)"
                   let ?u = "Fun h us"
                   note tu = Fun(2)
                   {
                     fix u
                     assume u: "u \<in> set us"
                     then have "?u \<rhd> u" by auto
                     from S_trans[OF tu S_supt[OF this]] have "S ?t u" by auto
                     from Fun(1)[OF u this] have "?SN u" .
                   } then have SNu: "set us \<subseteq> {s . ?SN s}" by blast
                   note IH = IH[OF _ this]
                   from tu have wut: "weight ?u \<le> weight ?t" by (simp split: if_splits)
                   show ?case
                   proof (cases "?m1 (f, ss) > ?m1 (h, us) \<or> ?m1 (f, ss) \<ge> ?m1 (h, us) \<and> pr_strict (?m2 (f, ss)) (?m2 (h, us))")
                     case True
                     from IH[OF True[unfolded split]] show ?thesis by simp
                   next
                     case False
                     with wut w have wut: "weight ?t = weight ?u" "weight ?s = weight ?u" by auto
                     note False = False[unfolded split wut]
                     note tu = tu[unfolded kbo.simps[of ?t] wut, unfolded Fun term.simps, simplified]
                     from tu have gh: "pr_weak ?g ?h" unfolding pr_strict by (auto split: if_splits)
                     from pr_weak_trans[OF fg gh] have fh: "pr_weak ?f ?h" .
                     from False wut fh have "\<not> pr_strict ?f ?h" unfolding pr_strict by auto
                     with fh have hf: "pr_weak ?h ?f" unfolding pr_strict by auto
                     from pr_weak_trans[OF hf fg] have hg: "pr_weak ?h ?g" .
                     from hg have gh2: "\<not> pr_strict ?g ?h" unfolding pr_strict by auto
                     from tu gh2 have lex: "fst (?lexu ts us)" by (auto split: if_splits)
                     from fh wut SNu have "pr_weak ?f ?h \<and> weight ?u \<le> weight ?s \<and> set us \<subseteq> {s. ?SN s}"
                       by auto
                     note inner_IH = inner_IH[OF _ this]
                     show ?thesis
                     proof (rule inner_IH, rule, unfold split, intro conjI ballI)
                       have "fst (?lexu ts us)" by (rule lex)
                       moreover have "length us \<le> weight ?s"
                       proof -
                         have "length us \<le> sum_list (map weight us)"
                         proof (induct us)
                           case (Cons u us)
                           from Cons have "length (u # us) \<le> Suc (sum_list (map weight us))" by auto
                           also have "... \<le> sum_list (map weight (u # us))" using weight_gt_0[of u]
                             by auto
                           finally show ?case .
                         qed simp
                         also have "\<dots> \<le> sum_list (map weight (scf_list (scf (h, length us)) us))"
                           by (rule sum_list_scf_list[OF scf])
                         also have "... \<le> weight ?s" using wut by simp
                         finally show ?thesis .
                       qed
                       ultimately show "fst (?lex ts us)" unfolding lex_ext_def Let_def by auto
                     qed (insert SN, blast)
                   qed
                 qed
               qed
             qed
           }
           from this[of f ss] SN_s  show "?SN ?s" by auto
         qed
       qed
     }
     from this[of "(f, ss)", unfolded split]
     show ?case using Fun by blast
   qed
 qed
 
 lemma S_SN: "SN {(x, y). S x y}"
   using kbo_strongly_normalizing unfolding SN_defs by blast
 
 
 subsection \<open>Ground Totality\<close>
 
 lemma ground_SCF [simp]:
   "ground (SCF t) = ground t"
 proof -
   have *: "\<forall>i<length xs. scf (f, length xs) i > 0"
     for f :: 'f and xs :: "('f, 'v) term list" using scf by simp
   show ?thesis by (induct t) (auto simp: set_scf_list [OF *])
 qed
 
 declare kbo.simps[simp del]
 
 lemma ground_vars_term_ms: "ground t \<Longrightarrow> vars_term_ms t = {#}"
   by (induct t) auto
 
 context
   fixes F :: "('f \<times> nat) set"
   assumes pr_weak: "pr_weak = pr_strict\<^sup>=\<^sup>="
     and pr_gtotal: "\<And>f g. f \<in> F \<Longrightarrow> g \<in> F \<Longrightarrow> f = g \<or> pr_strict f g \<or> pr_strict g f"
 begin
 
 lemma S_ground_total:
   assumes "funas_term s \<subseteq> F" and "ground s" and "funas_term t \<subseteq> F" and "ground t"
   shows "s = t \<or> S s t \<or> S t s"
   using assms
 proof (induct s arbitrary: t)
   case IH: (Fun f ss)
   note [simp] = ground_vars_term_ms
   let ?s = "Fun f ss"
   have *: "(vars_term_ms (SCF t) \<subseteq># vars_term_ms (SCF ?s)) = True"
     "(vars_term_ms (SCF ?s) \<subseteq># vars_term_ms (SCF t)) = True"
     using \<open>ground ?s\<close> and \<open>ground t\<close> by (auto simp: scf)
   from IH(5) obtain g ts where t[simp]: "t = Fun g ts" by (cases t, auto)
   let ?t = "Fun g ts"
   let ?f = "(f, length ss)"
   let ?g = "(g, length ts)"
   from IH have f: "?f \<in> F" and g: "?g \<in> F" by auto
   {
     assume "\<not> ?case"
     note contra = this[unfolded kbo.simps[of ?s] kbo.simps[of t] *, unfolded t term.simps]
     from pr_gtotal[OF f g] contra have fg: "?f = ?g" by (auto split: if_splits)
     have IH: "\<forall>(s, t)\<in>set (zip ss ts). s = t \<or> S s t \<or> S t s"
       using IH by (auto elim!: in_set_zipE) blast
     from fg have len: "length ss = length ts" by auto
     from lex_ext_unbounded_total[OF IH NS_refl len] contra fg
     have False by (auto split: if_splits)
   }
   then show ?case by blast
 qed auto
 end
 
 
 subsection \<open>Summary\<close>
 
 text \<open>
   At this point we have shown well-foundedness @{thm [source] S_SN},
   transitivity and compatibility @{thm [source] S_trans NS_trans NS_S_compat S_NS_compat},
   closure under substitutions @{thm [source] S_subst NS_subst},
   closure under contexts @{thm [source] S_ctxt NS_ctxt},
   the subterm property @{thm [source] S_supt NS_supteq},
   reflexivity of the weak @{thm [source] NS_refl} and irreflexivity of the strict
   part @{thm [source] S_irrefl},
   and ground-totality @{thm [source] S_ground_total}.
 
   In particular, this allows us to show that KBO is an instance of
   strongly normalizing order pairs (@{locale SN_order_pair}).
 \<close>
 
 sublocale SN_order_pair "{(x, y). S x y}" "{(x, y). NS x y}"
   by (unfold_locales, insert NS_refl NS_trans S_trans S_SN NS_S_compat S_NS_compat)
     (auto simp: refl_on_def trans_def, blast+)
 end
 
 end
diff --git a/thys/Knuth_Bendix_Order/Term_Aux.thy b/thys/Knuth_Bendix_Order/Term_Aux.thy
--- a/thys/Knuth_Bendix_Order/Term_Aux.thy
+++ b/thys/Knuth_Bendix_Order/Term_Aux.thy
@@ -1,119 +1,119 @@
 section \<open>Auxiliaries\<close>
 
 theory Term_Aux
   imports
     Subterm_and_Context
     "HOL-Library.Multiset"
 begin
 
 text \<open>
   This theory contains material about terms that is required for KBO, 
   but does not belong to @{theory Knuth_Bendix_Order.Subterm_and_Context}.
 
   We plan to merge this material into the theory @{theory First_Order_Terms.Term}
   at some point.
 \<close>
 
 text \<open>The variables of a term as multiset.\<close>
 fun vars_term_ms :: "('f, 'v) term \<Rightarrow> 'v multiset"
   where
     "vars_term_ms (Var x) = {#x#}" |
-    "vars_term_ms (Fun f ts) = \<Union># (mset (map vars_term_ms ts))"
+    "vars_term_ms (Fun f ts) = \<Sum>\<^sub># (mset (map vars_term_ms ts))"
 
 lemma vars_term_ms_subst [simp]:
   "vars_term_ms (t \<cdot> \<sigma>) =
-    \<Union># (image_mset (\<lambda> x. vars_term_ms (\<sigma> x)) (vars_term_ms t))" (is "_ = ?V t")
+    \<Sum>\<^sub># (image_mset (\<lambda> x. vars_term_ms (\<sigma> x)) (vars_term_ms t))" (is "_ = ?V t")
 proof (induct t)
   case (Fun f ts)
   have IH: "map (\<lambda> t. vars_term_ms (t \<cdot> \<sigma>)) ts = map (\<lambda> t. ?V t) ts"
     by (rule map_cong[OF refl Fun])
   show ?case by (simp add: o_def IH, induct ts, auto)
 qed simp
 
 lemma vars_term_ms_subst_mono:
   assumes "vars_term_ms s \<subseteq># vars_term_ms t"
   shows "vars_term_ms (s \<cdot> \<sigma>) \<subseteq># vars_term_ms (t \<cdot> \<sigma>)"
 proof -
   from assms[unfolded mset_subset_eq_exists_conv] obtain u where t: "vars_term_ms t = vars_term_ms s + u" by auto
   show ?thesis unfolding vars_term_ms_subst unfolding t by auto
 qed
 
 lemma set_mset_vars_term_ms [simp]:
   "set_mset (vars_term_ms t) = vars_term t"
   by (induct t) auto
 
 text \<open>A term is called \<^emph>\<open>ground\<close> if it does not contain any variables.\<close>
 fun ground :: "('f, 'v) term \<Rightarrow> bool"
   where
     "ground (Var x) \<longleftrightarrow> False" |
     "ground (Fun f ts) \<longleftrightarrow> (\<forall>t \<in> set ts. ground t)"
 
 lemma ground_vars_term_empty:
   "ground t \<longleftrightarrow> vars_term t = {}"
   by (induct t) simp_all
 
 lemma ground_subst [simp]:
   "ground (t \<cdot> \<sigma>) \<longleftrightarrow> (\<forall>x \<in> vars_term t. ground (\<sigma> x))"
   by (induct t) simp_all
 
 lemma ground_subst_apply:
   assumes "ground t"
   shows "t \<cdot> \<sigma> = t"
 proof -
   have "t = t \<cdot> Var" by simp
   also have "\<dots> = t \<cdot> \<sigma>"
     by (rule term_subst_eq, insert assms[unfolded ground_vars_term_empty], auto)
   finally show ?thesis by simp
 qed
 
 text \<open>
   A \<^emph>\<open>signature\<close> is a set of function symbol/arity pairs, where the arity of a function symbol,
   denotes the number of arguments it expects.
 \<close>
 type_synonym 'f sig = "('f \<times> nat) set"
 
 text \<open>The set of all function symbol/ arity pairs occurring in a term.\<close>
 fun funas_term :: "('f, 'v) term \<Rightarrow> 'f sig"
   where
     "funas_term (Var _) = {}" |
     "funas_term (Fun f ts) = {(f, length ts)} \<union> \<Union>(set (map funas_term ts))"
 
 
 lemma supt_imp_funas_term_subset:
   assumes "s \<rhd> t"
   shows "funas_term t \<subseteq> funas_term s"
   using assms by (induct) auto
 
 lemma supteq_imp_funas_term_subset[simp]:
   assumes "s \<unrhd> t"
   shows "funas_term t \<subseteq> funas_term s"
   using assms by (induct) auto
 
 text \<open>The set of all function symbol/arity pairs occurring in a context.\<close>
 fun funas_ctxt :: "('f, 'v) ctxt \<Rightarrow> 'f sig"
   where
     "funas_ctxt Hole = {}" |
     "funas_ctxt (More f ss1 D ss2) = {(f, Suc (length (ss1 @ ss2)))}
      \<union> funas_ctxt D \<union> \<Union>(set (map funas_term (ss1 @ ss2)))"
 
 lemma funas_term_ctxt_apply [simp]:
   "funas_term (C\<langle>t\<rangle>) = funas_ctxt C \<union> funas_term t"
 proof (induct t)
   case (Var x) show ?case by (induct C) auto
 next
   case (Fun f ts) show ?case by (induct C arbitrary: f ts) auto
 qed
 
 lemma funas_term_subst:
   "funas_term (t \<cdot> \<sigma>) = funas_term t \<union> \<Union>(funas_term ` \<sigma> ` vars_term t)"
   by (induct t) auto
 
 lemma funas_ctxt_compose [simp]:
   "funas_ctxt (C \<circ>\<^sub>c D) = funas_ctxt C \<union> funas_ctxt D"
   by (induct C) auto
 
 lemma funas_ctxt_subst [simp]:
   "funas_ctxt (C \<cdot>\<^sub>c \<sigma>) = funas_ctxt C \<union> \<Union>(funas_term ` \<sigma> ` vars_ctxt C)"
   by (induct C, auto simp: funas_term_subst)
 
 end
diff --git a/thys/Lambda_Free_RPOs/Lambda_Free_Term.thy b/thys/Lambda_Free_RPOs/Lambda_Free_Term.thy
--- a/thys/Lambda_Free_RPOs/Lambda_Free_Term.thy
+++ b/thys/Lambda_Free_RPOs/Lambda_Free_Term.thy
@@ -1,599 +1,599 @@
 (*  Title:       Lambda-Free Higher-Order Terms
     Author:      Jasmin Blanchette <jasmin.blanchette at inria.fr>, 2016
     Maintainer:  Jasmin Blanchette <jasmin.blanchette at inria.fr>
 *)
 
 section \<open>Lambda-Free Higher-Order Terms\<close>
 
 theory Lambda_Free_Term
 imports Lambda_Free_Util
 abbrevs ">s" = ">\<^sub>s"
   and ">h" = ">\<^sub>h\<^sub>d"
   and "\<le>\<ge>h" = "\<le>\<ge>\<^sub>h\<^sub>d"
 begin
 
 text \<open>
 This theory defines \<open>\<lambda>\<close>-free higher-order terms and related locales.
 \<close>
 
 
 subsection \<open>Precedence on Symbols\<close>
 
 locale gt_sym =
   fixes
     gt_sym :: "'s \<Rightarrow> 's \<Rightarrow> bool" (infix ">\<^sub>s" 50)
   assumes
     gt_sym_irrefl: "\<not> f >\<^sub>s f" and
     gt_sym_trans: "h >\<^sub>s g \<Longrightarrow> g >\<^sub>s f \<Longrightarrow> h >\<^sub>s f" and
     gt_sym_total: "f >\<^sub>s g \<or> g >\<^sub>s f \<or> g = f" and
     gt_sym_wf: "wfP (\<lambda>f g. g >\<^sub>s f)"
 begin
 
 lemma gt_sym_antisym: "f >\<^sub>s g \<Longrightarrow> \<not> g >\<^sub>s f"
   by (metis gt_sym_irrefl gt_sym_trans)
 
 end
 
 
 subsection \<open>Heads\<close>
 
 datatype (plugins del: size) (syms_hd: 's, vars_hd: 'v) hd =
   is_Var: Var (var: 'v)
 | Sym (sym: 's)
 
 abbreviation is_Sym :: "('s, 'v) hd \<Rightarrow> bool" where
   "is_Sym \<zeta> \<equiv> \<not> is_Var \<zeta>"
 
 lemma finite_vars_hd[simp]: "finite (vars_hd \<zeta>)"
   by (cases \<zeta>) auto
 
 lemma finite_syms_hd[simp]: "finite (syms_hd \<zeta>)"
   by (cases \<zeta>) auto
 
 
 subsection \<open>Terms\<close>
 
 consts head0 :: 'a
 
 datatype (syms: 's, vars: 'v) tm =
   is_Hd: Hd (head: "('s, 'v) hd")
 | App ("fun": "('s, 'v) tm") (arg: "('s, 'v) tm")
 where
   "head (App s _) = head0 s"
 | "fun (Hd \<zeta>) = Hd \<zeta>"
 | "arg (Hd \<zeta>) = Hd \<zeta>"
 
 overloading head0 \<equiv> "head0 :: ('s, 'v) tm \<Rightarrow> ('s, 'v) hd"
 begin
 
 primrec head0 :: "('s, 'v) tm \<Rightarrow> ('s, 'v) hd" where
   "head0 (Hd \<zeta>) = \<zeta>"
 | "head0 (App s _) = head0 s"
 
 end
 
 lemma head_App[simp]: "head (App s t) = head s"
   by (cases s) auto
 
 declare tm.sel(2)[simp del]
 
 lemma head_fun[simp]: "head (fun s) = head s"
   by (cases s) auto
 
 abbreviation ground :: "('s, 'v) tm \<Rightarrow> bool" where
   "ground t \<equiv> vars t = {}"
 
 abbreviation is_App :: "('s, 'v) tm \<Rightarrow> bool" where
   "is_App s \<equiv> \<not> is_Hd s"
 
 lemma
   size_fun_lt: "is_App s \<Longrightarrow> size (fun s) < size s" and
   size_arg_lt: "is_App s \<Longrightarrow> size (arg s) < size s"
   by (cases s; simp)+
 
 lemma
   finite_vars[simp]: "finite (vars s)" and
   finite_syms[simp]: "finite (syms s)"
   by (induct s) auto
 
 lemma
   vars_head_subseteq: "vars_hd (head s) \<subseteq> vars s" and
   syms_head_subseteq: "syms_hd (head s) \<subseteq> syms s"
   by (induct s) auto
 
 fun args :: "('s, 'v) tm \<Rightarrow> ('s, 'v) tm list" where
   "args (Hd _) = []"
 | "args (App s t) = args s @ [t]"
 
 lemma set_args_fun: "set (args (fun s)) \<subseteq> set (args s)"
   by (cases s) auto
 
 lemma arg_in_args: "is_App s \<Longrightarrow> arg s \<in> set (args s)"
   by (cases s rule: tm.exhaust) auto
 
 lemma
   vars_args_subseteq: "si \<in> set (args s) \<Longrightarrow> vars si \<subseteq> vars s" and
   syms_args_subseteq: "si \<in> set (args s) \<Longrightarrow> syms si \<subseteq> syms s"
   by (induct s) auto
 
 lemma args_Nil_iff_is_Hd: "args s = [] \<longleftrightarrow> is_Hd s"
   by (cases s) auto
 
 abbreviation num_args :: "('s, 'v) tm \<Rightarrow> nat" where
   "num_args s \<equiv> length (args s)"
 
 lemma size_ge_num_args: "size s \<ge> num_args s"
   by (induct s) auto
 
 lemma Hd_head_id: "num_args s = 0 \<Longrightarrow> Hd (head s) = s"
   by (metis args.cases args.simps(2) length_0_conv snoc_eq_iff_butlast tm.collapse(1) tm.disc(1))
 
 lemma one_arg_imp_Hd: "num_args s = 1 \<Longrightarrow> s = App t u \<Longrightarrow> t = Hd (head t)"
   by (simp add: Hd_head_id)
 
 lemma size_in_args: "s \<in> set (args t) \<Longrightarrow> size s < size t"
   by (induct t) auto
 
 primrec apps :: "('s, 'v) tm \<Rightarrow> ('s, 'v) tm list \<Rightarrow> ('s, 'v) tm" where
   "apps s [] = s"
 | "apps s (t # ts) = apps (App s t) ts"
 
 lemma
   vars_apps[simp]: "vars (apps s ss) = vars s \<union> (\<Union>s \<in> set ss. vars s)" and
   syms_apps[simp]: "syms (apps s ss) = syms s \<union> (\<Union>s \<in> set ss. syms s)" and
   head_apps[simp]: "head (apps s ss) = head s" and
   args_apps[simp]: "args (apps s ss) = args s @ ss" and
   is_App_apps[simp]: "is_App (apps s ss) \<longleftrightarrow> args (apps s ss) \<noteq> []" and
   fun_apps_Nil[simp]: "fun (apps s []) = fun s" and
   fun_apps_Cons[simp]: "fun (apps (App s sa) ss) = apps s (butlast (sa # ss))" and
   arg_apps_Nil[simp]: "arg (apps s []) = arg s" and
   arg_apps_Cons[simp]: "arg (apps (App s sa) ss) = last (sa # ss)"
   by (induct ss arbitrary: s sa) (auto simp: args_Nil_iff_is_Hd)
 
 lemma apps_append[simp]: "apps s (ss @ ts) = apps (apps s ss) ts"
   by (induct ss arbitrary: s ts) auto
 
 lemma App_apps: "App (apps s ts) t = apps s (ts @ [t])"
   by simp
 
 lemma tm_inject_apps[iff, induct_simp]: "apps (Hd \<zeta>) ss = apps (Hd \<xi>) ts \<longleftrightarrow> \<zeta> = \<xi> \<and> ss = ts"
   by (metis args_apps head_apps same_append_eq tm.sel(1))
 
 lemma tm_collapse_apps[simp]: "apps (Hd (head s)) (args s) = s"
   by (induct s) auto
 
 lemma tm_expand_apps: "head s = head t \<Longrightarrow> args s = args t \<Longrightarrow> s = t"
   by (metis tm_collapse_apps)
 
 lemma tm_exhaust_apps_sel[case_names apps]: "(s = apps (Hd (head s)) (args s) \<Longrightarrow> P) \<Longrightarrow> P"
   by (atomize_elim, induct s) auto
 
 lemma tm_exhaust_apps[case_names apps]: "(\<And>\<zeta> ss. s = apps (Hd \<zeta>) ss \<Longrightarrow> P) \<Longrightarrow> P"
   by (metis tm_collapse_apps)
 
 lemma tm_induct_apps[case_names apps]:
   assumes "\<And>\<zeta> ss. (\<And>s. s \<in> set ss \<Longrightarrow> P s) \<Longrightarrow> P (apps (Hd \<zeta>) ss)"
   shows "P s"
   using assms
   by (induct s taking: size rule: measure_induct_rule) (metis size_in_args tm_collapse_apps)
 
 lemma
   ground_fun: "ground s \<Longrightarrow> ground (fun s)" and
   ground_arg: "ground s \<Longrightarrow> ground (arg s)"
   by (induct s) auto
 
 lemma ground_head: "ground s \<Longrightarrow> is_Sym (head s)"
   by (cases s rule: tm_exhaust_apps) (auto simp: is_Var_def)
 
 lemma ground_args: "t \<in> set (args s) \<Longrightarrow> ground s \<Longrightarrow> ground t"
   by (induct s rule: tm_induct_apps) auto
 
 primrec vars_mset :: "('s, 'v) tm \<Rightarrow> 'v multiset" where
   "vars_mset (Hd \<zeta>) = mset_set (vars_hd \<zeta>)"
 | "vars_mset (App s t) = vars_mset s + vars_mset t"
 
 lemma set_vars_mset[simp]: "set_mset (vars_mset t) = vars t"
   by (induct t) auto
 
 lemma vars_mset_empty_iff[iff]: "vars_mset s = {#} \<longleftrightarrow> ground s"
   by (induct s) (auto simp: mset_set_empty_iff)
 
 lemma vars_mset_fun[intro]: "vars_mset (fun t) \<subseteq># vars_mset t"
   by (cases t) auto
 
 lemma vars_mset_arg[intro]: "vars_mset (arg t) \<subseteq># vars_mset t"
   by (cases t) auto
 
 
 subsection \<open>hsize\<close>
 
 text \<open>The hsize of a term is the number of heads (Syms or Vars) in the term.\<close>
 
 primrec hsize :: "('s, 'v) tm \<Rightarrow> nat" where
   "hsize (Hd \<zeta>) = 1"
 | "hsize (App s t) = hsize s + hsize t"
 
 lemma hsize_size: "hsize t * 2 = size t + 1"
   by (induct t) auto
 
 lemma hsize_pos[simp]: "hsize t > 0"
   by (induction t; simp)
 
 lemma hsize_fun_lt: "is_App s \<Longrightarrow> hsize (fun s) < hsize s"
   by (cases s; simp)
 
 lemma hsize_arg_lt: "is_App s \<Longrightarrow> hsize (arg s) < hsize s"
   by (cases s; simp)
   
 lemma hsize_ge_num_args: "hsize s \<ge> hsize s"
   by (induct s) auto
 
 lemma hsize_in_args: "s \<in> set (args t) \<Longrightarrow> hsize s < hsize t"
   by (induct t) auto
 
 lemma hsize_apps: "hsize (apps t ts) = hsize t + sum_list (map hsize ts)"
   by (induct ts arbitrary:t; simp)
 
 lemma hsize_args: "1 + sum_list (map hsize (args t)) = hsize t"
   by (metis hsize.simps(1) hsize_apps tm_collapse_apps)
 
 
 subsection \<open>Substitutions\<close>
 
 primrec subst :: "('v \<Rightarrow> ('s, 'v) tm) \<Rightarrow> ('s, 'v) tm \<Rightarrow> ('s, 'v) tm" where
   "subst \<rho> (Hd \<zeta>) = (case \<zeta> of Var x \<Rightarrow> \<rho> x | Sym f \<Rightarrow> Hd (Sym f))"
 | "subst \<rho> (App s t) = App (subst \<rho> s) (subst \<rho> t)"
 
 lemma subst_apps[simp]: "subst \<rho> (apps s ts) = apps (subst \<rho> s) (map (subst \<rho>) ts)"
   by (induct ts arbitrary: s) auto
 
 lemma head_subst[simp]: "head (subst \<rho> s) = head (subst \<rho> (Hd (head s)))"
   by (cases s rule: tm_exhaust_apps) (auto split: hd.split)
 
 lemma args_subst[simp]:
   "args (subst \<rho> s) = (case head s of Var x \<Rightarrow> args (\<rho> x) | Sym f \<Rightarrow> []) @ map (subst \<rho>) (args s)"
   by (cases s rule: tm_exhaust_apps) (auto split: hd.split)
 
 lemma ground_imp_subst_iden: "ground s \<Longrightarrow> subst \<rho> s = s"
   by (induct s) (auto split: hd.split)
 
-lemma vars_mset_subst[simp]: "vars_mset (subst \<rho> s) = (\<Union># {#vars_mset (\<rho> x). x \<in># vars_mset s#})"
+lemma vars_mset_subst[simp]: "vars_mset (subst \<rho> s) = (\<Sum>\<^sub># {#vars_mset (\<rho> x). x \<in># vars_mset s#})"
 proof (induct s)
   case (Hd \<zeta>)
   show ?case
     by (cases \<zeta>) auto
 qed auto
 
 lemma vars_mset_subst_subseteq:
   "vars_mset t \<supseteq># vars_mset s \<Longrightarrow> vars_mset (subst \<rho> t) \<supseteq># vars_mset (subst \<rho> s)"
   unfolding vars_mset_subst
   by (metis (no_types) add_diff_cancel_right' diff_subset_eq_self image_mset_union sum_mset.union
     subset_mset.add_diff_inverse)
 
 lemma vars_subst_subseteq: "vars t \<supseteq> vars s \<Longrightarrow> vars (subst \<rho> t) \<supseteq> vars (subst \<rho> s)"
   unfolding set_vars_mset[symmetric] vars_mset_subst by auto
 
 
 subsection \<open>Subterms\<close>
 
 inductive sub :: "('s, 'v) tm \<Rightarrow> ('s, 'v) tm \<Rightarrow> bool" where
   sub_refl: "sub s s"
 | sub_fun: "sub s t \<Longrightarrow> sub s (App u t)"
 | sub_arg: "sub s t \<Longrightarrow> sub s (App t u)"
 
 inductive_cases sub_HdE[simplified, elim]: "sub s (Hd \<xi>)"
 inductive_cases sub_AppE[simplified, elim]: "sub s (App t u)"
 inductive_cases sub_Hd_HdE[simplified, elim]: "sub (Hd \<zeta>) (Hd \<xi>)"
 inductive_cases sub_Hd_AppE[simplified, elim]: "sub (Hd \<zeta>) (App t u)"
 
 lemma in_vars_imp_sub: "x \<in> vars s \<longleftrightarrow> sub (Hd (Var x)) s"
   by induct (auto intro: sub.intros elim: hd.set_cases(2))
 
 lemma sub_args: "s \<in> set (args t) \<Longrightarrow> sub s t"
   by (induct t) (auto intro: sub.intros)
 
 lemma sub_size: "sub s t \<Longrightarrow> size s \<le> size t"
   by induct auto
 
 lemma sub_subst: "sub s t \<Longrightarrow> sub (subst \<rho> s) (subst \<rho> t)"
 proof (induct t)
   case (Hd \<zeta>)
   thus ?case
     by (cases \<zeta>; blast intro: sub.intros)
 qed (auto intro: sub.intros del: sub_AppE elim!: sub_AppE)
 
 abbreviation proper_sub :: "('s, 'v) tm \<Rightarrow> ('s, 'v) tm \<Rightarrow> bool" where
   "proper_sub s t \<equiv> sub s t \<and> s \<noteq> t"
 
 lemma proper_sub_Hd[simp]: "\<not> proper_sub s (Hd \<zeta>)"
   using sub.cases by blast
 
 lemma proper_sub_subst:
   assumes psub: "proper_sub s t"
   shows "proper_sub (subst \<rho> s) (subst \<rho> t)"
 proof (cases t)
   case Hd
   thus ?thesis
     using psub by simp
 next
   case t: (App t1 t2)
   have "sub s t1 \<or> sub s t2"
     using t psub by blast
   hence "sub (subst \<rho> s) (subst \<rho> t1) \<or> sub (subst \<rho> s) (subst \<rho> t2)"
     using sub_subst by blast
   thus ?thesis
     unfolding t by (auto intro: sub.intros dest: sub_size)
 qed
 
 
 subsection \<open>Maximum Arities\<close>
 
 locale arity =
   fixes
     arity_sym :: "'s \<Rightarrow> enat" and
     arity_var :: "'v \<Rightarrow> enat"
 begin
 
 primrec arity_hd :: "('s, 'v) hd \<Rightarrow> enat" where
   "arity_hd (Var x) = arity_var x"
 | "arity_hd (Sym f) = arity_sym f"
 
 definition arity :: "('s, 'v) tm \<Rightarrow> enat" where
   "arity s = arity_hd (head s) - num_args s"
 
 lemma arity_simps[simp]:
   "arity (Hd \<zeta>) = arity_hd \<zeta>"
   "arity (App s t) = arity s - 1"
   by (auto simp: arity_def enat_diff_diff_eq add.commute eSuc_enat plus_1_eSuc(1))
 
 lemma arity_apps[simp]: "arity (apps s ts) = arity s - length ts"
 proof (induct ts arbitrary: s)
   case (Cons t ts)
   thus ?case
     by (case_tac "arity s"; simp add: one_enat_def)
 qed simp
 
 inductive wary :: "('s, 'v) tm \<Rightarrow> bool" where
   wary_Hd[intro]: "wary (Hd \<zeta>)"
 | wary_App[intro]: "wary s \<Longrightarrow> wary t \<Longrightarrow> num_args s < arity_hd (head s) \<Longrightarrow> wary (App s t)"
 
 inductive_cases wary_HdE: "wary (Hd \<zeta>)"
 inductive_cases wary_AppE: "wary (App s t)"
 inductive_cases wary_binaryE[simplified]: "wary (App (App s t) u)"
 
 lemma wary_fun[intro]: "wary t \<Longrightarrow> wary (fun t)"
   by (cases t) (auto elim: wary.cases)
 
 lemma wary_arg[intro]: "wary t \<Longrightarrow> wary (arg t)"
   by (cases t) (auto elim: wary.cases)
 
 lemma wary_args: "s \<in> set (args t) \<Longrightarrow> wary t \<Longrightarrow> wary s"
   by (induct t arbitrary: s, simp)
    (metis Un_iff args.simps(2) wary.cases insert_iff length_pos_if_in_set
       less_numeral_extra(3) list.set(2) list.size(3) set_append tm.distinct(1) tm.inject(2))
 
 lemma wary_sub: "sub s t \<Longrightarrow> wary t \<Longrightarrow> wary s"
   by (induct rule: sub.induct) (auto elim: wary.cases)
 
 lemma wary_inf_ary: "(\<And>\<zeta>. arity_hd \<zeta> = \<infinity>) \<Longrightarrow> wary s"
   by induct auto
 
 lemma wary_num_args_le_arity_head: "wary s \<Longrightarrow> num_args s \<le> arity_hd (head s)"
   by (induct rule: wary.induct) (auto simp: zero_enat_def[symmetric] Suc_ile_eq)
 
 lemma wary_apps:
   "wary s \<Longrightarrow> (\<And>sa. sa \<in> set ss \<Longrightarrow> wary sa) \<Longrightarrow> length ss \<le> arity s \<Longrightarrow> wary (apps s ss)"
 proof (induct ss arbitrary: s)
   case (Cons sa ss)
   note ih = this(1) and wary_s = this(2) and wary_ss = this(3) and nargs_s_sa_ss = this(4)
   show ?case
     unfolding apps.simps
   proof (rule ih)
     have "wary sa"
       using wary_ss by simp
     moreover have " enat (num_args s) < arity_hd (head s)"
       by (metis (mono_tags) One_nat_def add.comm_neutral arity_def diff_add_zero enat_ord_simps(1)
         idiff_enat_enat less_one list.size(4) nargs_s_sa_ss not_add_less2
         order.not_eq_order_implies_strict wary_num_args_le_arity_head wary_s)
     ultimately show "wary (App s sa)"
       by (rule wary_App[OF wary_s])
   next
     show "\<And>sa. sa \<in> set ss \<Longrightarrow> wary sa"
       using wary_ss by simp
   next
     show "length ss \<le> arity (App s sa)"
     proof (cases "arity s")
       case enat
       thus ?thesis
         using nargs_s_sa_ss by (simp add: one_enat_def)
     qed simp
   qed
 qed simp
 
 lemma wary_cases_apps[consumes 1, case_names apps]:
   assumes
     wary_t: "wary t" and
     apps: "\<And>\<zeta> ss. t = apps (Hd \<zeta>) ss \<Longrightarrow> (\<And>sa. sa \<in> set ss \<Longrightarrow> wary sa) \<Longrightarrow> length ss \<le> arity_hd \<zeta> \<Longrightarrow> P"
   shows P
   using apps
 proof (atomize_elim, cases t rule: tm_exhaust_apps)
   case t: (apps \<zeta> ss)
   show "\<exists>\<zeta> ss. t = apps (Hd \<zeta>) ss \<and> (\<forall>sa. sa \<in> set ss \<longrightarrow> wary sa) \<and> enat (length ss) \<le> arity_hd \<zeta>"
     by (rule exI[of _ \<zeta>], rule exI[of _ ss])
       (auto simp: t wary_args[OF _ wary_t] wary_num_args_le_arity_head[OF wary_t, unfolded t, simplified])
 qed
 
 lemma arity_hd_head: "wary s \<Longrightarrow> arity_hd (head s) = arity s + num_args s"
   by (simp add: arity_def enat_sub_add_same wary_num_args_le_arity_head)
 
 lemma arity_head_ge: "arity_hd (head s) \<ge> arity s"
   by (induct s) (auto intro: enat_le_imp_minus_le)
 
 inductive wary_fo :: "('s, 'v) tm \<Rightarrow> bool" where
   wary_foI[intro]: "is_Hd s \<or> is_Sym (head s) \<Longrightarrow> length (args s) = arity_hd (head s) \<Longrightarrow>
     (\<forall>t \<in> set (args s). wary_fo t) \<Longrightarrow> wary_fo s"
 
 lemma wary_fo_args: "s \<in> set (args t) \<Longrightarrow> wary_fo t \<Longrightarrow> wary_fo s"
   by (induct t arbitrary: s rule: tm_induct_apps, simp)
     (metis args.simps(1) args_apps self_append_conv2 wary_fo.cases)
 
 lemma wary_fo_arg: "wary_fo (App s t) \<Longrightarrow> wary_fo t"
   by (erule wary_fo.cases) auto
 
 end
 
 
 subsection \<open>Potential Heads of Ground Instances of Variables\<close>
 
 locale ground_heads = gt_sym "(>\<^sub>s)" + arity arity_sym arity_var
     for
       gt_sym :: "'s \<Rightarrow> 's \<Rightarrow> bool" (infix ">\<^sub>s" 50) and
       arity_sym :: "'s \<Rightarrow> enat" and
       arity_var :: "'v \<Rightarrow> enat" +
   fixes
     ground_heads_var :: "'v \<Rightarrow> 's set"
   assumes
     ground_heads_var_arity: "f \<in> ground_heads_var x \<Longrightarrow> arity_sym f \<ge> arity_var x" and
     ground_heads_var_nonempty: "ground_heads_var x \<noteq> {}"
 begin
 
 primrec ground_heads :: "('s, 'v) hd \<Rightarrow> 's set" where
   "ground_heads (Var x) = ground_heads_var x"
 | "ground_heads (Sym f) = {f}"
 
 lemma ground_heads_arity: "f \<in> ground_heads \<zeta> \<Longrightarrow> arity_sym f \<ge> arity_hd \<zeta>"
   by (cases \<zeta>) (auto simp: ground_heads_var_arity)
 
 lemma ground_heads_nonempty[simp]: "ground_heads \<zeta> \<noteq> {}"
   by (cases \<zeta>) (auto simp: ground_heads_var_nonempty)
 
 lemma sym_in_ground_heads: "is_Sym \<zeta> \<Longrightarrow> sym \<zeta> \<in> ground_heads \<zeta>"
   by (metis ground_heads.simps(2) hd.collapse(2) hd.set_sel(1) hd.simps(16))
 
 lemma ground_hd_in_ground_heads: "ground s \<Longrightarrow> sym (head s) \<in> ground_heads (head s)"
   by (simp add: ground_head sym_in_ground_heads)
 
 lemma some_ground_head_arity: "arity_sym (SOME f. f \<in> ground_heads (Var x)) \<ge> arity_var x"
   by (simp add: ground_heads_var_arity ground_heads_var_nonempty some_in_eq)
 
 definition wary_subst :: "('v \<Rightarrow> ('s, 'v) tm) \<Rightarrow> bool" where
   "wary_subst \<rho> \<longleftrightarrow>
    (\<forall>x. wary (\<rho> x) \<and> arity (\<rho> x) \<ge> arity_var x \<and> ground_heads (head (\<rho> x)) \<subseteq> ground_heads_var x)"
 
 definition strict_wary_subst :: "('v \<Rightarrow> ('s, 'v) tm) \<Rightarrow> bool" where
   "strict_wary_subst \<rho> \<longleftrightarrow>
    (\<forall>x. wary (\<rho> x) \<and> arity (\<rho> x) \<in> {arity_var x, \<infinity>}
     \<and> ground_heads (head (\<rho> x)) \<subseteq> ground_heads_var x)"
 
 lemma strict_imp_wary_subst: "strict_wary_subst \<rho> \<Longrightarrow> wary_subst \<rho>"
   unfolding strict_wary_subst_def wary_subst_def using eq_iff by force
 
 lemma wary_subst_wary:
   assumes wary_\<rho>: "wary_subst \<rho>" and wary_s: "wary s"
   shows "wary (subst \<rho> s)"
   using wary_s
 proof (induct s rule: tm.induct)
   case (App s t)
   note wary_st = this(3)
   from wary_st have wary_s: "wary s"
     by (rule wary_AppE)
   from wary_st have wary_t: "wary t"
     by (rule wary_AppE)
   from wary_st have nargs_s_lt: "num_args s < arity_hd (head s)"
     by (rule wary_AppE)
 
   note wary_\<rho>s = App(1)[OF wary_s]
   note wary_\<rho>t = App(2)[OF wary_t]
 
   note wary_\<rho>x = wary_\<rho>[unfolded wary_subst_def, rule_format, THEN conjunct1]
   note ary_\<rho>x = wary_\<rho>[unfolded wary_subst_def, rule_format, THEN conjunct2]
 
   have "num_args (\<rho> x) + num_args s < arity_hd (head (\<rho> x))" if hd_s: "head s = Var x" for x
   proof -
     have ary_hd_s: "arity_hd (head s) = arity_var x"
       using hd_s arity_hd.simps(1) by presburger
     hence "num_args s \<le> arity (\<rho> x)"
       by (metis (no_types) wary_num_args_le_arity_head ary_\<rho>x dual_order.trans wary_s)
     hence "num_args s + num_args (\<rho> x) \<le> arity_hd (head (\<rho> x))"
       by (metis (no_types) arity_hd_head[OF wary_\<rho>x] add_right_mono plus_enat_simps(1))
     thus ?thesis
       using ary_hd_s by (metis (no_types) add.commute add_diff_cancel_left' ary_\<rho>x arity_def
         idiff_enat_enat leD nargs_s_lt order.not_eq_order_implies_strict)
   qed
   hence nargs_\<rho>s: "num_args (subst \<rho> s) < arity_hd (head (subst \<rho> s))"
     using nargs_s_lt by (auto split: hd.split)
 
   show ?case
     by simp (rule wary_App[OF wary_\<rho>s wary_\<rho>t nargs_\<rho>s])
 qed (auto simp: wary_\<rho>[unfolded wary_subst_def] split: hd.split)
 
 lemmas strict_wary_subst_wary = wary_subst_wary[OF strict_imp_wary_subst]
 
 lemma wary_subst_ground_heads:
   assumes wary_\<rho>: "wary_subst \<rho>"
   shows "ground_heads (head (subst \<rho> s)) \<subseteq> ground_heads (head s)"
 proof (induct s rule: tm_induct_apps)
   case (apps \<zeta> ss)
   show ?case
   proof (cases \<zeta>)
     case x: (Var x)
     thus ?thesis
       using wary_\<rho> wary_subst_def x by auto
   qed auto
 qed
 
 lemmas strict_wary_subst_ground_heads = wary_subst_ground_heads[OF strict_imp_wary_subst]
 
 definition grounding_\<rho> :: "'v \<Rightarrow> ('s, 'v) tm" where
   "grounding_\<rho> x = (let s = Hd (Sym (SOME f. f \<in> ground_heads_var x)) in
      apps s (replicate (the_enat (arity s - arity_var x)) s))"
 
 lemma ground_grounding_\<rho>: "ground (subst grounding_\<rho> s)"
   by (induct s) (auto simp: Let_def grounding_\<rho>_def elim: hd.set_cases(2) split: hd.split)
 
 lemma strict_wary_grounding_\<rho>: "strict_wary_subst grounding_\<rho>"
   unfolding strict_wary_subst_def
 proof (intro allI conjI)
   fix x
 
   define f where "f = (SOME f. f \<in> ground_heads_var x)"
   define s :: "('s, 'v) tm" where "s = Hd (Sym f)"
 
   have wary_s: "wary s"
     unfolding s_def by (rule wary_Hd)
   have ary_s_ge_x: "arity s \<ge> arity_var x"
     unfolding s_def f_def using some_ground_head_arity by simp
   have gr\<rho>_x: "grounding_\<rho> x = apps s (replicate (the_enat (arity s - arity_var x)) s)"
     unfolding grounding_\<rho>_def Let_def f_def[symmetric] s_def[symmetric] by (rule refl)
 
   show "wary (grounding_\<rho> x)"
     unfolding gr\<rho>_x by (auto intro!: wary_s wary_apps[OF wary_s] enat_the_enat_minus_le)
   show "arity (grounding_\<rho> x) \<in> {arity_var x, \<infinity>}"
     unfolding gr\<rho>_x using ary_s_ge_x by (cases "arity s"; cases "arity_var x"; simp)
   show "ground_heads (head (grounding_\<rho> x)) \<subseteq> ground_heads_var x"
     unfolding gr\<rho>_x s_def f_def by (simp add: some_in_eq ground_heads_var_nonempty)
 qed
 
 lemmas wary_grounding_\<rho> = strict_wary_grounding_\<rho>[THEN strict_imp_wary_subst]
 
 definition gt_hd :: "('s, 'v) hd \<Rightarrow> ('s, 'v) hd \<Rightarrow> bool" (infix ">\<^sub>h\<^sub>d" 50) where
   "\<xi> >\<^sub>h\<^sub>d \<zeta> \<longleftrightarrow> (\<forall>g \<in> ground_heads \<xi>. \<forall>f \<in> ground_heads \<zeta>. g >\<^sub>s f)"
 
 definition comp_hd :: "('s, 'v) hd \<Rightarrow> ('s, 'v) hd \<Rightarrow> bool" (infix "\<le>\<ge>\<^sub>h\<^sub>d" 50) where
   "\<xi> \<le>\<ge>\<^sub>h\<^sub>d \<zeta> \<longleftrightarrow> \<xi> = \<zeta> \<or> \<xi> >\<^sub>h\<^sub>d \<zeta> \<or> \<zeta> >\<^sub>h\<^sub>d \<xi>"
 
 lemma gt_hd_irrefl: "\<not> \<zeta> >\<^sub>h\<^sub>d \<zeta>"
   unfolding gt_hd_def using gt_sym_irrefl by (meson ex_in_conv ground_heads_nonempty)
 
 lemma gt_hd_trans: "\<chi> >\<^sub>h\<^sub>d \<xi> \<Longrightarrow> \<xi> >\<^sub>h\<^sub>d \<zeta> \<Longrightarrow> \<chi> >\<^sub>h\<^sub>d \<zeta>"
   unfolding gt_hd_def using gt_sym_trans by (meson ex_in_conv ground_heads_nonempty)
 
 lemma gt_sym_imp_hd: "g >\<^sub>s f \<Longrightarrow> Sym g >\<^sub>h\<^sub>d Sym f"
   unfolding gt_hd_def by simp
 
 lemma not_comp_hd_imp_Var: "\<not> \<xi> \<le>\<ge>\<^sub>h\<^sub>d \<zeta> \<Longrightarrow> is_Var \<zeta> \<or> is_Var \<xi>"
   using gt_sym_total by (cases \<zeta>; cases \<xi>; auto simp: comp_hd_def gt_hd_def)
 
 end
 
 end
diff --git a/thys/Nested_Multisets_Ordinals/Multiset_More.thy b/thys/Nested_Multisets_Ordinals/Multiset_More.thy
--- a/thys/Nested_Multisets_Ordinals/Multiset_More.thy
+++ b/thys/Nested_Multisets_Ordinals/Multiset_More.thy
@@ -1,1032 +1,1032 @@
 (*  Title:       More about Multisets
     Author:      Mathias Fleury <mathias.fleury at mpi-inf.mpg.de>, 2015
     Author:      Jasmin Blanchette <blanchette at in.tum.de>, 2014, 2015
     Author:      Anders Schlichtkrull <andschl at dtu.dk>, 2017
     Author:      Dmitriy Traytel <traytel at in.tum.de>, 2014
     Maintainer:  Mathias Fleury <mathias.fleury at mpi-inf.mpg.de>
 *)
 
 section \<open>More about Multisets\<close>
 
 theory Multiset_More
   imports
     "HOL-Library.Multiset_Order"
     "HOL-Library.Sublist"
 begin
 
 text \<open>
 Isabelle's theory of finite multisets is not as developed as other areas, such as lists and sets.
 The present theory introduces some missing concepts and lemmas. Some of it is expected to move to
 Isabelle's library.
 \<close>
 
 
 subsection \<open>Basic Setup\<close>
 
 declare
   diff_single_trivial [simp]
   in_image_mset [iff]
   image_mset.compositionality [simp]
 
   (*To have the same rules as the set counter-part*)
   mset_subset_eqD[dest, intro?] (*@{thm subsetD}*)
 
   Multiset.in_multiset_in_set[simp]
   inter_add_left1[simp]
   inter_add_left2[simp]
   inter_add_right1[simp]
   inter_add_right2[simp]
 
   sum_mset_sum_list[simp]
 
 
 subsection \<open>Lemmas about Intersection, Union and Pointwise Inclusion\<close>
 
 lemma subset_mset_imp_subset_add_mset: "A \<subseteq># B \<Longrightarrow> A \<subseteq># add_mset x B"
   by (metis add_mset_diff_bothsides diff_subset_eq_self multiset_inter_def subset_mset.inf.absorb2)
 
 lemma subset_add_mset_notin_subset_mset: \<open>A \<subseteq># add_mset b B \<Longrightarrow> b \<notin># A \<Longrightarrow> A \<subseteq># B\<close>
   by (simp add: subset_mset.le_iff_sup)
 
 lemma subset_msetE: "\<lbrakk>A \<subset># B; \<lbrakk>A \<subseteq># B; \<not> B \<subseteq># A\<rbrakk> \<Longrightarrow> R\<rbrakk> \<Longrightarrow> R"
   by (simp add: subset_mset.less_le_not_le)
 
 lemma Diff_triv_mset: "M \<inter># N = {#} \<Longrightarrow> M - N = M"
   by (metis diff_intersect_left_idem diff_zero)
 
 lemma diff_intersect_sym_diff: "(A - B) \<inter># (B - A) = {#}"
   unfolding multiset_inter_def
 proof -
   have "A - (B - (B - A)) = A - B"
     by (metis diff_intersect_right_idem multiset_inter_def)
   then show "A - B - (A - B - (B - A)) = {#}"
     by (metis diff_add diff_cancel diff_subset_eq_self subset_mset.diff_add)
 qed
 
 declare subset_msetE [elim!]
 
 lemma subseq_mset_subseteq_mset: "subseq xs ys \<Longrightarrow> mset xs \<subseteq># mset ys"
 proof (induct xs arbitrary: ys)
   case (Cons x xs)
   note Outer_Cons = this
   then show ?case
   proof (induct ys)
     case (Cons y ys)
     have "subseq xs ys"
       by (metis Cons.prems(2) subseq_Cons' subseq_Cons2_iff)
     then show ?case
       using Cons by (metis mset.simps(2) mset_subset_eq_add_mset_cancel subseq_Cons2_iff
           subset_mset_imp_subset_add_mset)
   qed simp
 qed simp
 
 
 subsection \<open>Lemmas about Filter and Image\<close>
 
 lemma count_image_mset_ge_count: "count (image_mset f A) (f b) \<ge> count A b"
   by (induction A) auto
 
 lemma count_image_mset_inj:
   assumes \<open>inj f\<close>
   shows \<open>count (image_mset f M) (f x) = count M x\<close>
   by (induct M) (use assms in \<open>auto simp: inj_on_def\<close>)
 
 lemma count_image_mset_le_count_inj_on:
   "inj_on f (set_mset M) \<Longrightarrow> count (image_mset f M) y \<le> count M (inv_into (set_mset M) f y)"
 proof (induct M)
   case (add x M)
   note ih = this(1) and inj_xM = this(2)
 
   have inj_M: "inj_on f (set_mset M)"
     using inj_xM by simp
 
   show ?case
   proof (cases "x \<in># M")
     case x_in_M: True
     show ?thesis
     proof (cases "y = f x")
       case y_eq_fx: True
       show ?thesis
         using x_in_M ih[OF inj_M] unfolding y_eq_fx by (simp add: inj_M insert_absorb)
     next
       case y_ne_fx: False
       show ?thesis
         using x_in_M ih[OF inj_M] y_ne_fx insert_absorb by fastforce
     qed
   next
     case x_ni_M: False
     show ?thesis
     proof (cases "y = f x")
       case y_eq_fx: True
       have "f x \<notin># image_mset f M"
         using x_ni_M inj_xM by force
       thus ?thesis
         unfolding y_eq_fx
         by (metis (no_types) inj_xM count_add_mset count_greater_eq_Suc_zero_iff count_inI
           image_mset_add_mset inv_into_f_f union_single_eq_member)
     next
       case y_ne_fx: False
       show ?thesis
       proof (rule ccontr)
         assume neg_conj: "\<not> count (image_mset f (add_mset x M)) y
           \<le> count (add_mset x M) (inv_into (set_mset (add_mset x M)) f y)"
 
         have cnt_y: "count (add_mset (f x) (image_mset f M)) y = count (image_mset f M) y"
           using y_ne_fx by simp
 
         have "inv_into (set_mset M) f y \<in># add_mset x M \<Longrightarrow>
           inv_into (set_mset (add_mset x M)) f (f (inv_into (set_mset M) f y)) =
           inv_into (set_mset M) f y"
           by (meson inj_xM inv_into_f_f)
         hence "0 < count (image_mset f (add_mset x M)) y \<Longrightarrow>
           count M (inv_into (set_mset M) f y) = 0 \<or> x = inv_into (set_mset M) f y"
           using neg_conj cnt_y ih[OF inj_M]
           by (metis (no_types) count_add_mset count_greater_zero_iff count_inI f_inv_into_f
             image_mset_add_mset set_image_mset)
         thus False
           using neg_conj cnt_y x_ni_M ih[OF inj_M]
           by (metis (no_types) count_greater_zero_iff count_inI eq_iff image_mset_add_mset
             less_imp_le)
       qed
     qed
   qed
 qed simp
 
 lemma mset_filter_compl: "mset (filter p xs) + mset (filter (Not \<circ> p) xs) = mset xs"
   by (induction xs) (auto simp: ac_simps)
 
 text \<open>Near duplicate of @{thm [source] filter_eq_replicate_mset}: @{thm filter_eq_replicate_mset}.\<close>
 
 lemma filter_mset_eq: "filter_mset ((=) L) A = replicate_mset (count A L) L"
   by (auto simp: multiset_eq_iff)
 
 lemma filter_mset_cong[fundef_cong]:
   assumes "M = M'" "\<And>a. a \<in># M \<Longrightarrow> P a = Q a"
   shows "filter_mset P M = filter_mset Q M"
 proof -
   have "M - filter_mset Q M = filter_mset (\<lambda>a. \<not>Q a) M"
     by (metis multiset_partition add_diff_cancel_left')
   then show ?thesis
     by (auto simp: filter_mset_eq_conv assms)
 qed
 
 lemma image_mset_filter_swap: "image_mset f {# x \<in># M. P (f x)#} = {# x \<in># image_mset f M. P x#}"
   by (induction M) auto
 
 lemma image_mset_cong2:
   "(\<And>x. x \<in># M \<Longrightarrow> f x = g x) \<Longrightarrow> M = N \<Longrightarrow> image_mset f M = image_mset g N"
   by (hypsubst, rule image_mset_cong)
 
 lemma filter_mset_empty_conv: \<open>(filter_mset P M = {#}) = (\<forall>L\<in>#M. \<not> P L)\<close>
   by (induction M) auto
 
 lemma multiset_filter_mono2: \<open>filter_mset P A \<subseteq># filter_mset Q A \<longleftrightarrow> (\<forall>a\<in>#A. P a \<longrightarrow> Q a)\<close>
   by (induction A) (auto intro: subset_mset.order.trans)
 
 lemma image_filter_cong:
   assumes \<open>\<And>C. C \<in># M \<Longrightarrow> P C \<Longrightarrow> f C = g C\<close>
   shows \<open>{#f C. C \<in># {#C \<in># M. P C#}#} = {#g C | C\<in># M. P C#}\<close>
   using assms by (induction M) auto
 
 lemma image_mset_filter_swap2: \<open>{#C \<in># {#P x. x \<in># D#}. Q C #} = {#P x. x \<in># {#C| C \<in># D. Q (P C)#}#}\<close>
   by (simp add: image_mset_filter_swap)
 
 declare image_mset_cong2 [cong]
 
 lemma filter_mset_empty_if_finite_and_filter_set_empty:
   assumes
     "{x \<in> X. P x} = {}" and
     "finite X"
   shows "{#x \<in># mset_set X. P x#} = {#}"
 proof -
   have empty_empty: "\<And>Y. set_mset Y = {} \<Longrightarrow> Y = {#}"
     by auto
   from assms have "set_mset {#x \<in># mset_set X. P x#} = {}"
     by auto
   then show ?thesis
     by (rule empty_empty)
 qed
 
 
 subsection \<open>Lemmas about Sum\<close>
 
 lemma sum_image_mset_sum_map[simp]: "sum_mset (image_mset f (mset xs)) = sum_list (map f xs)"
   by (metis mset_map sum_mset_sum_list)
 
 lemma sum_image_mset_mono:
   fixes f :: "'a \<Rightarrow> 'b::canonically_ordered_monoid_add"
   assumes sub: "A \<subseteq># B"
   shows "(\<Sum>m \<in># A. f m) \<le> (\<Sum>m \<in># B. f m)"
   by (metis image_mset_union le_iff_add sub subset_mset.add_diff_inverse sum_mset.union)
 
 lemma sum_image_mset_mono_mem:
   "n \<in># M \<Longrightarrow> f n \<le> (\<Sum>m \<in># M. f m)" for f :: "'a \<Rightarrow> 'b::canonically_ordered_monoid_add"
   using le_iff_add multi_member_split by fastforce
 
 lemma count_sum_mset_if_1_0: \<open>count M a = (\<Sum>x\<in>#M. if x = a then 1 else 0)\<close>
   by (induction M) auto
 
 lemma sum_mset_dvd:
   fixes k :: "'a::comm_semiring_1_cancel"
   assumes "\<forall>m \<in># M. k dvd f m"
   shows "k dvd (\<Sum>m \<in># M. f m)"
   using assms by (induct M) auto
 
 lemma sum_mset_distrib_div_if_dvd:
   fixes k :: "'a::unique_euclidean_semiring"
   assumes "\<forall>m \<in># M. k dvd f m"
   shows "(\<Sum>m \<in># M. f m) div k = (\<Sum>m \<in># M. f m div k)"
   using assms by (induct M) (auto simp: div_plus_div_distrib_dvd_left)
 
 
 subsection \<open>Lemmas about Remove\<close>
 
 lemma set_mset_minus_replicate_mset[simp]:
   "n \<ge> count A a \<Longrightarrow> set_mset (A - replicate_mset n a) = set_mset A - {a}"
   "n < count A a \<Longrightarrow> set_mset (A - replicate_mset n a) = set_mset A"
   unfolding set_mset_def by (auto split: if_split simp: not_in_iff)
 
 abbreviation removeAll_mset :: "'a \<Rightarrow> 'a multiset \<Rightarrow> 'a multiset" where
   "removeAll_mset C M \<equiv> M - replicate_mset (count M C) C"
 
 lemma mset_removeAll[simp, code]: "removeAll_mset C (mset L) = mset (removeAll C L)"
   by (induction L) (auto simp: ac_simps multiset_eq_iff split: if_split_asm)
 
 lemma removeAll_mset_filter_mset: "removeAll_mset C M = filter_mset ((\<noteq>) C) M"
   by (induction M) (auto simp: ac_simps multiset_eq_iff)
 
 abbreviation remove1_mset :: "'a \<Rightarrow> 'a multiset \<Rightarrow> 'a multiset" where
   "remove1_mset C M \<equiv> M - {#C#}"
 
 lemma removeAll_subseteq_remove1_mset: "removeAll_mset x M \<subseteq># remove1_mset x M"
   by (auto simp: subseteq_mset_def)
 
 lemma in_remove1_mset_neq:
   assumes ab: "a \<noteq> b"
   shows "a \<in># remove1_mset b C \<longleftrightarrow> a \<in># C"
   by (metis assms diff_single_trivial in_diffD insert_DiffM insert_noteq_member)
 
 lemma size_mset_removeAll_mset_le_iff: "size (removeAll_mset x M) < size M \<longleftrightarrow> x \<in># M"
   by (auto intro: count_inI mset_subset_size simp: subset_mset_def multiset_eq_iff)
 
 lemma size_remove1_mset_If: \<open>size (remove1_mset x M) = size M - (if x \<in># M then 1 else 0)\<close>
   by (auto simp: size_Diff_subset_Int)
 
 lemma size_mset_remove1_mset_le_iff: "size (remove1_mset x M) < size M \<longleftrightarrow> x \<in># M"
   using less_irrefl
   by (fastforce intro!: mset_subset_size elim: in_countE simp: subset_mset_def multiset_eq_iff)
 
 lemma remove_1_mset_id_iff_notin: "remove1_mset a M = M \<longleftrightarrow> a \<notin># M"
   by (meson diff_single_trivial multi_drop_mem_not_eq)
 
 lemma id_remove_1_mset_iff_notin: "M = remove1_mset a M \<longleftrightarrow> a \<notin># M"
   using remove_1_mset_id_iff_notin by metis
 
 lemma remove1_mset_eqE:
   "remove1_mset L x1 = M \<Longrightarrow>
     (L \<in># x1 \<Longrightarrow> x1 = M + {#L#} \<Longrightarrow> P) \<Longrightarrow>
     (L \<notin># x1 \<Longrightarrow> x1 = M \<Longrightarrow> P) \<Longrightarrow>
   P"
   by (cases "L \<in># x1") auto
 
 lemma image_filter_ne_mset[simp]:
   "image_mset f {#x \<in># M. f x \<noteq> y#} = removeAll_mset y (image_mset f M)"
   by (induction M) simp_all
 
 lemma image_mset_remove1_mset_if:
   "image_mset f (remove1_mset a M) =
    (if a \<in># M then remove1_mset (f a) (image_mset f M) else image_mset f M)"
   by (auto simp: image_mset_Diff)
 
 lemma filter_mset_neq: "{#x \<in># M. x \<noteq> y#} = removeAll_mset y M"
   by (metis add_diff_cancel_left' filter_eq_replicate_mset multiset_partition)
 
 lemma filter_mset_neq_cond: "{#x \<in># M. P x \<and> x \<noteq> y#} = removeAll_mset y {# x\<in>#M. P x#}"
   by (metis filter_filter_mset filter_mset_neq)
 
 lemma remove1_mset_add_mset_If:
   "remove1_mset L (add_mset L' C) = (if L = L' then C else remove1_mset L C + {#L'#})"
   by (auto simp: multiset_eq_iff)
 
 lemma minus_remove1_mset_if:
   "A - remove1_mset b B = (if b \<in># B \<and> b \<in># A \<and> count A b \<ge> count B b then {#b#} + (A - B) else A - B)"
   by (auto simp: multiset_eq_iff count_greater_zero_iff[symmetric]
     simp del: count_greater_zero_iff)
 
 lemma add_mset_eq_add_mset_ne:
   "a \<noteq> b \<Longrightarrow> add_mset a A = add_mset b B \<longleftrightarrow> a \<in># B \<and> b \<in># A \<and> A = add_mset b (B - {#a#})"
   by (metis (no_types, lifting) diff_single_eq_union diff_union_swap multi_self_add_other_not_self
     remove_1_mset_id_iff_notin union_single_eq_diff)
 
 lemma add_mset_eq_add_mset: \<open>add_mset a M = add_mset b M' \<longleftrightarrow>
   (a = b \<and> M = M') \<or> (a \<noteq> b \<and> b \<in># M \<and> add_mset a (M - {#b#}) = M')\<close>
   by (metis add_mset_eq_add_mset_ne add_mset_remove_trivial union_single_eq_member)
 
 (* TODO move to Multiset: could replace add_mset_remove_trivial_eq? *)
 lemma add_mset_remove_trivial_iff: \<open>N = add_mset a (N - {#b#}) \<longleftrightarrow> a \<in># N \<and> a = b\<close>
   by (metis add_left_cancel add_mset_remove_trivial insert_DiffM2 single_eq_single
       size_mset_remove1_mset_le_iff union_single_eq_member)
 
 lemma trivial_add_mset_remove_iff: \<open>add_mset a (N - {#b#}) = N \<longleftrightarrow> a \<in># N \<and> a = b\<close>
   by (subst eq_commute) (fact add_mset_remove_trivial_iff)
 
 lemma remove1_single_empty_iff[simp]: \<open>remove1_mset L {#L'#} = {#} \<longleftrightarrow> L = L'\<close>
   using add_mset_remove_trivial_iff by fastforce
 
 lemma add_mset_less_imp_less_remove1_mset:
   assumes xM_lt_N: "add_mset x M < N"
   shows "M < remove1_mset x N"
 proof -
   have "M < N"
     using assms le_multiset_right_total mset_le_trans by blast
   then show ?thesis
     by (metis add_less_cancel_right add_mset_add_single diff_single_trivial insert_DiffM2 xM_lt_N)
 qed
 
 
 subsection \<open>Lemmas about Replicate\<close>
 
 lemma replicate_mset_minus_replicate_mset_same[simp]:
   "replicate_mset m x - replicate_mset n x = replicate_mset (m - n) x"
   by (induct m arbitrary: n, simp, metis left_diff_repeat_mset_distrib' repeat_mset_replicate_mset)
 
 lemma replicate_mset_subset_iff_lt[simp]: "replicate_mset m x \<subset># replicate_mset n x \<longleftrightarrow> m < n"
   by (induct n m rule: diff_induct) (auto intro: subset_mset.gr_zeroI)
 
 lemma replicate_mset_subseteq_iff_le[simp]: "replicate_mset m x \<subseteq># replicate_mset n x \<longleftrightarrow> m \<le> n"
   by (induct n m rule: diff_induct) auto
 
 lemma replicate_mset_lt_iff_lt[simp]: "replicate_mset m x < replicate_mset n x \<longleftrightarrow> m < n"
   by (induct n m rule: diff_induct) (auto intro: subset_mset.gr_zeroI gr_zeroI)
 
 lemma replicate_mset_le_iff_le[simp]: "replicate_mset m x \<le> replicate_mset n x \<longleftrightarrow> m \<le> n"
   by (induct n m rule: diff_induct) auto
 
 lemma replicate_mset_eq_iff[simp]:
   "replicate_mset m x = replicate_mset n y \<longleftrightarrow> m = n \<and> (m \<noteq> 0 \<longrightarrow> x = y)"
   by (cases m; cases n; simp)
     (metis in_replicate_mset insert_noteq_member size_replicate_mset union_single_eq_diff)
 
 lemma replicate_mset_plus: "replicate_mset (a + b) C = replicate_mset a C + replicate_mset b C"
   by (induct a) (auto simp: ac_simps)
 
 lemma mset_replicate_replicate_mset: "mset (replicate n L) = replicate_mset n L"
   by (induction n) auto
 
 lemma set_mset_single_iff_replicate_mset: "set_mset U = {a} \<longleftrightarrow> (\<exists>n > 0. U = replicate_mset n a)"
   by (rule, metis count_greater_zero_iff count_replicate_mset insertI1 multi_count_eq singletonD
     zero_less_iff_neq_zero, force)
 
 lemma ex_replicate_mset_if_all_elems_eq:
   assumes "\<forall>x \<in># M. x = y"
   shows "\<exists>n. M = replicate_mset n y"
   using assms by (metis count_replicate_mset mem_Collect_eq multiset_eqI neq0_conv set_mset_def)
 
 
 subsection \<open>Multiset and Set Conversions\<close>
 
 lemma count_mset_set_if: "count (mset_set A) a = (if a \<in> A \<and> finite A then 1 else 0)"
   by auto
 
 lemma mset_set_set_mset_empty_mempty[iff]: "mset_set (set_mset D) = {#} \<longleftrightarrow> D = {#}"
   by (simp add: mset_set_empty_iff)
 
 lemma count_mset_set_le_one: "count (mset_set A) x \<le> 1"
   by (simp add: count_mset_set_if)
 
 lemma mset_set_set_mset_subseteq[simp]: "mset_set (set_mset A) \<subseteq># A"
   by (simp add: mset_set_set_mset_msubset)
 
 lemma mset_sorted_list_of_set[simp]: "mset (sorted_list_of_set A) = mset_set A"
   by (metis mset_sorted_list_of_multiset sorted_list_of_mset_set)
 
 lemma sorted_sorted_list_of_multiset[simp]:
   "sorted (sorted_list_of_multiset (M :: 'a::linorder multiset))"
   by (metis mset_sorted_list_of_multiset sorted_list_of_multiset_mset sorted_sort)
 
 lemma mset_take_subseteq: "mset (take n xs) \<subseteq># mset xs"
   apply (induct xs arbitrary: n)
    apply simp
   by (case_tac n) simp_all
 
 lemma sorted_list_of_multiset_eq_Nil[simp]: "sorted_list_of_multiset M = [] \<longleftrightarrow> M = {#}"
   by (metis mset_sorted_list_of_multiset sorted_list_of_multiset_empty)
 
 
 subsection \<open>Duplicate Removal\<close>
 
 (* TODO: use abbreviation? *)
 definition remdups_mset :: "'v multiset \<Rightarrow> 'v multiset" where
   "remdups_mset S = mset_set (set_mset S)"
 
 lemma set_mset_remdups_mset[simp]: \<open>set_mset (remdups_mset A) = set_mset A\<close>
   unfolding remdups_mset_def by auto
 
 lemma count_remdups_mset_eq_1: "a \<in># remdups_mset A \<longleftrightarrow> count (remdups_mset A) a = 1"
   unfolding remdups_mset_def by (auto simp: count_eq_zero_iff intro: count_inI)
 
 lemma remdups_mset_empty[simp]: "remdups_mset {#} = {#}"
   unfolding remdups_mset_def by auto
 
 lemma remdups_mset_singleton[simp]: "remdups_mset {#a#} = {#a#}"
   unfolding remdups_mset_def by auto
 
 lemma remdups_mset_eq_empty[iff]: "remdups_mset D = {#} \<longleftrightarrow> D = {#}"
   unfolding remdups_mset_def by blast
 
 lemma remdups_mset_singleton_sum[simp]:
   "remdups_mset (add_mset a A) = (if a \<in># A then remdups_mset A else add_mset a (remdups_mset A))"
   unfolding remdups_mset_def by (simp_all add: insert_absorb)
 
 lemma mset_remdups_remdups_mset[simp]: "mset (remdups D) = remdups_mset (mset D)"
   by (induction D) (auto simp add: ac_simps)
 
 declare mset_remdups_remdups_mset[symmetric, code]
 
 definition distinct_mset :: "'a multiset \<Rightarrow> bool" where
   "distinct_mset S \<longleftrightarrow> (\<forall>a. a \<in># S \<longrightarrow> count S a = 1)"
 
 lemma distinct_mset_count_less_1: "distinct_mset S \<longleftrightarrow> (\<forall>a. count S a \<le> 1)"
   using eq_iff nat_le_linear unfolding distinct_mset_def by fastforce
 
 lemma distinct_mset_empty[simp]: "distinct_mset {#}"
   unfolding distinct_mset_def by auto
 
 lemma distinct_mset_singleton: "distinct_mset {#a#}"
   unfolding distinct_mset_def by auto
 
 lemma distinct_mset_union:
   assumes dist: "distinct_mset (A + B)"
   shows "distinct_mset A"
   unfolding distinct_mset_count_less_1
 proof (rule allI)
   fix a
   have \<open>count A a \<le> count (A + B) a\<close> by auto
   moreover have \<open>count (A + B) a \<le> 1\<close>
     using dist unfolding distinct_mset_count_less_1 by auto
   ultimately show \<open>count A a \<le> 1\<close>
     by simp
 qed
 
 lemma distinct_mset_minus[simp]: "distinct_mset A \<Longrightarrow> distinct_mset (A - B)"
   by (metis diff_subset_eq_self mset_subset_eq_exists_conv distinct_mset_union)
 
 lemma count_remdups_mset_If: \<open>count (remdups_mset A) a = (if a \<in># A then 1 else 0)\<close>
   unfolding remdups_mset_def by auto
 
 lemma distinct_mset_rempdups_union_mset:
   assumes "distinct_mset A" and "distinct_mset B"
   shows "A \<union># B = remdups_mset (A + B)"
   using assms nat_le_linear unfolding remdups_mset_def
   by (force simp add: multiset_eq_iff max_def count_mset_set_if distinct_mset_def not_in_iff)
 
 lemma distinct_mset_add_mset[simp]: "distinct_mset (add_mset a L) \<longleftrightarrow> a \<notin># L \<and> distinct_mset L"
   unfolding distinct_mset_def
   apply (rule iffI)
    apply (auto split: if_split_asm; fail)[]
   by (auto simp: not_in_iff; fail)
 
 lemma distinct_mset_size_eq_card: "distinct_mset C \<Longrightarrow> size C = card (set_mset C)"
   by (induction C) auto
 
 lemma distinct_mset_add:
   "distinct_mset (L + L') \<longleftrightarrow> distinct_mset L \<and> distinct_mset L' \<and> L \<inter># L' = {#}"
   by (induction L arbitrary: L') auto
 
 lemma distinct_mset_set_mset_ident[simp]: "distinct_mset M \<Longrightarrow> mset_set (set_mset M) = M"
   by (induction M) auto
 
 lemma distinct_finite_set_mset_subseteq_iff[iff]:
   assumes "distinct_mset M" "finite N"
   shows "set_mset M \<subseteq> N \<longleftrightarrow> M \<subseteq># mset_set N"
   by (metis assms distinct_mset_set_mset_ident finite_set_mset msubset_mset_set_iff)
 
 lemma distinct_mem_diff_mset:
   assumes dist: "distinct_mset M" and mem: "x \<in> set_mset (M - N)"
   shows "x \<notin> set_mset N"
 proof -
   have "count M x = 1"
     using dist mem by (meson distinct_mset_def in_diffD)
   then show ?thesis
     using mem by (metis count_greater_eq_one_iff in_diff_count not_less)
 qed
 
 lemma distinct_set_mset_eq:
   assumes "distinct_mset M" "distinct_mset N" "set_mset M = set_mset N"
   shows "M = N"
   using assms distinct_mset_set_mset_ident by fastforce
 
 lemma distinct_mset_union_mset[simp]:
   \<open>distinct_mset (D \<union># C) \<longleftrightarrow> distinct_mset D \<and> distinct_mset C\<close>
   unfolding distinct_mset_count_less_1 by force
 
 lemma distinct_mset_inter_mset:
   "distinct_mset C \<Longrightarrow> distinct_mset (C \<inter># D)"
   "distinct_mset D \<Longrightarrow> distinct_mset (C \<inter># D)"
   by (simp_all add: multiset_inter_def,
     metis distinct_mset_minus multiset_inter_commute multiset_inter_def)
 
 lemma distinct_mset_remove1_All: "distinct_mset C \<Longrightarrow> remove1_mset L C = removeAll_mset L C"
   by (auto simp: multiset_eq_iff distinct_mset_count_less_1)
 
 lemma distinct_mset_size_2: "distinct_mset {#a, b#} \<longleftrightarrow> a \<noteq> b"
   by auto
 
 lemma distinct_mset_filter: "distinct_mset M \<Longrightarrow> distinct_mset {# L \<in># M. P L#}"
   by (simp add: distinct_mset_def)
 
 lemma distinct_mset_mset_distinct[simp]: \<open>distinct_mset (mset xs) = distinct xs\<close>
   by (induction xs) auto
 
 lemma distinct_image_mset_inj:
   \<open>inj_on f (set_mset M) \<Longrightarrow> distinct_mset (image_mset f M) \<longleftrightarrow> distinct_mset M\<close>
   by (induction M) (auto simp: inj_on_def)
 
 
 subsection \<open>Repeat Operation\<close>
 
 lemma repeat_mset_compower: "repeat_mset n A = (((+) A) ^^ n) {#}"
   by (induction n) auto
 
 lemma repeat_mset_prod: "repeat_mset (m * n) A = (((+) (repeat_mset n A)) ^^ m) {#}"
   by (induction m) (auto simp: repeat_mset_distrib)
 
 
 subsection \<open>Cartesian Product\<close>
 
 text \<open>Definition of the cartesian products over multisets. The construction mimics of the cartesian
   product on sets and use the same theorem names (adding only the suffix \<open>_mset\<close> to Sigma
   and Times). See file @{file \<open>~~/src/HOL/Product_Type.thy\<close>}\<close>
 
 definition Sigma_mset :: "'a multiset \<Rightarrow> ('a \<Rightarrow> 'b multiset) \<Rightarrow> ('a \<times> 'b) multiset" where
-  "Sigma_mset A B \<equiv> \<Union># {#{#(a, b). b \<in># B a#}. a \<in># A #}"
+  "Sigma_mset A B \<equiv> \<Sum>\<^sub># {#{#(a, b). b \<in># B a#}. a \<in># A #}"
 
 abbreviation Times_mset :: "'a multiset \<Rightarrow> 'b multiset \<Rightarrow> ('a \<times> 'b) multiset" (infixr "\<times>#" 80) where
   "Times_mset A B \<equiv> Sigma_mset A (\<lambda>_. B)"
 
 hide_const (open) Times_mset
 
 text \<open>Contrary to the set version @{term \<open>SIGMA x:A. B\<close>}, we use the non-ASCII symbol \<open>\<in>#\<close>.\<close>
 
 syntax
   "_Sigma_mset" :: "[pttrn, 'a multiset, 'b multiset] => ('a * 'b) multiset"
   ("(3SIGMAMSET _\<in>#_./ _)" [0, 0, 10] 10)
 translations
   "SIGMAMSET x\<in>#A. B" == "CONST Sigma_mset A (\<lambda>x. B)"
 
 text \<open>Link between the multiset and the set cartesian product:\<close>
 
 lemma Times_mset_Times: "set_mset (A \<times># B) = set_mset A \<times> set_mset B"
   unfolding Sigma_mset_def by auto
 
 lemma Sigma_msetI [intro!]: "\<lbrakk>a \<in># A; b \<in># B a\<rbrakk> \<Longrightarrow> (a, b) \<in># Sigma_mset A B"
   by (unfold Sigma_mset_def) auto
 
 lemma Sigma_msetE[elim!]: "\<lbrakk>c \<in># Sigma_mset A B; \<And>x y. \<lbrakk>x \<in># A; y \<in># B x; c = (x, y)\<rbrakk> \<Longrightarrow> P\<rbrakk> \<Longrightarrow> P"
   by (unfold Sigma_mset_def) auto
 
 text \<open>Elimination of @{term "(a, b) \<in># A \<times># B"} -- introduces no eigenvariables.\<close>
 
 lemma Sigma_msetD1: "(a, b) \<in># Sigma_mset A B \<Longrightarrow> a \<in># A"
   by blast
 
 lemma Sigma_msetD2: "(a, b) \<in># Sigma_mset A B \<Longrightarrow> b \<in># B a"
   by blast
 
 lemma Sigma_msetE2: "\<lbrakk>(a, b) \<in># Sigma_mset A B; \<lbrakk>a \<in># A; b \<in># B a\<rbrakk> \<Longrightarrow> P\<rbrakk> \<Longrightarrow> P"
   by blast
 
 lemma Sigma_mset_cong:
   "\<lbrakk>A = B; \<And>x. x \<in># B \<Longrightarrow> C x = D x\<rbrakk> \<Longrightarrow> (SIGMAMSET x \<in># A. C x) = (SIGMAMSET x \<in># B. D x)"
   by (metis (mono_tags, lifting) Sigma_mset_def image_mset_cong)
 
-lemma count_sum_mset: "count (\<Union># M) b = (\<Sum>P \<in># M. count P b)"
+lemma count_sum_mset: "count (\<Sum>\<^sub># M) b = (\<Sum>P \<in># M. count P b)"
   by (induction M) auto
 
 lemma Sigma_mset_plus_distrib1[simp]: "Sigma_mset (A + B) C = Sigma_mset A C + Sigma_mset B C"
   unfolding Sigma_mset_def by auto
 
 lemma Sigma_mset_plus_distrib2[simp]:
   "Sigma_mset A (\<lambda>i. B i + C i) = Sigma_mset A B + Sigma_mset A C"
   unfolding Sigma_mset_def by (induction A) (auto simp: multiset_eq_iff)
 
 lemma Times_mset_single_left: "{#a#} \<times># B = image_mset (Pair a) B"
   unfolding Sigma_mset_def by auto
 
 lemma Times_mset_single_right: "A \<times># {#b#} = image_mset (\<lambda>a. Pair a b) A"
   unfolding Sigma_mset_def by (induction A) auto
 
 lemma Times_mset_single_single[simp]: "{#a#} \<times># {#b#} = {#(a, b)#}"
   unfolding Sigma_mset_def by simp
 
 lemma count_image_mset_Pair:
   "count (image_mset (Pair a) B) (x, b) = (if x = a then count B b else 0)"
   by (induction B) auto
 
 lemma count_Sigma_mset: "count (Sigma_mset A B) (a, b) = count A a * count (B a) b"
   by (induction A) (auto simp: Sigma_mset_def count_image_mset_Pair)
 
 lemma Sigma_mset_empty1[simp]: "Sigma_mset {#} B = {#}"
   unfolding Sigma_mset_def by auto
 
 lemma Sigma_mset_empty2[simp]: "A \<times># {#} = {#}"
   by (auto simp: multiset_eq_iff count_Sigma_mset)
 
 lemma Sigma_mset_mono:
   assumes "A \<subseteq># C" and "\<And>x. x \<in># A \<Longrightarrow> B x \<subseteq># D x"
   shows "Sigma_mset A B \<subseteq># Sigma_mset C D"
 proof -
   have "count A a * count (B a) b \<le> count C a * count (D a) b" for a b
     using assms unfolding subseteq_mset_def by (metis count_inI eq_iff mult_eq_0_iff mult_le_mono)
   then show ?thesis
     by (auto simp: subseteq_mset_def count_Sigma_mset)
 qed
 
 lemma mem_Sigma_mset_iff[iff]: "((a,b) \<in># Sigma_mset A B) = (a \<in># A \<and> b \<in># B a)"
   by blast
 
 lemma mem_Times_mset_iff: "x \<in># A \<times># B \<longleftrightarrow> fst x \<in># A \<and> snd x \<in># B"
   by (induct x) simp
 
 lemma Sigma_mset_empty_iff: "(SIGMAMSET i\<in>#I. X i) = {#} \<longleftrightarrow> (\<forall>i\<in>#I. X i = {#})"
   by (auto simp: Sigma_mset_def)
 
 lemma Times_mset_subset_mset_cancel1: "x \<in># A \<Longrightarrow> (A \<times># B \<subseteq># A \<times># C) = (B \<subseteq># C)"
   by (auto simp: subseteq_mset_def count_Sigma_mset)
 
 lemma Times_mset_subset_mset_cancel2: "x \<in># C \<Longrightarrow> (A \<times># C \<subseteq># B \<times># C) = (A \<subseteq># B)"
   by (auto simp: subseteq_mset_def count_Sigma_mset)
 
 lemma Times_mset_eq_cancel2: "x \<in># C \<Longrightarrow> (A \<times># C = B \<times># C) = (A = B)"
   by (auto simp: multiset_eq_iff count_Sigma_mset dest!: in_countE)
 
 lemma split_paired_Ball_mset_Sigma_mset[simp]:
   "(\<forall>z\<in>#Sigma_mset A B. P z) \<longleftrightarrow> (\<forall>x\<in>#A. \<forall>y\<in>#B x. P (x, y))"
   by blast
 
 lemma split_paired_Bex_mset_Sigma_mset[simp]:
   "(\<exists>z\<in>#Sigma_mset A B. P z) \<longleftrightarrow> (\<exists>x\<in>#A. \<exists>y\<in>#B x. P (x, y))"
   by blast
 
 lemma sum_mset_if_eq_constant:
   "(\<Sum>x\<in>#M. if a = x then (f x) else 0) = (((+) (f a)) ^^ (count M a)) 0"
   by (induction M) (auto simp: ac_simps)
 
 lemma iterate_op_plus: "(((+) k) ^^ m) 0 = k * m"
   by (induction m) auto
 
 lemma untion_image_mset_Pair_distribute:
-  "\<Union>#{#image_mset (Pair x) (C x). x \<in># J - I#} =
-   \<Union># {#image_mset (Pair x) (C x). x \<in># J#} - \<Union>#{#image_mset (Pair x) (C x). x \<in># I#}"
+  "\<Sum>\<^sub>#{#image_mset (Pair x) (C x). x \<in># J - I#} =
+   \<Sum>\<^sub># {#image_mset (Pair x) (C x). x \<in># J#} - \<Sum>\<^sub>#{#image_mset (Pair x) (C x). x \<in># I#}"
   by (auto simp: multiset_eq_iff count_sum_mset count_image_mset_Pair sum_mset_if_eq_constant
     iterate_op_plus diff_mult_distrib2)
 
 lemma Sigma_mset_Un_distrib1: "Sigma_mset (I \<union># J) C = Sigma_mset I C \<union># Sigma_mset J C"
   by (auto simp: Sigma_mset_def sup_subset_mset_def untion_image_mset_Pair_distribute)
 
 lemma Sigma_mset_Un_distrib2: "(SIGMAMSET i\<in>#I. A i \<union># B i) = Sigma_mset I A \<union># Sigma_mset I B"
   by (auto simp: multiset_eq_iff count_sum_mset count_image_mset_Pair sum_mset_if_eq_constant
     Sigma_mset_def diff_mult_distrib2 iterate_op_plus max_def not_in_iff)
 
 lemma Sigma_mset_Int_distrib1: "Sigma_mset (I \<inter># J) C = Sigma_mset I C \<inter># Sigma_mset J C"
   by (auto simp: multiset_eq_iff count_sum_mset count_image_mset_Pair sum_mset_if_eq_constant
     Sigma_mset_def iterate_op_plus min_def not_in_iff)
 
 lemma Sigma_mset_Int_distrib2: "(SIGMAMSET i\<in>#I. A i \<inter># B i) = Sigma_mset I A \<inter># Sigma_mset I B"
   by (auto simp: multiset_eq_iff count_sum_mset count_image_mset_Pair sum_mset_if_eq_constant
     Sigma_mset_def iterate_op_plus min_def not_in_iff)
 
 lemma Sigma_mset_Diff_distrib1: "Sigma_mset (I - J) C = Sigma_mset I C - Sigma_mset J C"
   by (auto simp: multiset_eq_iff count_sum_mset count_image_mset_Pair sum_mset_if_eq_constant
     Sigma_mset_def iterate_op_plus min_def not_in_iff diff_mult_distrib2)
 
 lemma Sigma_mset_Diff_distrib2: "(SIGMAMSET i\<in>#I. A i - B i) = Sigma_mset I A - Sigma_mset I B"
   by (auto simp: multiset_eq_iff count_sum_mset count_image_mset_Pair sum_mset_if_eq_constant
     Sigma_mset_def iterate_op_plus min_def not_in_iff diff_mult_distrib)
 
-lemma Sigma_mset_Union: "Sigma_mset (\<Union>#X) B = (\<Union># (image_mset (\<lambda>A. Sigma_mset A B) X))"
+lemma Sigma_mset_Union: "Sigma_mset (\<Sum>\<^sub>#X) B = (\<Sum>\<^sub># (image_mset (\<lambda>A. Sigma_mset A B) X))"
   by (auto simp: multiset_eq_iff count_sum_mset count_image_mset_Pair sum_mset_if_eq_constant
     Sigma_mset_def iterate_op_plus min_def not_in_iff sum_mset_distrib_left)
 
 lemma Times_mset_Un_distrib1: "(A \<union># B) \<times># C = A \<times># C \<union># B \<times># C"
   by (fact Sigma_mset_Un_distrib1)
 
 lemma Times_mset_Int_distrib1: "(A \<inter># B) \<times># C = A \<times># C \<inter># B \<times># C"
   by (fact Sigma_mset_Int_distrib1)
 
 lemma Times_mset_Diff_distrib1: "(A - B) \<times># C = A \<times># C - B \<times># C"
   by (fact Sigma_mset_Diff_distrib1)
 
 lemma Times_mset_empty[simp]: "A \<times># B = {#} \<longleftrightarrow> A = {#} \<or> B = {#}"
   by (auto simp: Sigma_mset_empty_iff)
 
 lemma Times_insert_left: "A \<times># add_mset x B = A \<times># B + image_mset (\<lambda>a. Pair a x) A"
   unfolding add_mset_add_single[of x B] Sigma_mset_plus_distrib2
   by (simp add: Times_mset_single_right)
 
 lemma Times_insert_right: "add_mset a A \<times># B = A \<times># B + image_mset (Pair a) B"
   unfolding add_mset_add_single[of a A] Sigma_mset_plus_distrib1
   by (simp add: Times_mset_single_left)
 
 lemma fst_image_mset_times_mset [simp]:
   "image_mset fst (A \<times># B) = (if B = {#} then {#} else repeat_mset (size B) A)"
   by (induct B) (auto simp: Times_mset_single_right ac_simps Times_insert_left)
 
 lemma snd_image_mset_times_mset [simp]:
   "image_mset snd (A \<times># B) = (if A = {#} then {#} else repeat_mset (size A) B)"
   by (induct B) (auto simp add: Times_mset_single_right Times_insert_left image_mset_const_eq)
 
 lemma product_swap_mset: "image_mset prod.swap (A \<times># B) = B \<times># A"
   by (induction A) (auto simp add: Times_mset_single_left Times_mset_single_right
       Times_insert_right Times_insert_left)
 
 context
 begin
 
 qualified definition product_mset :: "'a multiset \<Rightarrow> 'b multiset \<Rightarrow> ('a \<times> 'b) multiset" where
   [code_abbrev]: "product_mset A B = A \<times># B"
 
 lemma member_product_mset: "x \<in># product_mset A B \<longleftrightarrow> x \<in># A \<times># B"
   by (simp add: Multiset_More.product_mset_def)
 
 end
 
 lemma count_Sigma_mset_abs_def: "count (Sigma_mset A B) = (\<lambda>(a, b) \<Rightarrow> count A a * count (B a) b)"
   by (auto simp: fun_eq_iff count_Sigma_mset)
 
 lemma Times_mset_image_mset1: "image_mset f A \<times># B = image_mset (\<lambda>(a, b). (f a, b)) (A \<times># B)"
   by (induct B) (auto simp: Times_insert_left)
 
 lemma Times_mset_image_mset2: "A \<times># image_mset f B = image_mset (\<lambda>(a, b). (a, f b)) (A \<times># B)"
   by (induct A) (auto simp: Times_insert_right)
 
 lemma sum_le_singleton: "A \<subseteq> {x} \<Longrightarrow> sum f A = (if x \<in> A then f x else 0)"
   by (auto simp: subset_singleton_iff elim: finite_subset)
 
 lemma Times_mset_assoc: "(A \<times># B) \<times># C = image_mset (\<lambda>(a, b, c). ((a, b), c)) (A \<times># B \<times># C)"
   by (auto simp: multiset_eq_iff count_Sigma_mset count_image_mset vimage_def Times_mset_Times
       Int_commute count_eq_zero_iff intro!: trans[OF _ sym[OF sum_le_singleton[of _ "(_, _, _)"]]]
       cong: sum.cong if_cong)
 
 
 subsection \<open>Transfer Rules\<close>
 
 lemma plus_multiset_transfer[transfer_rule]:
   "(rel_fun (rel_mset R) (rel_fun (rel_mset R) (rel_mset R))) (+) (+)"
   by (unfold rel_fun_def rel_mset_def)
     (force dest: list_all2_appendI intro: exI[of _ "_ @ _"] conjI[rotated])
 
 lemma minus_multiset_transfer[transfer_rule]:
   assumes [transfer_rule]: "bi_unique R"
   shows "(rel_fun (rel_mset R) (rel_fun (rel_mset R) (rel_mset R))) (-) (-)"
 proof (unfold rel_fun_def rel_mset_def, safe)
   fix xs ys xs' ys'
   assume [transfer_rule]: "list_all2 R xs ys" "list_all2 R xs' ys'"
   have "list_all2 R (fold remove1 xs' xs) (fold remove1 ys' ys)"
     by transfer_prover
   moreover have "mset (fold remove1 xs' xs) = mset xs - mset xs'"
     by (induct xs' arbitrary: xs) auto
   moreover have "mset (fold remove1 ys' ys) = mset ys - mset ys'"
     by (induct ys' arbitrary: ys) auto
   ultimately show "\<exists>xs'' ys''.
     mset xs'' = mset xs - mset xs' \<and> mset ys'' = mset ys - mset ys' \<and> list_all2 R xs'' ys''"
     by blast
 qed
 
 declare rel_mset_Zero[transfer_rule]
 
 lemma count_transfer[transfer_rule]:
   assumes "bi_unique R"
   shows "(rel_fun (rel_mset R) (rel_fun R (=))) count count"
 unfolding rel_fun_def rel_mset_def proof safe
   fix x y xs ys
   assume "list_all2 R xs ys" "R x y"
   then show "count (mset xs) x = count (mset ys) y"
   proof (induct xs ys rule: list.rel_induct)
     case (Cons x' xs y' ys)
     then show ?case
       using assms unfolding bi_unique_alt_def2 by (auto simp: rel_fun_def)
   qed simp
 qed
 
 lemma subseteq_multiset_transfer[transfer_rule]:
   assumes [transfer_rule]: "bi_unique R" "right_total R"
   shows "(rel_fun (rel_mset R) (rel_fun (rel_mset R) (=)))
     (\<lambda>M N. filter_mset (Domainp R) M \<subseteq># filter_mset (Domainp R) N) (\<subseteq>#)"
 proof -
   have count_filter_mset_less:
     "(\<forall>a. count (filter_mset (Domainp R) M) a \<le> count (filter_mset (Domainp R) N) a) \<longleftrightarrow>
      (\<forall>a \<in> {x. Domainp R x}. count M a \<le> count N a)" for M and N by auto
   show ?thesis unfolding subseteq_mset_def count_filter_mset_less
     by transfer_prover
 qed
 
 lemma sum_mset_transfer[transfer_rule]:
   "R 0 0 \<Longrightarrow> rel_fun R (rel_fun R R) (+) (+) \<Longrightarrow> (rel_fun (rel_mset R) R) sum_mset sum_mset"
   using sum_list_transfer[of R] unfolding rel_fun_def rel_mset_def by auto
 
 lemma Sigma_mset_transfer[transfer_rule]:
   "(rel_fun (rel_mset R) (rel_fun (rel_fun R (rel_mset S)) (rel_mset (rel_prod R S))))
      Sigma_mset Sigma_mset"
   by (unfold Sigma_mset_def) transfer_prover
 
 
 subsection \<open>Even More about Multisets\<close>
 
 subsubsection \<open>Multisets and Functions\<close>
 
 lemma range_image_mset:
   assumes "set_mset Ds \<subseteq> range f"
   shows "Ds \<in> range (image_mset f)"
 proof -
   have "\<forall>D. D \<in># Ds \<longrightarrow> (\<exists>C. f C = D)"
     using assms by blast
   then obtain f_i where
     f_p: "\<forall>D. D \<in># Ds \<longrightarrow> (f (f_i D) = D)"
     by metis
   define Cs where
     "Cs \<equiv> image_mset f_i Ds"
   from f_p Cs_def have "image_mset f Cs = Ds"
     by auto
   then show ?thesis
     by blast
 qed
 
 
 subsubsection \<open>Multisets and Lists\<close>
 
 lemma length_sorted_list_of_multiset[simp]: "length (sorted_list_of_multiset A) = size A"
   by (metis mset_sorted_list_of_multiset size_mset)
 
 definition list_of_mset :: "'a multiset \<Rightarrow> 'a list" where
   "list_of_mset m = (SOME l. m = mset l)"
 
 lemma list_of_mset_exi: "\<exists>l. m = mset l"
   using ex_mset by metis
 
 lemma mset_list_of_mset[simp]: "mset (list_of_mset m) = m"
   by (metis (mono_tags, lifting) ex_mset list_of_mset_def someI_ex)
 
 lemma length_list_of_mset[simp]: "length (list_of_mset A) = size A"
   unfolding list_of_mset_def by (metis (mono_tags) ex_mset size_mset someI_ex)
 
 lemma range_mset_map:
   assumes "set_mset Ds \<subseteq> range f"
   shows "Ds \<in> range (\<lambda>Cl. mset (map f Cl))"
 proof -
   have "Ds \<in> range (image_mset f)"
     by (simp add: assms range_image_mset)
   then obtain Cs where Cs_p: "image_mset f Cs = Ds"
     by auto
   define Cl where "Cl = list_of_mset Cs"
   then have "mset Cl = Cs"
     by auto
   then have "image_mset f (mset Cl) = Ds"
     using Cs_p by auto
   then have "mset (map f Cl) = Ds"
     by auto
   then show ?thesis
     by auto
 qed
 
 lemma list_of_mset_empty[iff]: "list_of_mset m = [] \<longleftrightarrow> m = {#}"
   by (metis (mono_tags, lifting) ex_mset list_of_mset_def mset_zero_iff_right someI_ex)
 
 lemma in_mset_conv_nth: "(x \<in># mset xs) = (\<exists>i<length xs. xs ! i = x)"
   by (auto simp: in_set_conv_nth)
 
 lemma in_mset_sum_list:
   assumes "L \<in># LL"
   assumes "LL \<in> set Ci"
   shows "L \<in># sum_list Ci"
   using assms by (induction Ci) auto
 
 lemma in_mset_sum_list2:
   assumes "L \<in># sum_list Ci"
   obtains LL where
     "LL \<in> set Ci"
     "L \<in># LL"
   using assms by (induction Ci) auto
 
 (* TODO: Make [simp]. *)
 lemma in_mset_sum_list_iff: "a \<in># sum_list \<A> \<longleftrightarrow> (\<exists>A \<in> set \<A>. a \<in># A)"
   by (metis in_mset_sum_list in_mset_sum_list2)
 
 lemma subseteq_list_Union_mset:
   assumes "length Ci = n"
   assumes "length CAi = n"
   assumes "\<forall>i<n.  Ci ! i \<subseteq># CAi ! i "
-  shows "\<Union># (mset Ci) \<subseteq># \<Union># (mset CAi)"
+  shows "\<Sum>\<^sub># (mset Ci) \<subseteq># \<Sum>\<^sub># (mset CAi)"
   using assms proof (induction n arbitrary: Ci CAi)
   case 0
   then show ?case by auto
 next
   case (Suc n)
   from Suc have "\<forall>i<n. tl Ci ! i \<subseteq># tl CAi ! i"
     by (simp add: nth_tl)
-  hence "\<Union>#(mset (tl Ci)) \<subseteq># \<Union>#(mset (tl CAi))" using Suc by auto
+  hence "\<Sum>\<^sub>#(mset (tl Ci)) \<subseteq># \<Sum>\<^sub>#(mset (tl CAi))" using Suc by auto
   moreover
   have "hd Ci \<subseteq># hd CAi" using Suc
     by (metis hd_conv_nth length_greater_0_conv zero_less_Suc)
   ultimately
-  show "\<Union>#(mset Ci) \<subseteq># \<Union>#(mset CAi)"
+  show "\<Sum>\<^sub>#(mset Ci) \<subseteq># \<Sum>\<^sub>#(mset CAi)"
     using Suc by (cases Ci; cases CAi) (auto intro: subset_mset.add_mono)
 qed
 
 
 subsubsection \<open>More on Multisets and Functions\<close>
 
 lemma subseteq_mset_size_eql: "X \<subseteq># Y \<Longrightarrow> size Y = size X \<Longrightarrow> X = Y"
   using mset_subset_size subset_mset_def by fastforce
 
 lemma image_mset_of_subset_list:
   assumes "image_mset \<eta> C' = mset lC"
   shows "\<exists>qC'. map \<eta> qC' = lC \<and> mset qC' = C'"
   using assms apply (induction lC arbitrary: C')
   subgoal by simp
   subgoal by (fastforce dest!: msed_map_invR intro: exI[of _ \<open>_ # _\<close>])
   done
 
 lemma image_mset_of_subset:
   assumes "A \<subseteq># image_mset \<eta> C'"
   shows "\<exists>A'. image_mset \<eta> A' = A \<and> A' \<subseteq># C'"
 proof -
   define C where "C = image_mset \<eta> C'"
 
   define lA where "lA = list_of_mset A"
   define lD where "lD = list_of_mset (C-A)"
   define lC where "lC = lA @ lD"
 
   have "mset lC = C"
     using C_def assms unfolding lD_def lC_def lA_def by auto
   then have "\<exists>qC'. map \<eta> qC' = lC \<and> mset qC' = C'"
     using assms image_mset_of_subset_list unfolding C_def by metis
   then obtain qC' where qC'_p: "map \<eta> qC' = lC \<and> mset qC' = C'"
     by auto
   let ?lA' = "take (length lA) qC'"
   have m: "map \<eta> ?lA' = lA"
     using qC'_p lC_def
     by (metis append_eq_conv_conj take_map)
   let ?A' = "mset ?lA'"
 
   have "image_mset \<eta> ?A' = A"
     using m using lA_def
     by (metis (full_types) ex_mset list_of_mset_def mset_map someI_ex)
   moreover have "?A' \<subseteq># C'"
     using qC'_p unfolding lA_def
     using mset_take_subseteq by blast
   ultimately show ?thesis by blast
 qed
 
 lemma all_the_same: "\<forall>x \<in># X. x = y \<Longrightarrow> card (set_mset X) \<le> Suc 0"
   by (metis card.empty card.insert card_mono finite.intros(1) finite_insert le_SucI singletonI subsetI)
 
 lemma Melem_subseteq_Union_mset[simp]:
   assumes "x \<in># T"
-  shows "x \<subseteq># \<Union>#T"
+  shows "x \<subseteq># \<Sum>\<^sub>#T"
   using assms sum_mset.remove by force
 
 lemma Melem_subset_eq_sum_list[simp]:
   assumes "x \<in># mset T"
   shows "x \<subseteq># sum_list T"
   using assms by (metis mset_subset_eq_add_left sum_mset.remove sum_mset_sum_list)
 
 lemma less_subset_eq_Union_mset[simp]:
   assumes "i < length CAi"
-  shows "CAi ! i \<subseteq># \<Union>#(mset CAi)"
+  shows "CAi ! i \<subseteq># \<Sum>\<^sub>#(mset CAi)"
 proof -
   from assms have "CAi ! i \<in># mset CAi"
     by auto
   then show ?thesis
     by auto
 qed
 
 lemma less_subset_eq_sum_list[simp]:
   assumes "i < length CAi"
   shows "CAi ! i \<subseteq># sum_list CAi"
 proof -
   from assms have "CAi ! i \<in># mset CAi"
     by auto
   then show ?thesis
     by auto
 qed
 
 
 subsubsection \<open>More on Multiset Order\<close>
 
 lemma less_multiset_doubletons:
   assumes
     "y < t \<or> y < s"  
     "x < t \<or> x < s" 
   shows 
     "{#y, x#} < {#t, s#}" 
   unfolding less_multiset\<^sub>D\<^sub>M
 proof (intro exI)
   let ?X = "{#t, s#}"
   let ?Y = "{#y, x#}"
   show "?X \<noteq> {#} \<and> ?X \<subseteq># {#t, s#} \<and> {#y, x#} = {#t, s#} - ?X + ?Y
     \<and> (\<forall>k. k \<in># ?Y \<longrightarrow> (\<exists>a. a \<in># ?X \<and> k < a))"
     using add_eq_conv_diff assms by auto
 qed
 
 end
diff --git a/thys/Ordered_Resolution_Prover/FO_Ordered_Resolution.thy b/thys/Ordered_Resolution_Prover/FO_Ordered_Resolution.thy
--- a/thys/Ordered_Resolution_Prover/FO_Ordered_Resolution.thy
+++ b/thys/Ordered_Resolution_Prover/FO_Ordered_Resolution.thy
@@ -1,1412 +1,1412 @@
 (*  Title:       First-Order Ordered Resolution Calculus with Selection
     Author:      Anders Schlichtkrull <andschl at dtu.dk>, 2016, 2017
     Author:      Jasmin Blanchette <j.c.blanchette at vu.nl>, 2014, 2017
     Author:      Dmitriy Traytel <traytel at inf.ethz.ch>, 2014
     Author:      Sophie Tourret <stourret at mpi-inf.mpg.de>, 2020
     Maintainer:  Anders Schlichtkrull <andschl at dtu.dk>
 *)
 
 section \<open>First-Order Ordered Resolution Calculus with Selection\<close>
 
 theory FO_Ordered_Resolution
   imports Abstract_Substitution Ordered_Ground_Resolution Standard_Redundancy
 begin
 
 text \<open>
 This material is based on Section 4.3 (``A Simple Resolution Prover for First-Order Clauses'') of
 Bachmair and Ganzinger's chapter. Specifically, it formalizes the ordered resolution calculus for
 first-order standard clauses presented in Figure 4 and its related lemmas and theorems, including
 soundness and Lemma 4.12 (the lifting lemma).
 
 The following corresponds to pages 41--42 of Section 4.3, until Figure 5 and its explanation.
 \<close>
 
 locale FO_resolution = mgu subst_atm id_subst comp_subst atm_of_atms renamings_apart mgu
   for
     subst_atm :: "'a :: wellorder \<Rightarrow> 's \<Rightarrow> 'a" and
     id_subst :: "'s" and
     comp_subst :: "'s \<Rightarrow> 's \<Rightarrow> 's" and
     renamings_apart :: "'a literal multiset list \<Rightarrow> 's list" and
     atm_of_atms :: "'a list \<Rightarrow> 'a" and
     mgu :: "'a set set \<Rightarrow> 's option" +
   fixes
     less_atm :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
   assumes
     less_atm_stable: "less_atm A B \<Longrightarrow> less_atm (A \<cdot>a \<sigma>) (B \<cdot>a \<sigma>)" and
     less_atm_ground: "is_ground_atm A \<Longrightarrow> is_ground_atm B \<Longrightarrow> less_atm A B \<Longrightarrow> A < B"
 begin
 
 
 subsection \<open>Library\<close>
 
 lemma Bex_cartesian_product: "(\<exists>xy \<in> A \<times> B. P xy) \<equiv> (\<exists>x \<in> A. \<exists>y \<in> B. P (x, y))"
   by simp
 
 lemma eql_map_neg_lit_eql_atm:
   assumes "map (\<lambda>L. L \<cdot>l \<eta>) (map Neg As') = map Neg As"
   shows "As' \<cdot>al \<eta> = As"
   using assms by (induction As' arbitrary: As) auto
 
 lemma instance_list:
   assumes "negs (mset As) = SDA' \<cdot> \<eta>"
   shows "\<exists>As'. negs (mset As') = SDA' \<and> As' \<cdot>al \<eta> = As"
 proof -
   from assms have negL: "\<forall>L \<in># SDA'. is_neg L"
     using Melem_subst_cls subst_lit_in_negs_is_neg by metis
 
   from assms have "{#L \<cdot>l \<eta>. L \<in># SDA'#} = mset (map Neg As)"
     using subst_cls_def by auto
   then have "\<exists>NAs'. map (\<lambda>L. L \<cdot>l \<eta>) NAs' = map Neg As \<and> mset NAs' = SDA'"
     using image_mset_of_subset_list[of "\<lambda>L. L \<cdot>l \<eta>" SDA' "map Neg As"] by auto
   then obtain As' where As'_p:
     "map (\<lambda>L. L \<cdot>l \<eta>) (map Neg As') = map Neg As \<and> mset (map Neg As') = SDA'"
     by (metis (no_types, lifting) Neg_atm_of_iff negL ex_map_conv set_mset_mset)
 
   have "negs (mset As') = SDA'"
     using As'_p by auto
   moreover have "map (\<lambda>L. L \<cdot>l \<eta>) (map Neg As') = map Neg As"
     using As'_p by auto
   then have "As' \<cdot>al \<eta> = As"
     using eql_map_neg_lit_eql_atm by auto
   ultimately show ?thesis
     by blast
 qed
 
 lemma map2_add_mset_map:
   assumes "length AAs' = n" and "length As' = n"
   shows "map2 add_mset (As' \<cdot>al \<eta>) (AAs' \<cdot>aml \<eta>) = map2 add_mset As' AAs' \<cdot>aml \<eta>"
   using assms
 proof (induction n arbitrary: AAs' As')
   case (Suc n)
   then have "map2 add_mset (tl (As' \<cdot>al \<eta>)) (tl (AAs' \<cdot>aml \<eta>)) = map2 add_mset (tl As') (tl AAs') \<cdot>aml \<eta>"
     by simp
   moreover have Succ: "length (As' \<cdot>al \<eta>) = Suc n" "length (AAs' \<cdot>aml \<eta>) = Suc n"
     using Suc(3) Suc(2) by auto
   then have "length (tl (As' \<cdot>al \<eta>)) = n" "length (tl (AAs' \<cdot>aml \<eta>)) = n"
     by auto
   then have "length (map2 add_mset (tl (As' \<cdot>al \<eta>)) (tl (AAs' \<cdot>aml \<eta>))) = n"
     "length (map2 add_mset (tl As') (tl AAs') \<cdot>aml \<eta>) = n"
     using Suc(2,3) by auto
   ultimately have "\<forall>i < n. tl (map2 add_mset ( (As' \<cdot>al \<eta>)) ((AAs' \<cdot>aml \<eta>))) ! i =
     tl (map2 add_mset (As') (AAs') \<cdot>aml \<eta>) ! i"
     using Suc(2,3) Succ by (simp add: map2_tl map_tl subst_atm_mset_list_def del: subst_atm_list_tl)
   moreover have nn: "length (map2 add_mset ((As' \<cdot>al \<eta>)) ((AAs' \<cdot>aml \<eta>))) = Suc n"
     "length (map2 add_mset (As') (AAs') \<cdot>aml \<eta>) = Suc n"
     using Succ Suc by auto
   ultimately have "\<forall>i. i < Suc n \<longrightarrow> i > 0 \<longrightarrow>
     map2 add_mset (As' \<cdot>al \<eta>) (AAs' \<cdot>aml \<eta>) ! i = (map2 add_mset As' AAs' \<cdot>aml \<eta>) ! i"
     by (auto simp: subst_atm_mset_list_def gr0_conv_Suc subst_atm_mset_def)
   moreover have "add_mset (hd As' \<cdot>a \<eta>) (hd AAs' \<cdot>am \<eta>) = add_mset (hd As') (hd AAs') \<cdot>am \<eta>"
     unfolding subst_atm_mset_def by auto
   then have "(map2 add_mset (As' \<cdot>al \<eta>) (AAs' \<cdot>aml \<eta>)) ! 0  = (map2 add_mset (As') (AAs') \<cdot>aml \<eta>) ! 0"
     using Suc by (simp add: Succ(2) subst_atm_mset_def)
   ultimately have "\<forall>i < Suc n. (map2 add_mset (As' \<cdot>al \<eta>) (AAs' \<cdot>aml \<eta>)) ! i =
     (map2 add_mset (As') (AAs') \<cdot>aml \<eta>) ! i"
     using Suc by auto
   then show ?case
     using nn list_eq_iff_nth_eq by metis
 qed auto
 
 context
   fixes S :: "'a clause \<Rightarrow> 'a clause"
 begin
 
 
 subsection \<open>Calculus\<close>
 
 text \<open>
 The following corresponds to Figure 4.
 \<close>
 
 definition maximal_wrt :: "'a \<Rightarrow> 'a literal multiset \<Rightarrow> bool" where
   "maximal_wrt A C \<longleftrightarrow> (\<forall>B \<in> atms_of C. \<not> less_atm A B)"
 
 definition strictly_maximal_wrt :: "'a \<Rightarrow> 'a literal multiset \<Rightarrow> bool" where
   "strictly_maximal_wrt A C \<equiv> \<forall>B \<in> atms_of C. A \<noteq> B \<and> \<not> less_atm A B"
 
 lemma strictly_maximal_wrt_maximal_wrt: "strictly_maximal_wrt A C \<Longrightarrow> maximal_wrt A C"
   unfolding maximal_wrt_def strictly_maximal_wrt_def by auto
 
 lemma maximal_wrt_subst: "maximal_wrt (A \<cdot>a \<sigma>) (C \<cdot> \<sigma>) \<Longrightarrow> maximal_wrt A C"
   unfolding maximal_wrt_def using in_atms_of_subst less_atm_stable by blast
 
 lemma strictly_maximal_wrt_subst:
   "strictly_maximal_wrt (A \<cdot>a \<sigma>) (C \<cdot> \<sigma>) \<Longrightarrow> strictly_maximal_wrt A C"
   unfolding strictly_maximal_wrt_def using in_atms_of_subst less_atm_stable by blast
 
 inductive eligible :: "'s \<Rightarrow> 'a list \<Rightarrow> 'a clause \<Rightarrow> bool" where
   eligible:
     "S DA = negs (mset As) \<or> S DA = {#} \<and> length As = 1 \<and> maximal_wrt (As ! 0 \<cdot>a \<sigma>) (DA \<cdot> \<sigma>) \<Longrightarrow>
      eligible \<sigma> As DA"
 
 inductive
   ord_resolve
   :: "'a clause list \<Rightarrow> 'a clause \<Rightarrow> 'a multiset list \<Rightarrow> 'a list \<Rightarrow> 's \<Rightarrow> 'a clause \<Rightarrow> bool"
 where
   ord_resolve:
     "length CAs = n \<Longrightarrow>
      length Cs = n \<Longrightarrow>
      length AAs = n \<Longrightarrow>
      length As = n \<Longrightarrow>
      n \<noteq> 0 \<Longrightarrow>
      (\<forall>i < n. CAs ! i = Cs ! i + poss (AAs ! i)) \<Longrightarrow>
      (\<forall>i < n. AAs ! i \<noteq> {#}) \<Longrightarrow>
      Some \<sigma> = mgu (set_mset ` set (map2 add_mset As AAs)) \<Longrightarrow>
      eligible \<sigma> As (D + negs (mset As)) \<Longrightarrow>
      (\<forall>i < n. strictly_maximal_wrt (As ! i \<cdot>a \<sigma>) (Cs ! i \<cdot> \<sigma>)) \<Longrightarrow>
      (\<forall>i < n. S (CAs ! i) = {#}) \<Longrightarrow>
-     ord_resolve CAs (D + negs (mset As)) AAs As \<sigma> ((\<Union># (mset Cs) + D) \<cdot> \<sigma>)"
+     ord_resolve CAs (D + negs (mset As)) AAs As \<sigma> ((\<Sum>\<^sub># (mset Cs) + D) \<cdot> \<sigma>)"
 
 inductive
   ord_resolve_rename
   :: "'a clause list \<Rightarrow> 'a clause \<Rightarrow> 'a multiset list \<Rightarrow> 'a list \<Rightarrow> 's \<Rightarrow> 'a clause \<Rightarrow> bool"
 where
   ord_resolve_rename:
     "length CAs = n \<Longrightarrow>
      length AAs = n \<Longrightarrow>
      length As = n \<Longrightarrow>
      (\<forall>i < n. poss (AAs ! i) \<subseteq># CAs ! i) \<Longrightarrow>
      negs (mset As) \<subseteq># DA \<Longrightarrow>
      \<rho> = hd (renamings_apart (DA # CAs)) \<Longrightarrow>
      \<rho>s = tl (renamings_apart (DA # CAs)) \<Longrightarrow>
      ord_resolve (CAs \<cdot>\<cdot>cl \<rho>s) (DA \<cdot> \<rho>) (AAs \<cdot>\<cdot>aml \<rho>s) (As \<cdot>al \<rho>) \<sigma> E \<Longrightarrow>
      ord_resolve_rename CAs DA AAs As \<sigma> E"
 
 lemma ord_resolve_empty_main_prem: "\<not> ord_resolve Cs {#} AAs As \<sigma> E"
   by (simp add: ord_resolve.simps)
 
 lemma ord_resolve_rename_empty_main_prem: "\<not> ord_resolve_rename Cs {#} AAs As \<sigma> E"
   by (simp add: ord_resolve_empty_main_prem ord_resolve_rename.simps)
 
 
 subsection \<open>Soundness\<close>
 
 text \<open>
 Soundness is not discussed in the chapter, but it is an important property.
 \<close>
 
 lemma ord_resolve_ground_inst_sound:
   assumes
     res_e: "ord_resolve CAs DA AAs As \<sigma> E" and
     cc_inst_true: "I \<Turnstile>m mset CAs \<cdot>cm \<sigma> \<cdot>cm \<eta>" and
     d_inst_true: "I \<Turnstile> DA \<cdot> \<sigma> \<cdot> \<eta>" and
     ground_subst_\<eta>: "is_ground_subst \<eta>"
   shows "I \<Turnstile> E \<cdot> \<eta>"
   using res_e
 proof (cases rule: ord_resolve.cases)
   case (ord_resolve n Cs D)
   note da = this(1) and e = this(2) and cas_len = this(3) and cs_len = this(4) and
     aas_len = this(5) and as_len = this(6) and cas = this(8) and mgu = this(10) and
     len = this(1)
 
   have len: "length CAs = length As"
     using as_len cas_len by auto
   have "is_ground_subst (\<sigma> \<odot> \<eta>)"
     using ground_subst_\<eta> by (rule is_ground_comp_subst)
   then have cc_true: "I \<Turnstile>m mset CAs \<cdot>cm \<sigma> \<cdot>cm \<eta>" and d_true: "I \<Turnstile> DA \<cdot> \<sigma> \<cdot> \<eta>"
     using cc_inst_true d_inst_true by auto
 
   from mgu have unif: "\<forall>i < n. \<forall>A\<in>#AAs ! i. A \<cdot>a \<sigma> = As ! i \<cdot>a \<sigma>"
     using mgu_unifier as_len aas_len by blast
 
   show "I \<Turnstile> E \<cdot> \<eta>"
   proof (cases "\<forall>A \<in> set As. A \<cdot>a \<sigma> \<cdot>a \<eta> \<in> I")
     case True
     then have "\<not> I \<Turnstile> negs (mset As) \<cdot> \<sigma> \<cdot> \<eta>"
       unfolding true_cls_def[of I] by auto
     then have "I \<Turnstile> D \<cdot> \<sigma> \<cdot> \<eta>"
       using d_true da by auto
     then show ?thesis
       unfolding e by auto
   next
     case False
     then obtain i where a_in_aa: "i < length CAs" and a_false: "(As ! i) \<cdot>a \<sigma> \<cdot>a \<eta> \<notin> I"
       using da len by (metis in_set_conv_nth)
     define C where "C \<equiv> Cs ! i"
     define BB where "BB \<equiv> AAs ! i"
-    have c_cf': "C \<subseteq># \<Union># (mset CAs)"
+    have c_cf': "C \<subseteq># \<Sum>\<^sub># (mset CAs)"
       unfolding C_def using a_in_aa cas cas_len
       by (metis less_subset_eq_Union_mset mset_subset_eq_add_left subset_mset.order.trans)
     have c_in_cc: "C + poss BB \<in># mset CAs"
       using C_def BB_def a_in_aa cas_len in_set_conv_nth cas by fastforce
     {
       fix B
       assume "B \<in># BB"
       then have "B \<cdot>a \<sigma> = (As ! i) \<cdot>a \<sigma>"
         using unif a_in_aa cas_len unfolding BB_def by auto
     }
     then have "\<not> I \<Turnstile> poss BB \<cdot> \<sigma> \<cdot> \<eta>"
       using a_false by (auto simp: true_cls_def)
     moreover have "I \<Turnstile> (C + poss BB) \<cdot> \<sigma> \<cdot> \<eta>"
       using c_in_cc cc_true true_cls_mset_true_cls[of I "mset CAs \<cdot>cm \<sigma> \<cdot>cm \<eta>"] by force
     ultimately have "I \<Turnstile> C \<cdot> \<sigma> \<cdot> \<eta>"
       by simp
     then show ?thesis
       unfolding e subst_cls_union using c_cf' C_def a_in_aa cas_len cs_len
       by (metis (no_types, lifting) mset_subset_eq_add_left nth_mem_mset set_mset_mono sum_mset.remove true_cls_mono subst_cls_mono)
   qed
 qed
 
 text \<open>
 The previous lemma is not only used to prove soundness, but also the following lemma which is
 used to prove Lemma 4.10.
 \<close>
 
 lemma ord_resolve_rename_ground_inst_sound:
   assumes
     "ord_resolve_rename CAs DA AAs As \<sigma> E" and
     "\<rho>s = tl (renamings_apart (DA # CAs))" and
     "\<rho> = hd (renamings_apart (DA # CAs))" and
     "I \<Turnstile>m (mset (CAs \<cdot>\<cdot>cl \<rho>s)) \<cdot>cm \<sigma> \<cdot>cm \<eta>" and
     "I \<Turnstile> DA \<cdot> \<rho> \<cdot> \<sigma> \<cdot> \<eta>" and
     "is_ground_subst \<eta>"
   shows "I \<Turnstile> E \<cdot> \<eta>"
   using assms by (cases rule: ord_resolve_rename.cases) (fast intro: ord_resolve_ground_inst_sound)
 
 text \<open>
 Here follows the soundness theorem for the resolution rule.
 \<close>
 
 theorem ord_resolve_sound:
  assumes
    res_e: "ord_resolve CAs DA AAs As \<sigma> E" and
    cc_d_true: "\<And>\<sigma>. is_ground_subst \<sigma> \<Longrightarrow> I \<Turnstile>m (mset CAs + {#DA#}) \<cdot>cm \<sigma>" and
    ground_subst_\<eta>: "is_ground_subst \<eta>"
  shows "I \<Turnstile> E \<cdot> \<eta>"
 proof (use res_e in \<open>cases rule: ord_resolve.cases\<close>)
   case (ord_resolve n Cs D)
   note da = this(1) and e = this(2) and cas_len = this(3) and cs_len = this(4)
     and aas_len = this(5) and as_len = this(6) and cas = this(8) and mgu = this(10)
   have ground_subst_\<sigma>_\<eta>: "is_ground_subst (\<sigma> \<odot> \<eta>)"
     using ground_subst_\<eta> by (rule is_ground_comp_subst)
   have cas_true: "I \<Turnstile>m mset CAs \<cdot>cm \<sigma> \<cdot>cm \<eta>"
     using cc_d_true ground_subst_\<sigma>_\<eta> by fastforce
   have da_true: "I \<Turnstile> DA \<cdot> \<sigma> \<cdot> \<eta>"
     using cc_d_true ground_subst_\<sigma>_\<eta> by fastforce
   show "I \<Turnstile> E \<cdot> \<eta>"
     using ord_resolve_ground_inst_sound[OF res_e cas_true da_true] ground_subst_\<eta> by auto
 qed
 
 lemma subst_sound:
   assumes
     "\<And>\<sigma>. is_ground_subst \<sigma> \<Longrightarrow> I \<Turnstile> C \<cdot> \<sigma>" and
     "is_ground_subst \<eta>"
   shows "I \<Turnstile> C \<cdot> \<rho> \<cdot> \<eta>"
   using assms is_ground_comp_subst subst_cls_comp_subst by metis
 
 lemma subst_sound_scl:
   assumes
     len: "length P = length CAs" and
     true_cas: "\<And>\<sigma>. is_ground_subst \<sigma> \<Longrightarrow> I \<Turnstile>m mset CAs \<cdot>cm \<sigma>" and
     ground_subst_\<eta>: "is_ground_subst \<eta>"
   shows "I \<Turnstile>m mset (CAs \<cdot>\<cdot>cl P) \<cdot>cm \<eta>"
 proof -
   from true_cas have "\<And>CA. CA\<in># mset CAs \<Longrightarrow> (\<And>\<sigma>. is_ground_subst \<sigma> \<Longrightarrow> I \<Turnstile> CA \<cdot> \<sigma>)"
     unfolding true_cls_mset_def by force
   then have "\<forall>i < length CAs. \<forall>\<sigma>. is_ground_subst \<sigma> \<longrightarrow> (I \<Turnstile> CAs ! i \<cdot> \<sigma>)"
     using in_set_conv_nth by auto
   then have true_cp: "\<forall>i < length CAs. \<forall>\<sigma>. is_ground_subst \<sigma> \<longrightarrow> I \<Turnstile> CAs ! i \<cdot> P ! i \<cdot> \<sigma>"
     using subst_sound len by auto
 
   {
     fix CA
     assume "CA \<in># mset (CAs \<cdot>\<cdot>cl P)"
     then obtain i where
       i_x: "i < length (CAs \<cdot>\<cdot>cl P)" "CA = (CAs \<cdot>\<cdot>cl P) ! i"
       by (metis in_mset_conv_nth)
     then have "\<forall>\<sigma>. is_ground_subst \<sigma> \<longrightarrow> I \<Turnstile> CA \<cdot> \<sigma>"
       using true_cp unfolding subst_cls_lists_def by (simp add: len)
   }
   then show ?thesis
     using assms unfolding true_cls_mset_def by auto
 qed
 
 text \<open>
 Here follows the soundness theorem for the resolution rule with renaming.
 \<close>
 
 lemma ord_resolve_rename_sound:
   assumes
     res_e: "ord_resolve_rename CAs DA AAs As \<sigma> E" and
     cc_d_true: "\<And>\<sigma>. is_ground_subst \<sigma> \<Longrightarrow> I \<Turnstile>m ((mset CAs) + {#DA#}) \<cdot>cm \<sigma>" and
     ground_subst_\<eta>: "is_ground_subst \<eta>"
   shows "I \<Turnstile> E \<cdot> \<eta>"
   using res_e
 proof (cases rule: ord_resolve_rename.cases)
   case (ord_resolve_rename n \<rho> \<rho>s)
   note \<rho>s = this(7) and res = this(8)
   have len: "length \<rho>s = length CAs"
     using \<rho>s renamings_apart_length by auto
   have "\<And>\<sigma>. is_ground_subst \<sigma> \<Longrightarrow> I \<Turnstile>m (mset (CAs \<cdot>\<cdot>cl \<rho>s) + {#DA \<cdot> \<rho>#}) \<cdot>cm \<sigma>"
     using subst_sound_scl[OF len, of I] subst_sound cc_d_true by auto
   then show "I \<Turnstile> E \<cdot> \<eta>"
     using ground_subst_\<eta> ord_resolve_sound[OF res] by simp
 qed
 
 
 subsection \<open>Other Basic Properties\<close>
 
 lemma ord_resolve_unique:
   assumes
     "ord_resolve CAs DA AAs As \<sigma> E" and
     "ord_resolve CAs DA AAs As \<sigma>' E'"
   shows "\<sigma> = \<sigma>' \<and> E = E'"
   using assms
 proof (cases rule: ord_resolve.cases[case_product ord_resolve.cases], intro conjI)
   case (ord_resolve_ord_resolve CAs n Cs AAs As \<sigma>'' DA CAs' n' Cs' AAs' As' \<sigma>''' DA')
   note res = this(1-17) and res' = this(18-34)
 
   show \<sigma>: "\<sigma> = \<sigma>'"
     using res(3-5,14) res'(3-5,14) by (metis option.inject)
 
   have "Cs = Cs'"
     using res(1,3,7,8,12) res'(1,3,7,8,12) by (metis add_right_imp_eq nth_equalityI)
   moreover have "DA = DA'"
     using res(2,4) res'(2,4) by fastforce
   ultimately show "E = E'"
     using res(5,6) res'(5,6) \<sigma> by blast
 qed
 
 lemma ord_resolve_rename_unique:
   assumes
     "ord_resolve_rename CAs DA AAs As \<sigma> E" and
     "ord_resolve_rename CAs DA AAs As \<sigma>' E'"
   shows "\<sigma> = \<sigma>' \<and> E = E'"
   using assms unfolding ord_resolve_rename.simps using ord_resolve_unique by meson
 
 lemma ord_resolve_max_side_prems: "ord_resolve CAs DA AAs As \<sigma> E \<Longrightarrow> length CAs \<le> size DA"
   by (auto elim!: ord_resolve.cases)
 
 lemma ord_resolve_rename_max_side_prems:
   "ord_resolve_rename CAs DA AAs As \<sigma> E \<Longrightarrow> length CAs \<le> size DA"
   by (elim ord_resolve_rename.cases, drule ord_resolve_max_side_prems, simp add: renamings_apart_length)
 
 
 subsection \<open>Inference System\<close>
 
 definition ord_FO_\<Gamma> :: "'a inference set" where
   "ord_FO_\<Gamma> = {Infer (mset CAs) DA E | CAs DA AAs As \<sigma> E. ord_resolve_rename CAs DA AAs As \<sigma> E}"
 
 interpretation ord_FO_resolution: inference_system ord_FO_\<Gamma> .
 
 lemma finite_ord_FO_resolution_inferences_between:
   assumes fin_cc: "finite CC"
   shows "finite (ord_FO_resolution.inferences_between CC C)"
 proof -
   let ?CCC = "CC \<union> {C}"
 
   define all_AA where "all_AA = (\<Union>D \<in> ?CCC. atms_of D)"
   define max_ary where "max_ary = Max (size ` ?CCC)"
   define CAS where "CAS = {CAs. CAs \<in> lists ?CCC \<and> length CAs \<le> max_ary}"
   define AS where "AS = {As. As \<in> lists all_AA \<and> length As \<le> max_ary}"
   define AAS where "AAS = {AAs. AAs \<in> lists (mset ` AS) \<and> length AAs \<le> max_ary}"
 
   note defs = all_AA_def max_ary_def CAS_def AS_def AAS_def
 
   let ?infer_of =
     "\<lambda>CAs DA AAs As. Infer (mset CAs) DA (THE E. \<exists>\<sigma>. ord_resolve_rename CAs DA AAs As \<sigma> E)"
 
   let ?Z = "{\<gamma> | CAs DA AAs As \<sigma> E \<gamma>. \<gamma> = Infer (mset CAs) DA E
     \<and> ord_resolve_rename CAs DA AAs As \<sigma> E \<and> infer_from ?CCC \<gamma> \<and> C \<in># prems_of \<gamma>}"
   let ?Y = "{Infer (mset CAs) DA E | CAs DA AAs As \<sigma> E.
     ord_resolve_rename CAs DA AAs As \<sigma> E \<and> set CAs \<union> {DA} \<subseteq> ?CCC}"
   let ?X = "{?infer_of CAs DA AAs As | CAs DA AAs As. CAs \<in> CAS \<and> DA \<in> ?CCC \<and> AAs \<in> AAS \<and> As \<in> AS}"
   let ?W = "CAS \<times> ?CCC \<times> AAS \<times> AS"
 
   have fin_w: "finite ?W"
     unfolding defs using fin_cc by (simp add: finite_lists_length_le lists_eq_set)
 
   have "?Z \<subseteq> ?Y"
     by (force simp: infer_from_def)
   also have "\<dots> \<subseteq> ?X"
   proof -
     {
       fix CAs DA AAs As \<sigma> E
       assume
         res_e: "ord_resolve_rename CAs DA AAs As \<sigma> E" and
         da_in: "DA \<in> ?CCC" and
         cas_sub: "set CAs \<subseteq> ?CCC"
 
       have "E = (THE E. \<exists>\<sigma>. ord_resolve_rename CAs DA AAs As \<sigma> E)
         \<and> CAs \<in> CAS \<and> AAs \<in> AAS \<and> As \<in> AS" (is "?e \<and> ?cas \<and> ?aas \<and> ?as")
       proof (intro conjI)
         show ?e
           using res_e ord_resolve_rename_unique by (blast intro: the_equality[symmetric])
       next
         show ?cas
           unfolding CAS_def max_ary_def using cas_sub
             ord_resolve_rename_max_side_prems[OF res_e] da_in fin_cc
           by (auto simp add: Max_ge_iff)
       next
         show ?aas
           using res_e
         proof (cases rule: ord_resolve_rename.cases)
           case (ord_resolve_rename n \<rho> \<rho>s)
           note len_cas = this(1) and len_aas = this(2) and len_as = this(3) and
             aas_sub = this(4) and as_sub = this(5) and res_e' = this(8)
 
           show ?thesis
             unfolding AAS_def
           proof (clarify, intro conjI)
             show "AAs \<in> lists (mset ` AS)"
               unfolding AS_def image_def
             proof clarsimp
               fix AA
               assume "AA \<in> set AAs"
               then obtain i where
                 i_lt: "i < n" and
                 aa: "AA = AAs ! i"
                 by (metis in_set_conv_nth len_aas)
 
               have casi_in: "CAs ! i \<in> ?CCC"
                 using i_lt len_cas cas_sub nth_mem by blast
 
               have pos_aa_sub: "poss AA \<subseteq># CAs ! i"
                 using aa aas_sub i_lt by blast
               then have "set_mset AA \<subseteq> atms_of (CAs ! i)"
                 by (metis atms_of_poss lits_subseteq_imp_atms_subseteq set_mset_mono)
               also have aa_sub: "\<dots> \<subseteq> all_AA"
                 unfolding all_AA_def using casi_in by force
               finally have aa_sub: "set_mset AA \<subseteq> all_AA"
                 .
 
               have "size AA = size (poss AA)"
                 by simp
               also have "\<dots> \<le> size (CAs ! i)"
                 by (rule size_mset_mono[OF pos_aa_sub])
               also have "\<dots> \<le> max_ary"
                 unfolding max_ary_def using fin_cc casi_in by auto
               finally have sz_aa: "size AA \<le> max_ary"
                 .
 
               let ?As' = "sorted_list_of_multiset AA"
 
               have "?As' \<in> lists all_AA"
                 using aa_sub by auto
               moreover have "length ?As' \<le> max_ary"
                 using sz_aa by simp
               moreover have "AA = mset ?As'"
                 by simp
               ultimately show "\<exists>xa. xa \<in> lists all_AA \<and> length xa \<le> max_ary \<and> AA = mset xa"
                 by blast
             qed
           next
             have "length AAs = length As"
               unfolding len_aas len_as ..
             also have "\<dots> \<le> size DA"
               using as_sub size_mset_mono by fastforce
             also have "\<dots> \<le> max_ary"
               unfolding max_ary_def using fin_cc da_in by auto
             finally show "length AAs \<le> max_ary"
               .
           qed
         qed
       next
         show ?as
           unfolding AS_def
         proof (clarify, intro conjI)
           have "set As \<subseteq> atms_of DA"
             using res_e[simplified ord_resolve_rename.simps]
             by (metis atms_of_negs lits_subseteq_imp_atms_subseteq set_mset_mono set_mset_mset)
           also have "\<dots> \<subseteq> all_AA"
             unfolding all_AA_def using da_in by blast
           finally show "As \<in> lists all_AA"
             unfolding lists_eq_set by simp
         next
           have "length As \<le> size DA"
             using res_e[simplified ord_resolve_rename.simps]
               ord_resolve_rename_max_side_prems[OF res_e] by auto
           also have "size DA \<le> max_ary"
             unfolding max_ary_def using fin_cc da_in by auto
           finally show "length As \<le> max_ary"
             .
         qed
       qed
     }
     then show ?thesis
       by simp fast
   qed
   also have "\<dots> \<subseteq> (\<lambda>(CAs, DA, AAs, As). ?infer_of CAs DA AAs As) ` ?W"
     unfolding image_def Bex_cartesian_product by fast
   finally show ?thesis
     unfolding inference_system.inferences_between_def ord_FO_\<Gamma>_def mem_Collect_eq
     by (fast intro: rev_finite_subset[OF finite_imageI[OF fin_w]])
 qed
 
 lemma ord_FO_resolution_inferences_between_empty_empty:
   "ord_FO_resolution.inferences_between {} {#} = {}"
   unfolding ord_FO_resolution.inferences_between_def inference_system.inferences_between_def
     infer_from_def ord_FO_\<Gamma>_def
   using ord_resolve_rename_empty_main_prem by auto
 
 
 subsection \<open>Lifting\<close>
 
 text \<open>
 The following corresponds to the passage between Lemmas 4.11 and 4.12.
 \<close>
 
 context
   fixes M :: "'a clause set"
   assumes select: "selection S"
 begin
 
 interpretation selection
   by (rule select)
 
 definition S_M :: "'a literal multiset \<Rightarrow> 'a literal multiset" where
   "S_M C =
    (if C \<in> grounding_of_clss M then
       (SOME C'. \<exists>D \<sigma>. D \<in> M \<and> C = D \<cdot> \<sigma> \<and> C' = S D \<cdot> \<sigma> \<and> is_ground_subst \<sigma>)
     else
       S C)"
 
 lemma S_M_grounding_of_clss:
   assumes "C \<in> grounding_of_clss M"
   obtains D \<sigma> where
     "D \<in> M \<and> C = D \<cdot> \<sigma> \<and> S_M C = S D \<cdot> \<sigma> \<and> is_ground_subst \<sigma>"
 proof (atomize_elim, unfold S_M_def eqTrueI[OF assms] if_True, rule someI_ex)
   from assms show "\<exists>C' D \<sigma>. D \<in> M \<and> C = D \<cdot> \<sigma> \<and> C' = S D \<cdot> \<sigma> \<and> is_ground_subst \<sigma>"
     by (auto simp: grounding_of_clss_def grounding_of_cls_def)
 qed
 
 lemma S_M_not_grounding_of_clss: "C \<notin> grounding_of_clss M \<Longrightarrow> S_M C = S C"
   unfolding S_M_def by simp
 
 lemma S_M_selects_subseteq: "S_M C \<subseteq># C"
   by (metis S_M_grounding_of_clss S_M_not_grounding_of_clss S_selects_subseteq subst_cls_mono_mset)
 
 lemma S_M_selects_neg_lits: "L \<in># S_M C \<Longrightarrow> is_neg L"
   by (metis Melem_subst_cls S_M_grounding_of_clss S_M_not_grounding_of_clss S_selects_neg_lits
       subst_lit_is_neg)
 
 end
 
 end
 
 text \<open>
 The following corresponds to Lemma 4.12:
 \<close>
 
 lemma ground_resolvent_subset:
   assumes
     gr_cas: "is_ground_cls_list CAs" and
     gr_da: "is_ground_cls DA" and
     res_e: "ord_resolve S CAs DA AAs As \<sigma> E"
-  shows "E \<subseteq># \<Union># (mset CAs) + DA"
+  shows "E \<subseteq># \<Sum>\<^sub># (mset CAs) + DA"
   using res_e
 proof (cases rule: ord_resolve.cases)
   case (ord_resolve n Cs D)
   note da = this(1) and e = this(2) and cas_len = this(3) and cs_len = this(4)
     and aas_len = this(5) and as_len = this(6) and cas = this(8) and mgu = this(10)
-  then have cs_sub_cas: "\<Union># (mset Cs) \<subseteq># \<Union># (mset CAs)"
+  then have cs_sub_cas: "\<Sum>\<^sub># (mset Cs) \<subseteq># \<Sum>\<^sub># (mset CAs)"
     using subseteq_list_Union_mset cas_len cs_len by force
-  then have cs_sub_cas: "\<Union># (mset Cs) \<subseteq># \<Union># (mset CAs)"
+  then have cs_sub_cas: "\<Sum>\<^sub># (mset Cs) \<subseteq># \<Sum>\<^sub># (mset CAs)"
     using subseteq_list_Union_mset cas_len cs_len by force
   then have gr_cs: "is_ground_cls_list Cs"
     using gr_cas by simp
   have d_sub_da: "D \<subseteq># DA"
     by (simp add: da)
   then have gr_d: "is_ground_cls D"
     using gr_da is_ground_cls_mono by auto
 
-  have "is_ground_cls (\<Union># (mset Cs) + D)"
+  have "is_ground_cls (\<Sum>\<^sub># (mset Cs) + D)"
     using gr_cs gr_d by auto
-  with e have "E = \<Union># (mset Cs) + D"
+  with e have "E = \<Sum>\<^sub># (mset Cs) + D"
     by auto
   then show ?thesis
     using cs_sub_cas d_sub_da by (auto simp: subset_mset.add_mono)
 qed
 
 lemma ord_resolve_obtain_clauses:
   assumes
     res_e: "ord_resolve (S_M S M) CAs DA AAs As \<sigma> E" and
     select: "selection S" and
     grounding: "{DA} \<union> set CAs \<subseteq> grounding_of_clss M" and
     n: "length CAs = n" and
     d: "DA = D + negs (mset As)" and
     c: "(\<forall>i < n. CAs ! i = Cs ! i + poss (AAs ! i))" "length Cs = n" "length AAs = n"
   obtains DA0 \<eta>0 CAs0 \<eta>s0 As0 AAs0 D0 Cs0 where
     "length CAs0 = n"
     "length \<eta>s0 = n"
     "DA0 \<in> M"
     "DA0 \<cdot> \<eta>0 = DA"
     "S DA0 \<cdot> \<eta>0 = S_M S M DA"
     "\<forall>CA0 \<in> set CAs0. CA0 \<in> M"
     "CAs0 \<cdot>\<cdot>cl \<eta>s0 = CAs"
     "map S CAs0 \<cdot>\<cdot>cl \<eta>s0 = map (S_M S M) CAs"
     "is_ground_subst \<eta>0"
     "is_ground_subst_list \<eta>s0"
     "As0  \<cdot>al \<eta>0 = As"
     "AAs0 \<cdot>\<cdot>aml \<eta>s0 = AAs"
     "length As0 = n"
     "D0 \<cdot> \<eta>0 = D"
     "DA0 = D0 + (negs (mset As0))"
     "S_M S M (D + negs (mset As)) \<noteq> {#} \<Longrightarrow> negs (mset As0) = S DA0"
     "length Cs0 = n"
     "Cs0 \<cdot>\<cdot>cl \<eta>s0 = Cs"
     "\<forall>i < n. CAs0 ! i = Cs0 ! i + poss (AAs0 ! i)"
     "length AAs0 = n"
   using res_e
 proof (cases rule: ord_resolve.cases)
   case (ord_resolve n_twin Cs_twins D_twin)
   note da = this(1) and e = this(2) and cas = this(8) and mgu = this(10) and eligible = this(11)
   from ord_resolve have "n_twin = n" "D_twin = D"
     using n d by auto
   moreover have "Cs_twins = Cs"
     using c cas n calculation(1) \<open>length Cs_twins = n_twin\<close> by (auto simp add: nth_equalityI)
   ultimately
   have nz: "n \<noteq> 0" and cs_len: "length Cs = n" and aas_len: "length AAs = n" and as_len: "length As = n"
     and da: "DA = D + negs (mset As)" and eligible: "eligible (S_M S M) \<sigma> As (D + negs (mset As))"
     and cas: "\<forall>i<n. CAs ! i = Cs ! i + poss (AAs ! i)"
     using ord_resolve by force+
 
   note n = \<open>n \<noteq> 0\<close> \<open>length CAs = n\<close> \<open>length Cs = n\<close> \<open>length AAs = n\<close> \<open>length As = n\<close>
 
   interpret S: selection S by (rule select)
 
   \<comment> \<open>Obtain FO side premises\<close>
   have "\<forall>CA \<in> set CAs. \<exists>CA0 \<eta>c0. CA0 \<in> M \<and> CA0 \<cdot> \<eta>c0 = CA \<and> S CA0 \<cdot> \<eta>c0 = S_M S M CA \<and> is_ground_subst \<eta>c0"
     using grounding S_M_grounding_of_clss select by (metis (no_types) le_supE subset_iff)
   then have "\<forall>i < n. \<exists>CA0 \<eta>c0. CA0 \<in> M \<and> CA0 \<cdot> \<eta>c0 = (CAs ! i) \<and> S CA0 \<cdot> \<eta>c0 = S_M S M (CAs ! i) \<and> is_ground_subst \<eta>c0"
     using n by force
   then obtain \<eta>s0f CAs0f where f_p:
     "\<forall>i < n. CAs0f i \<in> M"
     "\<forall>i < n. (CAs0f i) \<cdot> (\<eta>s0f i) = (CAs ! i)"
     "\<forall>i < n. S (CAs0f i)  \<cdot> (\<eta>s0f i) = S_M S M (CAs ! i)"
     "\<forall>i < n. is_ground_subst (\<eta>s0f i)"
     using n by (metis (no_types))
 
   define \<eta>s0 where
     "\<eta>s0 = map \<eta>s0f [0 ..<n]"
   define CAs0 where
     "CAs0 = map CAs0f [0 ..<n]"
 
   have "length \<eta>s0 = n" "length CAs0 = n"
     unfolding \<eta>s0_def CAs0_def by auto
   note n = \<open>length \<eta>s0 = n\<close> \<open>length CAs0 = n\<close> n
 
   \<comment> \<open>The properties we need of the FO side premises\<close>
   have CAs0_in_M: "\<forall>CA0 \<in> set CAs0. CA0 \<in> M"
     unfolding CAs0_def using f_p(1) by auto
   have CAs0_to_CAs: "CAs0 \<cdot>\<cdot>cl \<eta>s0 = CAs"
     unfolding CAs0_def \<eta>s0_def using f_p(2)  by (auto simp: n intro: nth_equalityI)
   have SCAs0_to_SMCAs: "(map S CAs0) \<cdot>\<cdot>cl \<eta>s0 = map (S_M S M) CAs"
     unfolding CAs0_def \<eta>s0_def using f_p(3) n by (force intro: nth_equalityI)
   have sub_ground: "\<forall>\<eta>c0 \<in> set \<eta>s0. is_ground_subst \<eta>c0"
     unfolding \<eta>s0_def using f_p n by force
   then have "is_ground_subst_list \<eta>s0"
     using n unfolding is_ground_subst_list_def by auto
 
   \<comment> \<open>Split side premises CAs0 into Cs0 and AAs0\<close>
   obtain AAs0 Cs0 where AAs0_Cs0_p:
    "AAs0 \<cdot>\<cdot>aml \<eta>s0 = AAs" "length Cs0 = n" "Cs0 \<cdot>\<cdot>cl \<eta>s0 = Cs"
    "\<forall>i < n. CAs0 ! i = Cs0 ! i + poss (AAs0 ! i)" "length AAs0 = n"
   proof -
     have "\<forall>i < n. \<exists>AA0. AA0 \<cdot>am \<eta>s0 ! i = AAs ! i \<and> poss AA0 \<subseteq># CAs0 ! i"
     proof (rule, rule)
       fix i
       assume "i < n"
       have "CAs0 ! i \<cdot> \<eta>s0 ! i = CAs ! i"
         using \<open>i < n\<close> \<open>CAs0 \<cdot>\<cdot>cl \<eta>s0 = CAs\<close> n by force
       moreover have "poss (AAs ! i) \<subseteq># CAs !i"
         using \<open>i < n\<close> cas by auto
       ultimately obtain poss_AA0 where
         nn: "poss_AA0 \<cdot> \<eta>s0 ! i = poss (AAs ! i) \<and> poss_AA0 \<subseteq># CAs0 ! i"
         using cas image_mset_of_subset unfolding subst_cls_def by metis
       then have l: "\<forall>L \<in># poss_AA0. is_pos L"
         unfolding subst_cls_def by (metis Melem_subst_cls imageE literal.disc(1)
             literal.map_disc_iff set_image_mset subst_cls_def subst_lit_def)
 
       define AA0 where
         "AA0 = image_mset atm_of poss_AA0"
 
       have na: "poss AA0 = poss_AA0"
         using l unfolding AA0_def by auto
       then have "AA0 \<cdot>am \<eta>s0 ! i = AAs ! i"
         using nn by (metis (mono_tags) literal.inject(1) multiset.inj_map_strong subst_cls_poss)
       moreover have "poss AA0 \<subseteq># CAs0 ! i"
         using na nn by auto
       ultimately show "\<exists>AA0. AA0 \<cdot>am \<eta>s0 ! i = AAs ! i \<and> poss AA0 \<subseteq># CAs0 ! i"
         by blast
     qed
     then obtain AAs0f where
       AAs0f_p: "\<forall>i < n. AAs0f i \<cdot>am \<eta>s0 ! i = AAs ! i \<and> (poss (AAs0f i)) \<subseteq># CAs0 ! i"
       by metis
 
     define AAs0 where "AAs0 = map AAs0f [0 ..<n]"
 
     then have "length AAs0 = n"
       by auto
     note n = n \<open>length AAs0 = n\<close>
 
     from AAs0_def have "\<forall>i < n. AAs0 ! i \<cdot>am \<eta>s0 ! i = AAs ! i"
       using AAs0f_p by auto
     then have AAs0_AAs: "AAs0 \<cdot>\<cdot>aml \<eta>s0 = AAs"
       using n by (auto intro: nth_equalityI)
 
     from AAs0_def have AAs0_in_CAs0: "\<forall>i < n. poss (AAs0 ! i) \<subseteq># CAs0 ! i"
       using AAs0f_p by auto
 
     define Cs0 where
       "Cs0 = map2 (-) CAs0 (map poss AAs0)"
 
     have "length Cs0 = n"
       using Cs0_def n by auto
     note n = n \<open>length Cs0 = n\<close>
 
     have "\<forall>i < n. CAs0 ! i = Cs0 ! i + poss (AAs0 ! i)"
       using AAs0_in_CAs0 Cs0_def n by auto
     then have "Cs0 \<cdot>\<cdot>cl \<eta>s0 = Cs"
       using \<open>CAs0 \<cdot>\<cdot>cl \<eta>s0 = CAs\<close> AAs0_AAs cas n by (auto intro: nth_equalityI)
 
     show ?thesis
       using that
         \<open>AAs0 \<cdot>\<cdot>aml \<eta>s0 = AAs\<close> \<open>Cs0 \<cdot>\<cdot>cl \<eta>s0 = Cs\<close> \<open>\<forall>i < n. CAs0 ! i = Cs0 ! i + poss (AAs0 ! i)\<close>
         \<open>length AAs0 = n\<close> \<open>length Cs0 = n\<close>
       by blast
   qed
 
   \<comment> \<open>Obtain FO main premise\<close>
   have "\<exists>DA0 \<eta>0. DA0 \<in> M \<and> DA = DA0 \<cdot> \<eta>0 \<and> S DA0 \<cdot> \<eta>0 = S_M S M DA \<and> is_ground_subst \<eta>0"
     using grounding S_M_grounding_of_clss select by (metis le_supE singletonI subsetCE)
   then obtain DA0 \<eta>0 where
     DA0_\<eta>0_p: "DA0 \<in> M \<and> DA = DA0 \<cdot> \<eta>0 \<and> S DA0 \<cdot> \<eta>0 = S_M S M DA \<and> is_ground_subst \<eta>0"
     by auto
   \<comment> \<open>The properties we need of the FO main premise\<close>
   have DA0_in_M: "DA0 \<in> M"
     using DA0_\<eta>0_p by auto
   have DA0_to_DA: "DA0 \<cdot> \<eta>0 = DA"
     using DA0_\<eta>0_p by auto
   have SDA0_to_SMDA: "S DA0 \<cdot> \<eta>0 = S_M S M DA"
     using DA0_\<eta>0_p by auto
   have "is_ground_subst \<eta>0"
     using DA0_\<eta>0_p by auto
 
   \<comment> \<open>Split main premise DA0 into D0 and As0\<close>
   obtain D0 As0 where D0As0_p:
      "As0  \<cdot>al \<eta>0 = As" "length As0 = n" "D0 \<cdot> \<eta>0 = D" "DA0 = D0 + (negs (mset As0))"
     "S_M S M (D + negs (mset As)) \<noteq> {#} \<Longrightarrow> negs (mset As0) = S DA0"
   proof -
     {
       assume a: "S_M S M (D + negs (mset As)) = {#} \<and> length As = (Suc 0)
         \<and> maximal_wrt (As ! 0 \<cdot>a \<sigma>) ((D + negs (mset As)) \<cdot> \<sigma>)"
       then have as: "mset As = {#As ! 0#}"
         by (auto intro: nth_equalityI)
       then have "negs (mset As) = {#Neg (As ! 0)#}"
         by (simp add: \<open>mset As = {#As ! 0#}\<close>)
       then have "DA = D + {#Neg (As ! 0)#}"
         using da by auto
       then obtain L where "L \<in># DA0 \<and> L \<cdot>l \<eta>0 = Neg (As ! 0)"
         using DA0_to_DA by (metis Melem_subst_cls mset_subset_eq_add_right single_subset_iff)
       then have "Neg (atm_of L) \<in># DA0 \<and> Neg (atm_of L) \<cdot>l \<eta>0 = Neg (As ! 0)"
         by (metis Neg_atm_of_iff literal.sel(2) subst_lit_is_pos)
       then have "[atm_of L] \<cdot>al \<eta>0 = As \<and> negs (mset [atm_of L]) \<subseteq># DA0"
         using as subst_lit_def by auto
       then have "\<exists>As0. As0 \<cdot>al \<eta>0 = As \<and> negs (mset As0) \<subseteq># DA0
         \<and> (S_M S M (D + negs (mset As)) \<noteq> {#} \<longrightarrow> negs (mset As0) = S DA0)"
         using a by blast
     }
     moreover
     {
       assume "S_M S M (D + negs (mset As)) = negs (mset As)"
       then have "negs (mset As) = S DA0 \<cdot> \<eta>0"
         using da \<open>S DA0 \<cdot> \<eta>0 = S_M S M DA\<close> by auto
       then have "\<exists>As0. negs (mset As0) = S DA0 \<and> As0 \<cdot>al \<eta>0 = As"
         using instance_list[of As "S DA0" \<eta>0] S.S_selects_neg_lits by auto
       then have "\<exists>As0. As0 \<cdot>al \<eta>0 = As \<and> negs (mset As0) \<subseteq># DA0
         \<and> (S_M S M (D + negs (mset As)) \<noteq> {#} \<longrightarrow> negs (mset As0) = S DA0)"
         using S.S_selects_subseteq by auto
     }
     ultimately have "\<exists>As0. As0 \<cdot>al \<eta>0 = As \<and> (negs (mset As0)) \<subseteq># DA0
       \<and> (S_M S M (D + negs (mset As)) \<noteq> {#} \<longrightarrow> negs (mset As0) = S DA0)"
       using eligible unfolding eligible.simps by auto
     then obtain As0 where
       As0_p: "As0 \<cdot>al \<eta>0 = As \<and> negs (mset As0) \<subseteq># DA0
       \<and> (S_M S M (D + negs (mset As)) \<noteq> {#} \<longrightarrow> negs (mset As0) = S DA0)"
       by blast
     then have "length As0 = n"
       using as_len by auto
     note n = n this
 
     have "As0 \<cdot>al \<eta>0 = As"
       using As0_p by auto
 
     define D0 where
       "D0 = DA0 - negs (mset As0)"
     then have "DA0 = D0 + negs (mset As0)"
       using As0_p by auto
     then have "D0 \<cdot> \<eta>0 = D"
       using DA0_to_DA da As0_p by auto
 
     have "S_M S M (D + negs (mset As)) \<noteq> {#} \<Longrightarrow> negs (mset As0) = S DA0"
       using As0_p by blast
     then show ?thesis
       using that \<open>As0 \<cdot>al \<eta>0 = As\<close> \<open>D0 \<cdot> \<eta>0= D\<close> \<open>DA0 = D0 +  (negs (mset As0))\<close> \<open>length As0 = n\<close>
       by metis
   qed
 
   show ?thesis
     using that[OF n(2,1) DA0_in_M  DA0_to_DA SDA0_to_SMDA CAs0_in_M CAs0_to_CAs SCAs0_to_SMCAs
         \<open>is_ground_subst \<eta>0\<close> \<open>is_ground_subst_list \<eta>s0\<close> \<open>As0  \<cdot>al \<eta>0 = As\<close>
         \<open>AAs0 \<cdot>\<cdot>aml \<eta>s0 = AAs\<close>
         \<open>length As0 = n\<close>
         \<open>D0 \<cdot> \<eta>0 = D\<close>
         \<open>DA0 = D0 + (negs (mset As0))\<close>
         \<open>S_M S M (D + negs (mset As)) \<noteq> {#} \<Longrightarrow> negs (mset As0) = S DA0\<close>
         \<open>length Cs0 = n\<close>
         \<open>Cs0 \<cdot>\<cdot>cl \<eta>s0 = Cs\<close>
         \<open>\<forall>i < n. CAs0 ! i = Cs0 ! i + poss (AAs0 ! i)\<close>
         \<open>length AAs0 = n\<close>]
     by auto
 qed
 
 lemma ord_resolve_rename_lifting:
   assumes
     sel_stable: "\<And>\<rho> C. is_renaming \<rho> \<Longrightarrow> S (C \<cdot> \<rho>) = S C \<cdot> \<rho>" and
     res_e: "ord_resolve (S_M S M) CAs DA AAs As \<sigma> E" and
     select: "selection S" and
     grounding: "{DA} \<union> set CAs \<subseteq> grounding_of_clss M"
   obtains \<eta>s \<eta> \<eta>2 CAs0 DA0 AAs0 As0 E0 \<tau> where
     "is_ground_subst \<eta>"
     "is_ground_subst_list \<eta>s"
     "is_ground_subst \<eta>2"
     "ord_resolve_rename S CAs0 DA0 AAs0 As0 \<tau> E0"
     "CAs0 \<cdot>\<cdot>cl \<eta>s = CAs" "DA0 \<cdot> \<eta> = DA" "E0 \<cdot> \<eta>2 = E"
     "{DA0} \<union> set CAs0 \<subseteq> M"
     "length CAs0 = length CAs"
     "length \<eta>s = length CAs"
   using res_e
 proof (cases rule: ord_resolve.cases)
   case (ord_resolve n Cs D)
   note da = this(1) and e = this(2) and cas_len = this(3) and cs_len = this(4) and
     aas_len = this(5) and as_len = this(6) and nz = this(7) and cas = this(8) and
     aas_not_empt = this(9) and mgu = this(10) and eligible = this(11) and str_max = this(12) and
     sel_empt = this(13)
 
   have sel_ren_list_inv:
     "\<And>\<rho>s Cs. length \<rho>s = length Cs \<Longrightarrow> is_renaming_list \<rho>s \<Longrightarrow> map S (Cs \<cdot>\<cdot>cl \<rho>s) = map S Cs \<cdot>\<cdot>cl \<rho>s"
     using sel_stable unfolding is_renaming_list_def by (auto intro: nth_equalityI)
 
   note n = \<open>n \<noteq> 0\<close> \<open>length CAs = n\<close> \<open>length Cs = n\<close> \<open>length AAs = n\<close> \<open>length As = n\<close>
 
   interpret S: selection S by (rule select)
 
   obtain DA0 \<eta>0 CAs0 \<eta>s0 As0 AAs0 D0 Cs0 where as0:
     "length CAs0 = n"
     "length \<eta>s0 = n"
     "DA0 \<in> M"
     "DA0 \<cdot> \<eta>0 = DA"
     "S DA0 \<cdot> \<eta>0 = S_M S M DA"
     "\<forall>CA0 \<in> set CAs0. CA0 \<in> M"
     "CAs0 \<cdot>\<cdot>cl \<eta>s0 = CAs"
     "map S CAs0 \<cdot>\<cdot>cl \<eta>s0 = map (S_M S M) CAs"
     "is_ground_subst \<eta>0"
     "is_ground_subst_list \<eta>s0"
     "As0 \<cdot>al \<eta>0 = As"
     "AAs0 \<cdot>\<cdot>aml \<eta>s0 = AAs"
     "length As0 = n"
     "D0 \<cdot> \<eta>0 = D"
     "DA0 = D0 + (negs (mset As0))"
     "S_M S M (D + negs (mset As)) \<noteq> {#} \<Longrightarrow> negs (mset As0) = S DA0"
     "length Cs0 = n"
     "Cs0 \<cdot>\<cdot>cl \<eta>s0 = Cs"
     "\<forall>i < n. CAs0 ! i = Cs0 ! i + poss (AAs0 ! i)"
     "length AAs0 = n"
     using ord_resolve_obtain_clauses[of S M CAs DA, OF res_e select grounding n(2) \<open>DA = D + negs (mset As)\<close>
       \<open>\<forall>i<n. CAs ! i = Cs ! i + poss (AAs ! i)\<close> \<open>length Cs = n\<close> \<open>length AAs = n\<close>, of thesis] by blast
 
   note n = \<open>length CAs0 = n\<close> \<open>length \<eta>s0 = n\<close> \<open>length As0 = n\<close> \<open>length AAs0 = n\<close> \<open>length Cs0 = n\<close> n
 
   have "length (renamings_apart (DA0 # CAs0)) = Suc n"
     using n renamings_apart_length by auto
 
   note n = this n
 
   define \<rho> where
     "\<rho> = hd (renamings_apart (DA0 # CAs0))"
   define \<rho>s where
     "\<rho>s = tl (renamings_apart (DA0 # CAs0))"
   define DA0' where
     "DA0' = DA0 \<cdot> \<rho>"
   define D0' where
     "D0' = D0 \<cdot> \<rho>"
   define As0' where
     "As0' = As0 \<cdot>al \<rho>"
   define CAs0' where
     "CAs0' = CAs0 \<cdot>\<cdot>cl \<rho>s"
   define Cs0' where
     "Cs0' = Cs0 \<cdot>\<cdot>cl \<rho>s"
   define AAs0' where
     "AAs0' = AAs0 \<cdot>\<cdot>aml \<rho>s"
   define \<eta>0' where
     "\<eta>0' = inv_renaming \<rho> \<odot> \<eta>0"
   define \<eta>s0' where
     "\<eta>s0' = map inv_renaming \<rho>s \<odot>s \<eta>s0"
 
   have renames_DA0: "is_renaming \<rho>"
     using renamings_apart_length renamings_apart_renaming unfolding \<rho>_def
     by (metis length_greater_0_conv list.exhaust_sel list.set_intros(1) list.simps(3))
 
   have renames_CAs0: "is_renaming_list \<rho>s"
     using renamings_apart_length renamings_apart_renaming unfolding \<rho>s_def
     by (metis is_renaming_list_def length_greater_0_conv list.set_sel(2) list.simps(3))
 
   have "length \<rho>s = n"
     unfolding \<rho>s_def using n by auto
   note n = n \<open>length \<rho>s = n\<close>
   have "length As0' = n"
     unfolding As0'_def using n by auto
   have "length CAs0' = n"
     using as0(1) n unfolding CAs0'_def by auto
   have "length Cs0' = n"
     unfolding Cs0'_def using n by auto
   have "length AAs0' = n"
     unfolding AAs0'_def using n by auto
   have "length \<eta>s0' = n"
     using as0(2) n unfolding \<eta>s0'_def by auto
   note n = \<open>length CAs0' = n\<close> \<open>length \<eta>s0' = n\<close> \<open>length As0' = n\<close> \<open>length AAs0' = n\<close> \<open>length Cs0' = n\<close> n
 
   have DA0'_DA: "DA0' \<cdot> \<eta>0' = DA"
     using as0(4) unfolding \<eta>0'_def DA0'_def using renames_DA0 by simp
   have D0'_D: "D0' \<cdot> \<eta>0' = D"
     using as0(14) unfolding \<eta>0'_def D0'_def using renames_DA0 by simp
   have As0'_As: "As0' \<cdot>al \<eta>0' = As"
     using as0(11) unfolding \<eta>0'_def As0'_def using renames_DA0 by auto
   have "S DA0' \<cdot> \<eta>0' = S_M S M DA"
     using as0(5) unfolding \<eta>0'_def DA0'_def using renames_DA0 sel_stable by auto
   have CAs0'_CAs: "CAs0' \<cdot>\<cdot>cl \<eta>s0' = CAs"
     using as0(7) unfolding CAs0'_def \<eta>s0'_def using renames_CAs0 n by auto
   have Cs0'_Cs: "Cs0' \<cdot>\<cdot>cl \<eta>s0' = Cs"
     using as0(18) unfolding Cs0'_def \<eta>s0'_def using renames_CAs0 n by auto
   have AAs0'_AAs: "AAs0' \<cdot>\<cdot>aml \<eta>s0' = AAs"
     using as0(12) unfolding \<eta>s0'_def AAs0'_def using renames_CAs0 using n by auto
   have "map S CAs0' \<cdot>\<cdot>cl \<eta>s0' = map (S_M S M) CAs"
     unfolding CAs0'_def \<eta>s0'_def using as0(8) n renames_CAs0 sel_ren_list_inv by auto
 
   have DA0'_split: "DA0' = D0' + negs (mset As0')"
     using as0(15) DA0'_def D0'_def As0'_def by auto
   then have D0'_subset_DA0': "D0' \<subseteq># DA0'"
     by auto
   from DA0'_split have negs_As0'_subset_DA0': "negs (mset As0') \<subseteq># DA0'"
     by auto
 
   have CAs0'_split: "\<forall>i<n. CAs0' ! i = Cs0' ! i + poss (AAs0' ! i)"
     using as0(19) CAs0'_def Cs0'_def AAs0'_def n by auto
   then have "\<forall>i<n. Cs0' ! i \<subseteq># CAs0' ! i"
     by auto
   from CAs0'_split have poss_AAs0'_subset_CAs0': "\<forall>i<n. poss (AAs0' ! i) \<subseteq># CAs0' ! i"
     by auto
   then have AAs0'_in_atms_of_CAs0': "\<forall>i < n. \<forall>A\<in>#AAs0' ! i. A \<in> atms_of (CAs0' ! i)"
     by (auto simp add: atm_iff_pos_or_neg_lit)
 
   have as0':
     "S_M S M (D + negs (mset As)) \<noteq> {#} \<Longrightarrow> negs (mset As0') = S DA0'"
   proof -
     assume a: "S_M S M (D + negs (mset As)) \<noteq> {#}"
     then have "negs (mset As0) \<cdot> \<rho> = S DA0 \<cdot> \<rho>"
       using as0(16) unfolding \<rho>_def by metis
     then show "negs (mset As0') = S DA0'"
       using  As0'_def DA0'_def using sel_stable[of \<rho> DA0] renames_DA0 by auto
   qed
 
   have vd: "var_disjoint (DA0' # CAs0')"
     unfolding DA0'_def CAs0'_def using renamings_apart_var_disjoint
     unfolding \<rho>_def \<rho>s_def
     by (metis length_greater_0_conv list.exhaust_sel n(6) substitution.subst_cls_lists_Cons
         substitution_axioms zero_less_Suc)
 
   \<comment> \<open>Introduce ground substitution\<close>
   from vd DA0'_DA CAs0'_CAs have "\<exists>\<eta>. \<forall>i < Suc n. \<forall>S. S \<subseteq># (DA0' # CAs0') ! i \<longrightarrow> S \<cdot> (\<eta>0'#\<eta>s0') ! i = S \<cdot> \<eta>"
     unfolding var_disjoint_def using n by auto
   then obtain \<eta> where \<eta>_p: "\<forall>i < Suc n. \<forall>S. S \<subseteq># (DA0' # CAs0') ! i \<longrightarrow> S \<cdot> (\<eta>0'#\<eta>s0') ! i = S \<cdot> \<eta>"
     by auto
   have \<eta>_p_lit: "\<forall>i < Suc n. \<forall>L. L \<in># (DA0' # CAs0') ! i \<longrightarrow> L \<cdot>l (\<eta>0'#\<eta>s0') ! i = L \<cdot>l \<eta>"
   proof (rule, rule, rule, rule)
     fix i :: "nat" and L :: "'a literal"
     assume a:
       "i < Suc n"
       "L \<in># (DA0' # CAs0') ! i"
     then have "\<forall>S. S \<subseteq># (DA0' # CAs0') ! i \<longrightarrow> S \<cdot> (\<eta>0' # \<eta>s0') ! i = S \<cdot> \<eta>"
       using \<eta>_p by auto
     then have "{# L #} \<cdot> (\<eta>0' # \<eta>s0') ! i = {# L #} \<cdot> \<eta>"
       using a by (meson single_subset_iff)
     then show "L \<cdot>l (\<eta>0' # \<eta>s0') ! i = L \<cdot>l \<eta>" by auto
   qed
   have \<eta>_p_atm: "\<forall>i < Suc n. \<forall>A. A \<in> atms_of ((DA0' # CAs0') ! i) \<longrightarrow> A \<cdot>a (\<eta>0'#\<eta>s0') ! i = A \<cdot>a \<eta>"
   proof (rule, rule, rule, rule)
     fix i :: "nat" and A :: "'a"
     assume a:
       "i < Suc n"
       "A \<in> atms_of ((DA0' # CAs0') ! i)"
     then obtain L where L_p: "atm_of L = A \<and> L \<in># (DA0' # CAs0') ! i"
       unfolding atms_of_def by auto
     then have "L \<cdot>l (\<eta>0'#\<eta>s0') ! i = L \<cdot>l \<eta>"
       using \<eta>_p_lit a by auto
     then show "A \<cdot>a (\<eta>0' # \<eta>s0') ! i = A \<cdot>a \<eta>"
       using L_p unfolding subst_lit_def by (cases L) auto
   qed
 
   have DA0'_DA: "DA0' \<cdot> \<eta> = DA"
     using DA0'_DA \<eta>_p by auto
   have "D0' \<cdot> \<eta> = D" using \<eta>_p D0'_D n D0'_subset_DA0' by auto
   have "As0' \<cdot>al \<eta> = As"
   proof (rule nth_equalityI)
     show "length (As0' \<cdot>al \<eta>) = length As"
       using n by auto
   next
     fix i
     show "i<length (As0' \<cdot>al \<eta>) \<Longrightarrow> (As0' \<cdot>al \<eta>) ! i = As ! i"
     proof -
       assume a: "i < length (As0' \<cdot>al \<eta>)"
       have A_eq: "\<forall>A. A \<in> atms_of DA0' \<longrightarrow> A \<cdot>a \<eta>0' = A \<cdot>a \<eta>"
         using \<eta>_p_atm n by force
       have "As0' ! i \<in> atms_of DA0'"
         using negs_As0'_subset_DA0' unfolding atms_of_def
         using a n by force
       then have "As0' ! i \<cdot>a \<eta>0' = As0' ! i \<cdot>a \<eta>"
          using A_eq by simp
       then show "(As0' \<cdot>al \<eta>) ! i = As ! i"
         using As0'_As \<open>length As0' = n\<close> a by auto
     qed
   qed
 
   interpret selection
     by (rule select)
 
   have "S DA0' \<cdot> \<eta> = S_M S M DA"
     using \<open>S DA0' \<cdot> \<eta>0' = S_M S M DA\<close> \<eta>_p S.S_selects_subseteq by auto
 
   from \<eta>_p have \<eta>_p_CAs0': "\<forall>i < n. (CAs0' ! i) \<cdot> (\<eta>s0' ! i) = (CAs0'! i) \<cdot> \<eta>"
     using n by auto
   then have "CAs0' \<cdot>\<cdot>cl \<eta>s0' = CAs0' \<cdot>cl \<eta>"
     using n by (auto intro: nth_equalityI)
   then have CAs0'_\<eta>_fo_CAs: "CAs0' \<cdot>cl \<eta> = CAs"
     using CAs0'_CAs \<eta>_p n by auto
 
   from \<eta>_p have "\<forall>i < n. S (CAs0' ! i) \<cdot> \<eta>s0' ! i = S (CAs0' ! i) \<cdot> \<eta>"
     using S.S_selects_subseteq n by auto
   then have "map S CAs0' \<cdot>\<cdot>cl \<eta>s0' = map S CAs0' \<cdot>cl \<eta>"
     using n by (auto intro: nth_equalityI)
   then have SCAs0'_\<eta>_fo_SMCAs: "map S CAs0' \<cdot>cl \<eta> = map (S_M S M) CAs"
     using \<open>map S CAs0' \<cdot>\<cdot>cl \<eta>s0' = map (S_M S M) CAs\<close> by auto
 
   have "Cs0' \<cdot>cl \<eta> = Cs"
   proof (rule nth_equalityI)
     show "length (Cs0' \<cdot>cl \<eta>) = length Cs"
       using n by auto
   next
     fix i
     show "i<length (Cs0' \<cdot>cl \<eta>) \<Longrightarrow> (Cs0' \<cdot>cl \<eta>) ! i = Cs ! i"
     proof -
       assume "i < length (Cs0' \<cdot>cl \<eta>)"
       then have a: "i < n"
         using n by force
       have "(Cs0' \<cdot>\<cdot>cl \<eta>s0') ! i = Cs ! i"
         using Cs0'_Cs a n by force
       moreover
       have \<eta>_p_CAs0': "\<forall>S. S \<subseteq># CAs0' ! i \<longrightarrow> S \<cdot> \<eta>s0' ! i = S \<cdot> \<eta>"
         using \<eta>_p a by force
       have "Cs0' ! i \<cdot> \<eta>s0' ! i = (Cs0' \<cdot>cl \<eta>) ! i"
         using \<eta>_p_CAs0' \<open>\<forall>i<n. Cs0' ! i \<subseteq># CAs0' ! i\<close> a n by force
       then have "(Cs0' \<cdot>\<cdot>cl \<eta>s0') ! i = (Cs0' \<cdot>cl \<eta>) ! i "
         using a n by force
       ultimately show "(Cs0' \<cdot>cl \<eta>) ! i = Cs ! i"
         by auto
     qed
   qed
 
   have AAs0'_AAs: "AAs0' \<cdot>aml \<eta> = AAs"
   proof (rule nth_equalityI)
     show "length (AAs0' \<cdot>aml \<eta>) = length AAs"
       using n by auto
   next
     fix i
     show "i<length (AAs0' \<cdot>aml \<eta>) \<Longrightarrow> (AAs0' \<cdot>aml \<eta>) ! i = AAs ! i"
     proof -
       assume a: "i < length (AAs0' \<cdot>aml \<eta>)"
       then have "i < n"
         using n by force
       then have "\<forall>A. A \<in> atms_of ((DA0' # CAs0') ! Suc i) \<longrightarrow> A \<cdot>a (\<eta>0' # \<eta>s0') ! Suc i = A \<cdot>a \<eta>"
         using \<eta>_p_atm n by force
       then have A_eq: "\<forall>A. A \<in> atms_of (CAs0' ! i) \<longrightarrow> A \<cdot>a \<eta>s0' ! i = A \<cdot>a \<eta>"
         by auto
       have AAs_CAs0': "\<forall>A \<in># AAs0' ! i. A \<in> atms_of (CAs0' ! i)"
         using AAs0'_in_atms_of_CAs0' unfolding atms_of_def
         using a n by force
       then have "AAs0' ! i \<cdot>am  \<eta>s0' ! i = AAs0' ! i \<cdot>am \<eta>"
         unfolding subst_atm_mset_def using A_eq unfolding subst_atm_mset_def by auto
       then show "(AAs0' \<cdot>aml \<eta>) ! i = AAs ! i"
          using AAs0'_AAs \<open>length AAs0' = n\<close> \<open>length \<eta>s0' = n\<close> a by auto
     qed
   qed
 
   \<comment> \<open>Obtain MGU and substitution\<close>
   obtain \<tau> \<phi> where \<tau>\<phi>:
     "Some \<tau> = mgu (set_mset ` set (map2 add_mset As0' AAs0'))"
     "\<tau> \<odot> \<phi> = \<eta> \<odot> \<sigma>"
   proof -
     have uu: "is_unifiers \<sigma> (set_mset ` set (map2 add_mset (As0' \<cdot>al \<eta>) (AAs0' \<cdot>aml \<eta>)))"
       using mgu mgu_sound is_mgu_def unfolding \<open>AAs0' \<cdot>aml \<eta> = AAs\<close> using \<open>As0' \<cdot>al \<eta> = As\<close> by auto
     have \<eta>\<sigma>uni: "is_unifiers (\<eta> \<odot> \<sigma>) (set_mset ` set (map2 add_mset As0' AAs0'))"
     proof -
       have "set_mset ` set (map2 add_mset As0' AAs0' \<cdot>aml \<eta>) =
         set_mset ` set (map2 add_mset As0' AAs0') \<cdot>ass \<eta>"
         unfolding subst_atmss_def subst_atm_mset_list_def using subst_atm_mset_def subst_atms_def
         by (simp add: image_image subst_atm_mset_def subst_atms_def)
       then have "is_unifiers \<sigma> (set_mset ` set (map2 add_mset As0' AAs0') \<cdot>ass \<eta>)"
         using uu by (auto simp: n map2_add_mset_map)
       then show ?thesis
         using is_unifiers_comp by auto
     qed
     then obtain \<tau> where
       \<tau>_p: "Some \<tau> = mgu (set_mset ` set (map2 add_mset As0' AAs0'))"
       using mgu_complete
       by (metis (mono_tags, hide_lams) List.finite_set finite_imageI finite_set_mset image_iff)
     moreover then obtain \<phi> where \<phi>_p: "\<tau> \<odot> \<phi> = \<eta> \<odot> \<sigma>"
       by (metis (mono_tags, hide_lams) finite_set \<eta>\<sigma>uni finite_imageI finite_set_mset image_iff
           mgu_sound set_mset_mset substitution_ops.is_mgu_def) (* should be simpler *)
     ultimately show thesis
       using that by auto
   qed
 
   \<comment> \<open>Lifting eligibility\<close>
   have eligible0': "eligible S \<tau> As0' (D0' + negs (mset As0'))"
   proof -
     have "S_M S M (D + negs (mset As)) = negs (mset As) \<or> S_M S M (D + negs (mset As)) = {#} \<and>
       length As = 1 \<and> maximal_wrt (As ! 0 \<cdot>a \<sigma>) ((D + negs (mset As)) \<cdot> \<sigma>)"
       using eligible unfolding eligible.simps by auto
     then show ?thesis
     proof
       assume "S_M S M (D + negs (mset As)) = negs (mset As)"
       then have "S_M S M (D + negs (mset As)) \<noteq> {#}"
         using n by force
       then have "S (D0' + negs (mset As0')) = negs (mset As0')"
         using as0' DA0'_split by auto
       then show ?thesis
         unfolding eligible.simps[simplified]  by auto
     next
       assume asm: "S_M S M (D + negs (mset As)) = {#} \<and> length As = 1 \<and>
         maximal_wrt (As ! 0 \<cdot>a \<sigma>) ((D + negs (mset As)) \<cdot> \<sigma>)"
       then have "S (D0' + negs (mset As0')) = {#}"
         using \<open>D0' \<cdot> \<eta> = D\<close>[symmetric] \<open>As0' \<cdot>al \<eta> = As\<close>[symmetric] \<open>S (DA0') \<cdot> \<eta> = S_M S M (DA)\<close>
           da DA0'_split subst_cls_empty_iff by metis
       moreover from asm have l: "length As0' = 1"
         using \<open>As0' \<cdot>al \<eta> = As\<close> by auto
       moreover from asm have "maximal_wrt (As0' ! 0 \<cdot>a (\<tau> \<odot> \<phi>)) ((D0' + negs (mset As0')) \<cdot> (\<tau> \<odot> \<phi>))"
         using \<open>As0' \<cdot>al \<eta> = As\<close> \<open>D0' \<cdot> \<eta> = D\<close> using l \<tau>\<phi> by auto
       then have "maximal_wrt (As0' ! 0 \<cdot>a \<tau> \<cdot>a \<phi>) ((D0' + negs (mset As0')) \<cdot> \<tau> \<cdot> \<phi>)"
         by auto
       then have "maximal_wrt (As0' ! 0 \<cdot>a \<tau>) ((D0' + negs (mset As0')) \<cdot> \<tau>)"
         using maximal_wrt_subst by blast
       ultimately show ?thesis
         unfolding eligible.simps[simplified] by auto
     qed
   qed
 
   \<comment> \<open>Lifting maximality\<close>
   have maximality: "\<forall>i < n. strictly_maximal_wrt (As0' ! i \<cdot>a \<tau>) (Cs0' ! i \<cdot> \<tau>)"
     (* Reformulate in list notation? *)
   proof -
     from str_max have "\<forall>i < n. strictly_maximal_wrt ((As0' \<cdot>al \<eta>) ! i \<cdot>a \<sigma>) ((Cs0' \<cdot>cl \<eta>) ! i \<cdot> \<sigma>)"
       using \<open>As0' \<cdot>al \<eta> = As\<close>  \<open>Cs0' \<cdot>cl \<eta> = Cs\<close> by simp
     then have "\<forall>i < n. strictly_maximal_wrt (As0' ! i \<cdot>a (\<tau> \<odot> \<phi>)) (Cs0' ! i \<cdot> (\<tau> \<odot> \<phi>))"
       using n \<tau>\<phi> by simp
     then have "\<forall>i < n. strictly_maximal_wrt (As0' ! i \<cdot>a \<tau> \<cdot>a \<phi>) (Cs0' ! i \<cdot> \<tau> \<cdot> \<phi>)"
       by auto
     then show "\<forall>i < n. strictly_maximal_wrt (As0' ! i \<cdot>a \<tau>) (Cs0' ! i \<cdot> \<tau>)"
       using strictly_maximal_wrt_subst \<tau>\<phi> by blast
   qed
 
   \<comment> \<open>Lifting nothing being selected\<close>
   have nothing_selected: "\<forall>i < n. S (CAs0' ! i) = {#}"
   proof -
     have "\<forall>i < n. (map S CAs0' \<cdot>cl \<eta>) ! i = map (S_M S M) CAs ! i"
       by (simp add: \<open>map S CAs0' \<cdot>cl \<eta> = map (S_M S M) CAs\<close>)
     then have "\<forall>i < n. S (CAs0' ! i) \<cdot> \<eta> = S_M S M (CAs ! i)"
       using n by auto
     then have "\<forall>i < n. S (CAs0' ! i)  \<cdot> \<eta> = {#}"
       using sel_empt \<open>\<forall>i < n.  S (CAs0' ! i) \<cdot> \<eta> = S_M S M (CAs ! i)\<close> by auto
     then show "\<forall>i < n. S (CAs0' ! i) = {#}"
       using subst_cls_empty_iff by blast
   qed
 
   \<comment> \<open>Lifting AAs0's non-emptiness\<close>
   have "\<forall>i < n. AAs0' ! i \<noteq> {#}"
     using n aas_not_empt \<open>AAs0' \<cdot>aml \<eta> = AAs\<close> by auto
 
   \<comment> \<open>Resolve the lifted clauses\<close>
   define E0' where
-    "E0' = ((\<Union># (mset Cs0')) + D0') \<cdot> \<tau>"
+    "E0' = ((\<Sum>\<^sub># (mset Cs0')) + D0') \<cdot> \<tau>"
 
   have res_e0': "ord_resolve S CAs0' DA0' AAs0' As0' \<tau> E0'"
     using ord_resolve.intros[of CAs0' n Cs0' AAs0' As0' \<tau> S D0',
       OF _ _ _ _ _ _ \<open>\<forall>i < n. AAs0' ! i \<noteq> {#}\<close> \<tau>\<phi>(1) eligible0'
         \<open>\<forall>i < n. strictly_maximal_wrt (As0' ! i \<cdot>a \<tau>) (Cs0' ! i \<cdot> \<tau>)\<close> \<open>\<forall>i < n. S (CAs0' ! i) = {#}\<close>]
     unfolding E0'_def using DA0'_split n \<open>\<forall>i<n. CAs0' ! i = Cs0' ! i + poss (AAs0' ! i)\<close> by blast
 
   \<comment> \<open>Prove resolvent instantiates to ground resolvent\<close>
   have e0'\<phi>e: "E0' \<cdot> \<phi> = E"
   proof -
-    have "E0' \<cdot> \<phi> = ((\<Union># (mset Cs0')) + D0') \<cdot> (\<tau> \<odot> \<phi>)"
+    have "E0' \<cdot> \<phi> = ((\<Sum>\<^sub># (mset Cs0')) + D0') \<cdot> (\<tau> \<odot> \<phi>)"
       unfolding E0'_def by auto
-    also have "\<dots> = (\<Union># (mset Cs0') + D0') \<cdot> (\<eta> \<odot> \<sigma>)"
+    also have "\<dots> = (\<Sum>\<^sub># (mset Cs0') + D0') \<cdot> (\<eta> \<odot> \<sigma>)"
       using \<tau>\<phi> by auto
-    also have "\<dots> = (\<Union># (mset Cs) + D) \<cdot> \<sigma>"
+    also have "\<dots> = (\<Sum>\<^sub># (mset Cs) + D) \<cdot> \<sigma>"
       using \<open>Cs0' \<cdot>cl \<eta> = Cs\<close> \<open>D0' \<cdot> \<eta> = D\<close> by auto
     also have "\<dots> = E"
       using e by auto
     finally show e0'\<phi>e: "E0' \<cdot> \<phi> = E"
       .
   qed
 
   \<comment> \<open>Replace @{term \<phi>} with a true ground substitution\<close>
   obtain \<eta>2 where
     ground_\<eta>2: "is_ground_subst \<eta>2" "E0' \<cdot> \<eta>2 = E"
   proof -
     have "is_ground_cls_list CAs" "is_ground_cls DA"
       using grounding grounding_ground unfolding is_ground_cls_list_def by auto
     then have "is_ground_cls E"
       using res_e ground_resolvent_subset by (force intro: is_ground_cls_mono)
     then show thesis
       using that e0'\<phi>e make_ground_subst by auto
   qed
 
   have \<open>length CAs0 = length CAs\<close>
     using n by simp
 
   have \<open>length \<eta>s0 = length CAs\<close>
     using n by simp
 
   \<comment> \<open>Wrap up the proof\<close>
   have "ord_resolve S (CAs0 \<cdot>\<cdot>cl \<rho>s) (DA0 \<cdot> \<rho>) (AAs0 \<cdot>\<cdot>aml \<rho>s) (As0 \<cdot>al \<rho>) \<tau> E0'"
     using res_e0' As0'_def \<rho>_def AAs0'_def \<rho>s_def DA0'_def \<rho>_def CAs0'_def \<rho>s_def by simp
   moreover have "\<forall>i<n. poss (AAs0 ! i) \<subseteq># CAs0 ! i"
     using as0(19) by auto
   moreover have "negs (mset As0) \<subseteq># DA0"
     using local.as0(15) by auto
   ultimately have "ord_resolve_rename S CAs0 DA0 AAs0 As0 \<tau> E0'"
     using ord_resolve_rename[of CAs0 n AAs0 As0 DA0 \<rho> \<rho>s S \<tau> E0'] \<rho>_def \<rho>s_def n by auto
   then show thesis
     using that[of \<eta>0 \<eta>s0 \<eta>2 CAs0 DA0] \<open>is_ground_subst \<eta>0\<close> \<open>is_ground_subst_list \<eta>s0\<close>
       \<open>is_ground_subst \<eta>2\<close> \<open>CAs0 \<cdot>\<cdot>cl \<eta>s0 = CAs\<close> \<open>DA0 \<cdot> \<eta>0 = DA\<close> \<open>E0' \<cdot> \<eta>2 = E\<close> \<open>DA0 \<in> M\<close>
       \<open>\<forall>CA \<in> set CAs0. CA \<in> M\<close> \<open>length CAs0 = length CAs\<close> \<open>length \<eta>s0 = length CAs\<close>
     by blast
 qed
 
 lemma ground_ord_resolve_ground:
   assumes
     select: "selection S" and
     CAs_p: "ground_resolution_with_selection.ord_resolve S CAs DA AAs As E" and
     ground_cas: "is_ground_cls_list CAs" and
     ground_da: "is_ground_cls DA"
   shows "is_ground_cls E"
 proof -
   have a1: "atms_of E \<subseteq> (\<Union>CA \<in> set CAs. atms_of CA) \<union> atms_of DA"
     using ground_resolution_with_selection.ord_resolve_atms_of_concl_subset[OF _ CAs_p]
       ground_resolution_with_selection.intro[OF select] by blast
   {
     fix L :: "'a literal"
     assume "L \<in># E"
     then have "atm_of L \<in> atms_of E"
       by (meson atm_of_lit_in_atms_of)
     then have "is_ground_atm (atm_of L)"
       using a1 ground_cas ground_da is_ground_cls_imp_is_ground_atm is_ground_cls_list_def
       by auto
   }
   then show ?thesis
     unfolding is_ground_cls_def is_ground_lit_def by simp
 qed
 
 lemma ground_ord_resolve_imp_ord_resolve:
   assumes
     ground_da: \<open>is_ground_cls DA\<close> and
     ground_cas: \<open>is_ground_cls_list CAs\<close> and
     gr: "ground_resolution_with_selection S_G" and
     gr_res: \<open>ground_resolution_with_selection.ord_resolve S_G CAs DA AAs As E\<close>
   shows \<open>\<exists>\<sigma>. ord_resolve S_G CAs DA AAs As \<sigma> E\<close>
 proof (cases rule: ground_resolution_with_selection.ord_resolve.cases[OF gr gr_res])
   case (1 CAs n Cs AAs As D)
   note cas = this(1) and da = this(2) and aas = this(3) and as = this(4) and e = this(5) and
     cas_len = this(6) and cs_len = this(7) and aas_len = this(8) and as_len = this(9) and
     nz = this(10) and casi = this(11) and aas_not_empt = this(12) and as_aas = this(13) and
     eligibility = this(14) and str_max = this(15) and sel_empt = this(16)
 
   have len_aas_len_as: "length AAs = length As"
     using aas_len as_len by auto
 
   from as_aas have "\<forall>i < n. \<forall>A \<in># add_mset (As ! i) (AAs ! i). A = As ! i"
     by simp
   then have "\<forall>i < n. card (set_mset (add_mset (As ! i) (AAs ! i))) \<le> Suc 0"
     using all_the_same by metis
   then have "\<forall>i < length AAs. card (set_mset (add_mset (As ! i) (AAs ! i))) \<le> Suc 0"
     using aas_len by auto
   then have "\<forall>AA \<in> set (map2 add_mset As AAs). card (set_mset AA) \<le> Suc 0"
     using set_map2_ex[of AAs As add_mset, OF len_aas_len_as] by auto
   then have "is_unifiers id_subst (set_mset ` set (map2 add_mset As AAs))"
     unfolding is_unifiers_def is_unifier_def by auto
   moreover have "finite (set_mset ` set (map2 add_mset As AAs))"
     by auto
   moreover have "\<forall>AA \<in> set_mset ` set (map2 add_mset As AAs). finite AA"
     by auto
   ultimately obtain \<sigma> where
     \<sigma>_p: "Some \<sigma> = mgu (set_mset ` set (map2 add_mset As AAs))"
     using mgu_complete by metis
 
   have ground_elig: "ground_resolution_with_selection.eligible S_G As (D + negs (mset As))"
     using eligibility by simp
   have ground_cs: "\<forall>i < n. is_ground_cls (Cs ! i)"
     using cas cas_len cs_len casi ground_cas nth_mem unfolding is_ground_cls_list_def by force
   have ground_set_as: "is_ground_atms (set As)"
     using da ground_da by (metis atms_of_negs is_ground_cls_is_ground_atms_atms_of
         is_ground_cls_union set_mset_mset)
   then have ground_mset_as: "is_ground_atm_mset (mset As)"
     unfolding is_ground_atm_mset_def is_ground_atms_def by auto
   have ground_as: "is_ground_atm_list As"
     using ground_set_as is_ground_atm_list_def is_ground_atms_def by auto
   have ground_d: "is_ground_cls D"
     using ground_da da by simp
 
   from as_len nz have atms:
     "atms_of D \<union> set As \<noteq> {}"
     "finite (atms_of D \<union> set As)"
     by auto
   then have "Max (atms_of D \<union> set As) \<in> atms_of D \<union> set As"
     using Max_in by metis
   then have is_ground_Max: "is_ground_atm (Max (atms_of D \<union> set As))"
     using ground_d ground_mset_as is_ground_cls_imp_is_ground_atm
     unfolding is_ground_atm_mset_def by auto
 
   have "maximal_wrt (Max (atms_of D \<union> set As)) (D + negs (mset As))"
     unfolding maximal_wrt_def
     by clarsimp (metis atms Max_less_iff UnCI ground_d ground_set_as infinite_growing
         is_ground_Max is_ground_atms_def is_ground_cls_imp_is_ground_atm less_atm_ground)
   moreover have
     "Max (atms_of D \<union> set As) \<cdot>a \<sigma> = Max (atms_of D \<union> set As)" and
     "D \<cdot> \<sigma> + negs (mset As \<cdot>am \<sigma>) = D + negs (mset As)"
     using ground_elig is_ground_Max ground_mset_as ground_d by auto
   ultimately have fo_elig: "eligible S_G \<sigma> As (D + negs (mset As))"
     using ground_elig unfolding ground_resolution_with_selection.eligible.simps[OF gr]
       ground_resolution_with_selection.maximal_wrt_def[OF gr] eligible.simps
     by auto
 
   have "\<forall>i < n. strictly_maximal_wrt (As ! i) (Cs ! i)"
     using str_max[unfolded ground_resolution_with_selection.strictly_maximal_wrt_def[OF gr]]
       ground_as[unfolded is_ground_atm_list_def] ground_cs as_len less_atm_ground
     unfolding strictly_maximal_wrt_def by clarsimp (fastforce simp: is_ground_cls_as_atms)+
   then have ll: "\<forall>i < n. strictly_maximal_wrt (As ! i \<cdot>a \<sigma>) (Cs ! i \<cdot> \<sigma>)"
     by (simp add: ground_as ground_cs as_len)
 
   have ground_e: "is_ground_cls E"
     using ground_d ground_cs cs_len unfolding e is_ground_cls_def
     by simp (metis in_mset_sum_list2 in_set_conv_nth)
 
   show ?thesis
     using cas da aas as e ground_e ord_resolve.intros[OF cas_len cs_len aas_len as_len nz casi
         aas_not_empt \<sigma>_p fo_elig ll sel_empt]
     by auto
 qed
 
 end
 
 end
diff --git a/thys/Ordered_Resolution_Prover/Herbrand_Interpretation.thy b/thys/Ordered_Resolution_Prover/Herbrand_Interpretation.thy
--- a/thys/Ordered_Resolution_Prover/Herbrand_Interpretation.thy
+++ b/thys/Ordered_Resolution_Prover/Herbrand_Interpretation.thy
@@ -1,143 +1,143 @@
 (*  Title:       Herbrand Interpretation
     Author:      Jasmin Blanchette <j.c.blanchette at vu.nl>, 2014, 2017
     Author:      Dmitriy Traytel <traytel at inf.ethz.ch>, 2014
     Maintainer:  Jasmin Blanchette <j.c.blanchette at vu.nl>
 *)
 
 section \<open>Herbrand Intepretation\<close>
 
 theory Herbrand_Interpretation
   imports Clausal_Logic
 begin
 
 text \<open>
 The material formalized here corresponds roughly to Sections 2.2 (``Herbrand
 Interpretations'') of Bachmair and Ganzinger, excluding the formula and term
 syntax.
 
 A Herbrand interpretation is a set of ground atoms that are to be considered true.
 \<close>
 
 type_synonym 'a interp = "'a set"
 
 definition true_lit :: "'a interp \<Rightarrow> 'a literal \<Rightarrow> bool" (infix "\<Turnstile>l" 50) where
   "I \<Turnstile>l L \<longleftrightarrow> (if is_pos L then (\<lambda>P. P) else Not) (atm_of L \<in> I)"
 
 lemma true_lit_simps[simp]:
   "I \<Turnstile>l Pos A \<longleftrightarrow> A \<in> I"
   "I \<Turnstile>l Neg A \<longleftrightarrow> A \<notin> I"
   unfolding true_lit_def by auto
 
 lemma true_lit_iff[iff]: "I \<Turnstile>l L \<longleftrightarrow> (\<exists>A. L = Pos A \<and> A \<in> I \<or> L = Neg A \<and> A \<notin> I)"
   by (cases L) simp+
 
 definition true_cls :: "'a interp \<Rightarrow> 'a clause \<Rightarrow> bool" (infix "\<Turnstile>" 50) where
   "I \<Turnstile> C \<longleftrightarrow> (\<exists>L \<in># C. I \<Turnstile>l L)"
 
 lemma true_cls_empty[iff]: "\<not> I \<Turnstile> {#}"
   unfolding true_cls_def by simp
 
 lemma true_cls_singleton[iff]: "I \<Turnstile> {#L#} \<longleftrightarrow> I \<Turnstile>l L"
   unfolding true_cls_def by simp
 
 lemma true_cls_add_mset[iff]: "I \<Turnstile> add_mset C D \<longleftrightarrow> I \<Turnstile>l C \<or> I \<Turnstile> D"
   unfolding true_cls_def by auto
 
 lemma true_cls_union[iff]: "I \<Turnstile> C + D \<longleftrightarrow> I \<Turnstile> C \<or> I \<Turnstile> D"
   unfolding true_cls_def by auto
 
 lemma true_cls_mono: "set_mset C \<subseteq> set_mset D \<Longrightarrow> I \<Turnstile> C \<Longrightarrow> I \<Turnstile> D"
   unfolding true_cls_def subset_eq by metis
 
 lemma
   assumes "I \<subseteq> J"
   shows
     false_to_true_imp_ex_pos: "\<not> I \<Turnstile> C \<Longrightarrow> J \<Turnstile> C \<Longrightarrow> \<exists>A \<in> J. Pos A \<in># C" and
     true_to_false_imp_ex_neg: "I \<Turnstile> C \<Longrightarrow> \<not> J \<Turnstile> C \<Longrightarrow> \<exists>A \<in> J. Neg A \<in># C"
   using assms unfolding subset_iff true_cls_def by (metis literal.collapse true_lit_simps)+
 
 lemma true_cls_replicate_mset[iff]: "I \<Turnstile> replicate_mset n L \<longleftrightarrow> n \<noteq> 0 \<and> I \<Turnstile>l L"
   by (simp add: true_cls_def)
 
 lemma pos_literal_in_imp_true_cls[intro]: "Pos A \<in># C \<Longrightarrow> A \<in> I \<Longrightarrow> I \<Turnstile> C"
   using true_cls_def by blast
 
 lemma neg_literal_notin_imp_true_cls[intro]: "Neg A \<in># C \<Longrightarrow> A \<notin> I \<Longrightarrow> I \<Turnstile> C"
   using true_cls_def by blast
 
 lemma pos_neg_in_imp_true: "Pos A \<in># C \<Longrightarrow> Neg A \<in># C \<Longrightarrow> I \<Turnstile> C"
   using true_cls_def by blast
 
 definition true_clss :: "'a interp \<Rightarrow> 'a clause set \<Rightarrow> bool" (infix "\<Turnstile>s" 50) where
   "I \<Turnstile>s CC \<longleftrightarrow> (\<forall>C \<in> CC. I \<Turnstile> C)"
 
 lemma true_clss_empty[iff]: "I \<Turnstile>s {}"
   by (simp add: true_clss_def)
 
 lemma true_clss_singleton[iff]: "I \<Turnstile>s {C} \<longleftrightarrow> I \<Turnstile> C"
   unfolding true_clss_def by blast
 
 lemma true_clss_insert[iff]: "I \<Turnstile>s insert C DD \<longleftrightarrow> I \<Turnstile> C \<and> I \<Turnstile>s DD"
   unfolding true_clss_def by blast
 
 lemma true_clss_union[iff]: "I \<Turnstile>s CC \<union> DD \<longleftrightarrow> I \<Turnstile>s CC \<and> I \<Turnstile>s DD"
   unfolding true_clss_def by blast
 
 lemma true_clss_Union[iff]: "I \<Turnstile>s \<Union> CCC \<longleftrightarrow> (\<forall>CC \<in> CCC. I \<Turnstile>s CC)"
   unfolding true_clss_def by simp
 
 lemma true_clss_mono: "DD \<subseteq> CC \<Longrightarrow> I \<Turnstile>s CC \<Longrightarrow> I \<Turnstile>s DD"
   by (simp add: subsetD true_clss_def)
 
 lemma true_clss_mono_strong: "(\<forall>D \<in> DD. \<exists>C \<in> CC. C \<subseteq># D) \<Longrightarrow> I \<Turnstile>s CC \<Longrightarrow> I \<Turnstile>s DD"
   unfolding true_clss_def true_cls_def true_lit_def by (meson mset_subset_eqD)
 
 lemma true_clss_subclause: "C \<subseteq># D \<Longrightarrow> I \<Turnstile>s {C} \<Longrightarrow> I \<Turnstile>s {D}"
   by (rule true_clss_mono_strong[of _ "{C}"]) auto
 
 abbreviation satisfiable :: "'a clause set \<Rightarrow> bool" where
   "satisfiable CC \<equiv> \<exists>I. I \<Turnstile>s CC"
 
 lemma satisfiable_antimono: "CC \<subseteq> DD \<Longrightarrow> satisfiable DD \<Longrightarrow> satisfiable CC"
   using true_clss_mono by blast
 
 lemma unsatisfiable_mono: "CC \<subseteq> DD \<Longrightarrow> \<not> satisfiable CC \<Longrightarrow> \<not> satisfiable DD"
   using satisfiable_antimono by blast
 
 definition true_cls_mset :: "'a interp \<Rightarrow> 'a clause multiset \<Rightarrow> bool" (infix "\<Turnstile>m" 50) where
   "I \<Turnstile>m CC \<longleftrightarrow> (\<forall>C \<in># CC. I \<Turnstile> C)"
 
 lemma true_cls_mset_empty[iff]: "I \<Turnstile>m {#}"
   unfolding true_cls_mset_def by auto
 
 lemma true_cls_mset_singleton[iff]: "I \<Turnstile>m {#C#} \<longleftrightarrow> I \<Turnstile> C"
   by (simp add: true_cls_mset_def)
 
 lemma true_cls_mset_union[iff]: "I \<Turnstile>m CC + DD \<longleftrightarrow> I \<Turnstile>m CC \<and> I \<Turnstile>m DD"
   unfolding true_cls_mset_def by auto
 
-lemma true_cls_mset_Union[iff]: "I \<Turnstile>m \<Union># CCC \<longleftrightarrow> (\<forall>CC \<in># CCC. I \<Turnstile>m CC)"
+lemma true_cls_mset_Union[iff]: "I \<Turnstile>m \<Sum>\<^sub># CCC \<longleftrightarrow> (\<forall>CC \<in># CCC. I \<Turnstile>m CC)"
   unfolding true_cls_mset_def by simp
 
 lemma true_cls_mset_add_mset[iff]: "I \<Turnstile>m add_mset C CC \<longleftrightarrow> I \<Turnstile> C \<and> I \<Turnstile>m CC"
   unfolding true_cls_mset_def by auto
 
 lemma true_cls_mset_image_mset[iff]: "I \<Turnstile>m image_mset f A \<longleftrightarrow> (\<forall>x \<in># A. I \<Turnstile> f x)"
   unfolding true_cls_mset_def by auto
 
 lemma true_cls_mset_mono: "set_mset DD \<subseteq> set_mset CC \<Longrightarrow> I \<Turnstile>m CC \<Longrightarrow> I \<Turnstile>m DD"
   unfolding true_cls_mset_def subset_iff by auto
 
 lemma true_cls_mset_mono_strong: "(\<forall>D \<in># DD. \<exists>C \<in># CC. C \<subseteq># D) \<Longrightarrow> I \<Turnstile>m CC \<Longrightarrow> I \<Turnstile>m DD"
   unfolding true_cls_mset_def true_cls_def true_lit_def by (meson mset_subset_eqD)
 
 lemma true_clss_set_mset[iff]: "I \<Turnstile>s set_mset CC \<longleftrightarrow> I \<Turnstile>m CC"
   unfolding true_clss_def true_cls_mset_def by auto
 
 lemma true_clss_mset_set[simp]: "finite CC \<Longrightarrow> I \<Turnstile>m mset_set CC \<longleftrightarrow> I \<Turnstile>s CC"
   unfolding true_clss_def true_cls_mset_def by auto
 
 lemma true_cls_mset_true_cls: "I \<Turnstile>m CC \<Longrightarrow> C \<in># CC \<Longrightarrow> I \<Turnstile> C"
   using true_cls_mset_def by auto
 
 end
diff --git a/thys/Ordered_Resolution_Prover/Ordered_Ground_Resolution.thy b/thys/Ordered_Resolution_Prover/Ordered_Ground_Resolution.thy
--- a/thys/Ordered_Resolution_Prover/Ordered_Ground_Resolution.thy
+++ b/thys/Ordered_Resolution_Prover/Ordered_Ground_Resolution.thy
@@ -1,468 +1,468 @@
 (*  Title:       Ground Ordered Resolution Calculus with Selection
     Author:      Anders Schlichtkrull <andschl at dtu.dk>, 2016, 2017
     Author:      Jasmin Blanchette <j.c.blanchette at vu.nl>, 2014, 2017
     Author:      Dmitriy Traytel <traytel at inf.ethz.ch>, 2014
     Maintainer:  Anders Schlichtkrull <andschl at dtu.dk>
 *)
 
 section \<open>Ground Ordered Resolution Calculus with Selection\<close>
 
 theory Ordered_Ground_Resolution
   imports Inference_System Ground_Resolution_Model
 begin
 
 text \<open>
 Ordered ground resolution with selection is the second inference system studied in Section~3
 (``Standard Resolution'') of Bachmair and Ganzinger's chapter.
 \<close>
 
 
 subsection \<open>Inference Rule\<close>
 
 text \<open>
 Ordered ground resolution consists of a single rule, called \<open>ord_resolve\<close> below. Like
 \<open>unord_resolve\<close>, the rule is sound and counterexample-reducing. In addition, it is reductive.
 \<close>
 
 context ground_resolution_with_selection
 begin
 
 text \<open>
 The following inductive definition corresponds to Figure 2.
 \<close>
 
 definition maximal_wrt :: "'a \<Rightarrow> 'a literal multiset \<Rightarrow> bool" where
   "maximal_wrt A DA \<longleftrightarrow> DA = {#} \<or> A = Max (atms_of DA)"
 
 definition strictly_maximal_wrt :: "'a \<Rightarrow> 'a literal multiset \<Rightarrow> bool" where
   "strictly_maximal_wrt A CA \<longleftrightarrow> (\<forall>B \<in> atms_of CA. B < A)"
 
 inductive eligible :: "'a list \<Rightarrow> 'a clause \<Rightarrow> bool" where
   eligible: "(S DA = negs (mset As)) \<or> (S DA = {#} \<and> length As = 1 \<and> maximal_wrt (As ! 0) DA) \<Longrightarrow>
     eligible As DA"
 
 lemma "(S DA = negs (mset As) \<or> S DA = {#} \<and> length As = 1 \<and> maximal_wrt (As ! 0) DA) \<longleftrightarrow>
     eligible As DA"
   using eligible.intros ground_resolution_with_selection.eligible.cases ground_resolution_with_selection_axioms by blast
 
 inductive
   ord_resolve :: "'a clause list \<Rightarrow> 'a clause \<Rightarrow> 'a multiset list \<Rightarrow> 'a list \<Rightarrow> 'a clause \<Rightarrow> bool"
 where
   ord_resolve:
     "length CAs = n \<Longrightarrow>
      length Cs = n \<Longrightarrow>
      length AAs = n \<Longrightarrow>
      length As = n \<Longrightarrow>
      n \<noteq> 0 \<Longrightarrow>
      (\<forall>i < n. CAs ! i = Cs ! i + poss (AAs ! i)) \<Longrightarrow>
      (\<forall>i < n. AAs ! i \<noteq> {#}) \<Longrightarrow>
      (\<forall>i < n. \<forall>A \<in># AAs ! i. A = As ! i) \<Longrightarrow>
      eligible As (D + negs (mset As)) \<Longrightarrow>
      (\<forall>i < n. strictly_maximal_wrt (As ! i) (Cs ! i)) \<Longrightarrow>
      (\<forall>i < n. S (CAs ! i) = {#}) \<Longrightarrow>
-     ord_resolve CAs (D + negs (mset As)) AAs As (\<Union># (mset Cs) + D)"
+     ord_resolve CAs (D + negs (mset As)) AAs As (\<Sum>\<^sub># (mset Cs) + D)"
 
 lemma ord_resolve_sound:
   assumes
     res_e: "ord_resolve CAs DA AAs As E" and
     cc_true: "I \<Turnstile>m mset CAs" and
     d_true: "I \<Turnstile> DA"
   shows "I \<Turnstile> E"
   using res_e
 proof (cases rule: ord_resolve.cases)
   case (ord_resolve n Cs D)
   note DA = this(1) and e = this(2) and cas_len = this(3) and cs_len = this(4) and
     as_len = this(6) and cas = this(8) and aas_ne = this(9) and a_eq = this(10)
 
   show ?thesis
   proof (cases "\<forall>A \<in> set As. A \<in> I")
     case True
     then have "\<not> I \<Turnstile> negs (mset As)"
       unfolding true_cls_def by fastforce
     then have "I \<Turnstile> D"
       using d_true DA by fast
     then show ?thesis
       unfolding e by blast
   next
     case False
     then obtain i where
       a_in_aa: "i < n" and
       a_false: "As ! i \<notin> I"
       using cas_len as_len by (metis in_set_conv_nth)
     have "\<not> I \<Turnstile> poss (AAs ! i)"
       using a_false a_eq aas_ne a_in_aa unfolding true_cls_def by auto
     moreover have "I \<Turnstile> CAs ! i"
       using a_in_aa cc_true unfolding true_cls_mset_def using cas_len by auto
     ultimately have "I \<Turnstile> Cs ! i"
       using cas a_in_aa by auto
     then show ?thesis
       using a_in_aa cs_len unfolding e true_cls_def
       by (meson in_Union_mset_iff nth_mem_mset union_iff)
   qed
 qed
 
 lemma filter_neg_atm_of_S: "{#Neg (atm_of L). L \<in># S C#} = S C"
   by (simp add: S_selects_neg_lits)
 
 text \<open>
 This corresponds to Lemma 3.13:
 \<close>
 
 lemma ord_resolve_reductive:
   assumes "ord_resolve CAs DA AAs As E"
   shows "E < DA"
   using assms
 proof (cases rule: ord_resolve.cases)
   case (ord_resolve n Cs D)
   note DA = this(1) and e = this(2) and cas_len = this(3) and cs_len = this(4) and
     ai_len = this(6) and nz = this(7) and cas = this(8) and maxim = this(12)
 
   show ?thesis
-  proof (cases "\<Union># (mset Cs) = {#}")
+  proof (cases "\<Sum>\<^sub># (mset Cs) = {#}")
     case True
     have "negs (mset As) \<noteq> {#}"
        using nz ai_len by auto
     then show ?thesis
        unfolding True e DA by auto
   next
     case False
 
     define max_A_of_Cs where
-      "max_A_of_Cs = Max (atms_of (\<Union># (mset Cs)))"
+      "max_A_of_Cs = Max (atms_of (\<Sum>\<^sub># (mset Cs)))"
 
     have
-      mc_in: "max_A_of_Cs \<in> atms_of (\<Union># (mset Cs))" and
-      mc_max: "\<And>B. B \<in> atms_of (\<Union># (mset Cs)) \<Longrightarrow> B \<le> max_A_of_Cs"
+      mc_in: "max_A_of_Cs \<in> atms_of (\<Sum>\<^sub># (mset Cs))" and
+      mc_max: "\<And>B. B \<in> atms_of (\<Sum>\<^sub># (mset Cs)) \<Longrightarrow> B \<le> max_A_of_Cs"
       using max_A_of_Cs_def False by auto
 
     then have "\<exists>C_max \<in> set Cs. max_A_of_Cs \<in> atms_of (C_max)"
       by (metis atm_imp_pos_or_neg_lit in_Union_mset_iff neg_lit_in_atms_of pos_lit_in_atms_of
           set_mset_mset)
     then obtain max_i where
       cm_in_cas: "max_i < length CAs" and
       mc_in_cm: "max_A_of_Cs \<in> atms_of (Cs ! max_i)"
       using in_set_conv_nth[of _ CAs] by (metis cas_len cs_len in_set_conv_nth)
 
     define CA_max where "CA_max = CAs ! max_i"
     define A_max where "A_max = As ! max_i"
     define C_max where "C_max = Cs ! max_i"
 
     have mc_lt_ma: "max_A_of_Cs < A_max"
       using maxim cm_in_cas mc_in_cm cas_len unfolding strictly_maximal_wrt_def A_max_def by auto
 
-    then have ucas_ne_neg_aa: "\<Union># (mset Cs) \<noteq> negs (mset As)"
+    then have ucas_ne_neg_aa: "\<Sum>\<^sub># (mset Cs) \<noteq> negs (mset As)"
       using mc_in mc_max mc_lt_ma cm_in_cas cas_len ai_len unfolding A_max_def
       by (metis atms_of_negs nth_mem set_mset_mset leD)
-    moreover have ucas_lt_ma: "\<forall>B \<in> atms_of (\<Union># (mset Cs)). B < A_max"
+    moreover have ucas_lt_ma: "\<forall>B \<in> atms_of (\<Sum>\<^sub># (mset Cs)). B < A_max"
       using mc_max mc_lt_ma by fastforce
-    moreover have "\<not> Neg A_max \<in># \<Union># (mset Cs)"
-      using ucas_lt_ma neg_lit_in_atms_of[of A_max "\<Union># (mset Cs)"] by auto
+    moreover have "\<not> Neg A_max \<in># \<Sum>\<^sub># (mset Cs)"
+      using ucas_lt_ma neg_lit_in_atms_of[of A_max "\<Sum>\<^sub># (mset Cs)"] by auto
     moreover have "Neg A_max \<in># negs (mset As)"
       using cm_in_cas cas_len ai_len A_max_def by auto
-    ultimately have "\<Union># (mset Cs) < negs (mset As)"
+    ultimately have "\<Sum>\<^sub># (mset Cs) < negs (mset As)"
       unfolding less_multiset\<^sub>H\<^sub>O
       by (metis (no_types) atms_less_eq_imp_lit_less_eq_neg count_greater_zero_iff
           count_inI le_imp_less_or_eq less_imp_not_less not_le)
     then show ?thesis
       unfolding e DA by auto
   qed
 qed
 
 text \<open>
 This corresponds to Theorem 3.15:
 \<close>
 
 theorem ord_resolve_counterex_reducing:
   assumes
     ec_ni_n: "{#} \<notin> N" and
     d_in_n: "DA \<in> N" and
     d_cex: "\<not> INTERP N \<Turnstile> DA" and
     d_min: "\<And>C. C \<in> N \<Longrightarrow> \<not> INTERP N \<Turnstile> C \<Longrightarrow> DA \<le> C"
   obtains CAs AAs As E where
     "set CAs \<subseteq> N"
     "INTERP N \<Turnstile>m mset CAs"
     "\<And>CA. CA \<in> set CAs \<Longrightarrow> productive N CA"
     "ord_resolve CAs DA AAs As E"
     "\<not> INTERP N \<Turnstile> E"
     "E < DA"
 proof -
   have d_ne: "DA \<noteq> {#}"
     using d_in_n ec_ni_n by blast
   have "\<exists>As. As \<noteq> [] \<and> negs (mset As) \<le># DA \<and> eligible As DA"
   proof (cases "S DA = {#}")
     assume s_d_e: "S DA = {#}"
 
     define A where "A = Max (atms_of DA)"
     define As where "As = [A]"
     define D where "D = DA-{#Neg A #}"
 
     have na_in_d: "Neg A \<in># DA"
       unfolding A_def using s_d_e d_ne d_in_n d_cex d_min
       by (metis Max_in_lits Max_lit_eq_pos_or_neg_Max_atm max_pos_imp_Interp Interp_imp_INTERP)
     then have das: "DA = D + negs (mset As)"
       unfolding D_def As_def by auto
     moreover from na_in_d have "negs (mset As) \<subseteq># DA"
       by (simp add: As_def)
     moreover have hd: "As ! 0 = Max (atms_of (D + negs (mset As)))"
       using A_def As_def das by auto
     then have "eligible As DA"
       using eligible s_d_e As_def das maximal_wrt_def by auto
     ultimately show ?thesis
       using As_def by blast
   next
     assume s_d_e: "S DA \<noteq> {#}"
 
     define As :: "'a list" where
       "As = list_of_mset {#atm_of L. L \<in># S DA#}"
     define D :: "'a clause" where
       "D = DA - negs {#atm_of L. L \<in># S DA#}"
 
     have "As \<noteq> []" unfolding As_def using s_d_e
       by (metis image_mset_is_empty_iff list_of_mset_empty)
     moreover have da_sub_as: "negs {#atm_of L. L \<in># S DA#} \<subseteq># DA"
       using S_selects_subseteq by (auto simp: filter_neg_atm_of_S)
     then have "negs (mset As) \<subseteq># DA"
       unfolding As_def by auto
     moreover have das: "DA = D + negs (mset As)"
       using da_sub_as unfolding D_def As_def by auto
     moreover have "S DA = negs {#atm_of L. L \<in># S DA#}"
       by (auto simp: filter_neg_atm_of_S)
     then have "S DA = negs (mset As)"
       unfolding As_def by auto
     then have "eligible As DA"
       unfolding das using eligible by auto
     ultimately show ?thesis
       by blast
   qed
   then obtain As :: "'a list" where
     as_ne: "As \<noteq> []" and
     negs_as_le_d: "negs (mset As) \<le># DA" and
     s_d: "eligible As DA"
     by blast
 
   define D :: "'a clause" where
     "D = DA - negs (mset As)"
 
   have "set As \<subseteq> INTERP N"
     using d_cex negs_as_le_d by force
   then have prod_ex: "\<forall>A \<in> set As. \<exists>D. produces N D A"
     unfolding INTERP_def
     by (metis (no_types, lifting) INTERP_def subsetCE UN_E not_produces_imp_notin_production)
   then have "\<And>A. \<exists>D. produces N D A \<longrightarrow> A \<in> set As"
     using ec_ni_n by (auto intro: productive_in_N)
   then have "\<And>A. \<exists>D. produces N D A \<longleftrightarrow> A \<in> set As"
     using prod_ex by blast
   then obtain CA_of where c_of0: "\<And>A. produces N (CA_of A) A \<longleftrightarrow> A \<in> set As"
     by metis
   then have prod_c0: "\<forall>A \<in> set As. produces N (CA_of A) A"
     by blast
 
   define C_of where
     "\<And>A. C_of A = {#L \<in># CA_of A. L \<noteq> Pos A#}"
   define Aj_of where
     "\<And>A. Aj_of A = image_mset atm_of {#L \<in># CA_of A. L = Pos A#}"
 
   have pospos: "\<And>LL A. {#Pos (atm_of x). x \<in># {#L \<in># LL. L = Pos A#}#} = {#L \<in># LL. L = Pos A#}"
     by (metis (mono_tags, lifting) image_filter_cong literal.sel(1) multiset.map_ident)
   have ca_of_c_of_aj_of: "\<And>A. CA_of A = C_of A + poss (Aj_of A)"
     using pospos[of _ "CA_of _"] by (simp add: C_of_def Aj_of_def)
 
   define n :: nat where
     "n = length As"
   define Cs :: "'a clause list" where
     "Cs = map C_of As"
   define AAs :: "'a multiset list" where
     "AAs = map Aj_of As"
   define CAs :: "'a literal multiset list" where
     "CAs = map CA_of As"
 
   have m_nz: "\<And>A. A \<in> set As \<Longrightarrow> Aj_of A \<noteq> {#}"
     unfolding Aj_of_def using prod_c0 produces_imp_Pos_in_lits
     by (metis (full_types) filter_mset_empty_conv image_mset_is_empty_iff)
 
   have prod_c: "productive N CA" if ca_in: "CA \<in> set CAs" for CA
   proof -
     obtain i where i_p: "i < length CAs" "CAs ! i = CA"
       using ca_in by (meson in_set_conv_nth)
     have "production N (CA_of (As ! i)) = {As ! i}"
       using i_p CAs_def prod_c0 by auto
     then show "productive N CA"
       using i_p CAs_def by auto
   qed
   then have cs_subs_n: "set CAs \<subseteq> N"
     using productive_in_N by auto
   have cs_true: "INTERP N \<Turnstile>m mset CAs"
     unfolding true_cls_mset_def using prod_c productive_imp_INTERP by auto
 
   have "\<And>A. A \<in> set As \<Longrightarrow> \<not> Neg A \<in># CA_of A"
     using prod_c0 produces_imp_neg_notin_lits by auto
   then have a_ni_c': "\<And>A. A \<in> set As \<Longrightarrow> A \<notin> atms_of (C_of A)"
     unfolding C_of_def using atm_imp_pos_or_neg_lit by force
   have c'_le_c: "\<And>A. C_of A \<le> CA_of A"
     unfolding C_of_def by (auto intro: subset_eq_imp_le_multiset)
   have a_max_c: "\<And>A. A \<in> set As \<Longrightarrow> A = Max (atms_of (CA_of A))"
     using prod_c0 productive_imp_produces_Max_atom[of N] by auto
   then have "\<And>A. A \<in> set As \<Longrightarrow> C_of A \<noteq> {#} \<Longrightarrow> Max (atms_of (C_of A)) \<le> A"
     using c'_le_c by (metis less_eq_Max_atms_of)
   moreover have "\<And>A. A \<in> set As \<Longrightarrow> C_of A \<noteq> {#} \<Longrightarrow> Max (atms_of (C_of A)) \<noteq> A"
     using a_ni_c' Max_in by (metis (no_types) atms_empty_iff_empty finite_atms_of)
   ultimately have max_c'_lt_a: "\<And>A. A \<in> set As \<Longrightarrow> C_of A \<noteq> {#} \<Longrightarrow> Max (atms_of (C_of A)) < A"
     by (metis order.strict_iff_order)
 
   have le_cs_as: "length CAs = length As"
     unfolding CAs_def by simp
 
   have "length CAs = n"
     by (simp add: le_cs_as n_def)
   moreover have "length Cs = n"
     by (simp add: Cs_def n_def)
   moreover have "length AAs = n"
     by (simp add: AAs_def n_def)
   moreover have "length As = n"
     using n_def by auto
   moreover have "n \<noteq> 0"
     by (simp add: as_ne n_def)
   moreover have " \<forall>i. i < length AAs \<longrightarrow> (\<forall>A \<in># AAs ! i. A = As ! i)"
     using AAs_def Aj_of_def by auto
 
   have "\<And>x B. production N (CA_of x) = {x} \<Longrightarrow> B \<in># CA_of x \<Longrightarrow> B \<noteq> Pos x \<Longrightarrow> atm_of B < x"
     by (metis atm_of_lit_in_atms_of insert_not_empty le_imp_less_or_eq Pos_atm_of_iff
         Neg_atm_of_iff pos_neg_in_imp_true produces_imp_Pos_in_lits produces_imp_atms_leq
         productive_imp_not_interp)
   then have "\<And>B A. A\<in>set As \<Longrightarrow> B \<in># CA_of A \<Longrightarrow> B \<noteq> Pos A \<Longrightarrow> atm_of B < A"
     using prod_c0 by auto
   have "\<forall>i. i < length AAs \<longrightarrow> AAs ! i \<noteq> {#}"
     unfolding AAs_def using m_nz by simp
   have "\<forall>i < n. CAs ! i = Cs ! i + poss (AAs ! i)"
     unfolding CAs_def Cs_def AAs_def using ca_of_c_of_aj_of by (simp add: n_def)
 
   moreover have "\<forall>i < n. AAs ! i \<noteq> {#}"
     using \<open>\<forall>i < length AAs. AAs ! i \<noteq> {#}\<close> calculation(3) by blast
   moreover have "\<forall>i < n. \<forall>A \<in># AAs ! i. A = As ! i"
     by (simp add: \<open>\<forall>i < length AAs. \<forall>A \<in># AAs ! i. A = As ! i\<close> calculation(3))
   moreover have "eligible As DA"
     using s_d by auto
   then have "eligible As (D + negs (mset As))"
     using D_def negs_as_le_d by auto
   moreover have "\<And>i. i < length AAs \<Longrightarrow> strictly_maximal_wrt (As ! i) ((Cs ! i))"
     by (simp add: C_of_def Cs_def \<open>\<And>x B. \<lbrakk>production N (CA_of x) = {x}; B \<in># CA_of x; B \<noteq> Pos x\<rbrakk> \<Longrightarrow> atm_of B < x\<close> atms_of_def calculation(3) n_def prod_c0 strictly_maximal_wrt_def)
 
   have "\<forall>i < n. strictly_maximal_wrt (As ! i) (Cs ! i)"
     by (simp add: \<open>\<And>i. i < length AAs \<Longrightarrow> strictly_maximal_wrt (As ! i) (Cs ! i)\<close> calculation(3))
   moreover have "\<forall>CA \<in> set CAs. S CA = {#}"
     using prod_c producesD productive_imp_produces_Max_literal by blast
   have "\<forall>CA\<in>set CAs. S CA = {#}"
     using \<open>\<forall>CA\<in>set CAs. S CA = {#}\<close> by simp
   then have "\<forall>i < n. S (CAs ! i) = {#}"
     using \<open>length CAs = n\<close> nth_mem by blast
-  ultimately have res_e: "ord_resolve CAs (D + negs (mset As)) AAs As (\<Union># (mset Cs) + D)"
+  ultimately have res_e: "ord_resolve CAs (D + negs (mset As)) AAs As (\<Sum>\<^sub># (mset Cs) + D)"
     using ord_resolve by auto
 
   have "\<And>A. A \<in> set As \<Longrightarrow> \<not> interp N (CA_of A) \<Turnstile> CA_of A"
     by (simp add: prod_c0 producesD)
   then have "\<And>A. A \<in> set As \<Longrightarrow> \<not> Interp N (CA_of A) \<Turnstile> C_of A"
     unfolding prod_c0 C_of_def Interp_def true_cls_def using true_lit_def not_gr_zero prod_c0
     by auto
   then have c'_at_n: "\<And>A. A \<in> set As \<Longrightarrow> \<not> INTERP N \<Turnstile> C_of A"
     using a_max_c c'_le_c max_c'_lt_a not_Interp_imp_not_INTERP unfolding true_cls_def
     by (metis true_cls_def true_cls_empty)
 
-  have "\<not> INTERP N \<Turnstile> \<Union># (mset Cs)"
+  have "\<not> INTERP N \<Turnstile> \<Sum>\<^sub># (mset Cs)"
     unfolding Cs_def true_cls_def using c'_at_n by fastforce
   moreover have "\<not> INTERP N \<Turnstile> D"
     using d_cex by (metis D_def add_diff_cancel_right' negs_as_le_d subset_mset.add_diff_assoc2
         true_cls_def union_iff)
-  ultimately have e_cex: "\<not> INTERP N \<Turnstile> \<Union># (mset Cs) + D"
+  ultimately have e_cex: "\<not> INTERP N \<Turnstile> \<Sum>\<^sub># (mset Cs) + D"
     by simp
 
   have "set CAs \<subseteq> N"
     by (simp add: cs_subs_n)
   moreover have "INTERP N \<Turnstile>m mset CAs"
     by (simp add: cs_true)
   moreover have "\<And>CA. CA \<in> set CAs \<Longrightarrow> productive N CA"
     by (simp add: prod_c)
-  moreover have "ord_resolve CAs DA AAs As (\<Union># (mset Cs) + D)"
+  moreover have "ord_resolve CAs DA AAs As (\<Sum>\<^sub># (mset Cs) + D)"
     using D_def negs_as_le_d res_e by auto
-  moreover have "\<not> INTERP N \<Turnstile> \<Union># (mset Cs) + D"
+  moreover have "\<not> INTERP N \<Turnstile> \<Sum>\<^sub># (mset Cs) + D"
     using e_cex by simp
-  moreover have "\<Union># (mset Cs) + D < DA"
+  moreover have "\<Sum>\<^sub># (mset Cs) + D < DA"
     using calculation(4) ord_resolve_reductive by auto
   ultimately show thesis
     ..
 qed
 
 lemma ord_resolve_atms_of_concl_subset:
   assumes "ord_resolve CAs DA AAs As E"
   shows "atms_of E \<subseteq> (\<Union>C \<in> set CAs. atms_of C) \<union> atms_of DA"
   using assms
 proof (cases rule: ord_resolve.cases)
   case (ord_resolve n Cs D)
   note DA = this(1) and e = this(2) and cas_len = this(3) and cs_len = this(4) and cas = this(8)
 
   have "\<forall>i < n. set_mset (Cs ! i) \<subseteq> set_mset (CAs ! i)"
     using cas by auto
-  then have "\<forall>i < n. Cs ! i \<subseteq># \<Union># (mset CAs)"
+  then have "\<forall>i < n. Cs ! i \<subseteq># \<Sum>\<^sub># (mset CAs)"
     by (metis cas cas_len mset_subset_eq_add_left nth_mem_mset sum_mset.remove union_assoc)
-  then have "\<forall>C \<in> set Cs. C \<subseteq># \<Union># (mset CAs)"
+  then have "\<forall>C \<in> set Cs. C \<subseteq># \<Sum>\<^sub># (mset CAs)"
     using cs_len in_set_conv_nth[of _ Cs] by auto
-  then have "set_mset (\<Union># (mset Cs)) \<subseteq> set_mset (\<Union># (mset CAs))"
+  then have "set_mset (\<Sum>\<^sub># (mset Cs)) \<subseteq> set_mset (\<Sum>\<^sub># (mset CAs))"
     by auto (meson in_mset_sum_list2 mset_subset_eqD)
-  then have "atms_of (\<Union># (mset Cs)) \<subseteq> atms_of (\<Union># (mset CAs))"
+  then have "atms_of (\<Sum>\<^sub># (mset Cs)) \<subseteq> atms_of (\<Sum>\<^sub># (mset CAs))"
     by (meson lits_subseteq_imp_atms_subseteq mset_subset_eqD subsetI)
-  moreover have "atms_of (\<Union># (mset CAs)) = (\<Union>CA \<in> set CAs. atms_of CA)"
+  moreover have "atms_of (\<Sum>\<^sub># (mset CAs)) = (\<Union>CA \<in> set CAs. atms_of CA)"
     by (intro set_eqI iffI, simp_all,
       metis in_mset_sum_list2 atm_imp_pos_or_neg_lit neg_lit_in_atms_of pos_lit_in_atms_of,
       metis in_mset_sum_list atm_imp_pos_or_neg_lit neg_lit_in_atms_of pos_lit_in_atms_of)
-  ultimately have "atms_of (\<Union># (mset Cs)) \<subseteq> (\<Union>CA \<in> set CAs. atms_of CA)"
+  ultimately have "atms_of (\<Sum>\<^sub># (mset Cs)) \<subseteq> (\<Union>CA \<in> set CAs. atms_of CA)"
     by auto
   moreover have "atms_of D \<subseteq> atms_of DA"
     using DA by auto
   ultimately show ?thesis
     unfolding e by auto
 qed
 
 
 subsection \<open>Inference System\<close>
 
 text \<open>
 Theorem 3.16 is subsumed in the counterexample-reducing inference system framework, which is
 instantiated below. Unlike its unordered cousin, ordered resolution is additionally a reductive
 inference system.
 \<close>
 
 definition ord_\<Gamma> :: "'a inference set" where
   "ord_\<Gamma> = {Infer (mset CAs) DA E | CAs DA AAs As E. ord_resolve CAs DA AAs As E}"
 
 sublocale ord_\<Gamma>_sound_counterex_reducing?:
   sound_counterex_reducing_inference_system "ground_resolution_with_selection.ord_\<Gamma> S"
     "ground_resolution_with_selection.INTERP S" +
   reductive_inference_system "ground_resolution_with_selection.ord_\<Gamma> S"
 proof unfold_locales
   fix N :: "'a clause set" and DA :: "'a clause"
   assume "{#} \<notin> N" and "DA \<in> N" and "\<not> INTERP N \<Turnstile> DA" and "\<And>C. C \<in> N \<Longrightarrow> \<not> INTERP N \<Turnstile> C \<Longrightarrow> DA \<le> C"
   then obtain CAs AAs As E where
     dd_sset_n: "set CAs \<subseteq> N" and
     dd_true: "INTERP N \<Turnstile>m mset CAs" and
     res_e: "ord_resolve CAs DA AAs As E" and
     e_cex: "\<not> INTERP N \<Turnstile> E" and
     e_lt_c: "E < DA"
     using ord_resolve_counterex_reducing[of N DA thesis] by auto
 
   have "Infer (mset CAs) DA E \<in> ord_\<Gamma>"
     using res_e unfolding ord_\<Gamma>_def by (metis (mono_tags, lifting) mem_Collect_eq)
   then show "\<exists>CC E. set_mset CC \<subseteq> N \<and> INTERP N \<Turnstile>m CC \<and> Infer CC DA E \<in> ord_\<Gamma>
     \<and> \<not> INTERP N \<Turnstile> E \<and> E < DA"
     using dd_sset_n dd_true e_cex e_lt_c by (metis set_mset_mset)
 qed (auto simp: ord_\<Gamma>_def intro: ord_resolve_sound ord_resolve_reductive)
 
 lemmas clausal_logic_compact = ord_\<Gamma>_sound_counterex_reducing.clausal_logic_compact
 
 end
 
 text \<open>
 A second proof of Theorem 3.12, compactness of clausal logic:
 \<close>
 
 lemmas clausal_logic_compact = ground_resolution_with_selection.clausal_logic_compact
 
 end
diff --git a/thys/PAC_Checker/PAC_Polynomials.thy b/thys/PAC_Checker/PAC_Polynomials.thy
--- a/thys/PAC_Checker/PAC_Polynomials.thy
+++ b/thys/PAC_Checker/PAC_Polynomials.thy
@@ -1,489 +1,489 @@
 theory PAC_Polynomials
   imports PAC_Specification Finite_Map_Multiset
 begin
 
 
 section \<open>Polynomials of strings\<close>
 
 text \<open>
 
   Isabelle's definition of polynomials only work with variables of type
   \<^typ>\<open>nat\<close>. Therefore, we introduce a version that uses strings by using an injective function
   that converts a string to a natural number. It exists because strings are countable. Remark that
   the whole development is independent of the function.
 
 \<close>
 
 subsection \<open>Polynomials and Variables\<close>
 
 lemma poly_embed_EX:
   \<open>\<exists>\<phi>. bij (\<phi> :: string \<Rightarrow> nat)\<close>
   by (rule countableE_infinite[of \<open>UNIV :: string set\<close>])
      (auto intro!: infinite_UNIV_listI)
 
 text \<open>Using a multiset instead of a list has some advantage from an abstract point of view. First,
   we can have monomials that appear several times  and the coefficient can also be zero. Basically,
   we can represent un-normalised polynomials, which is very useful to talk about intermediate states
   in our program.
 \<close>
 type_synonym term_poly = \<open>string multiset\<close>
 type_synonym mset_polynomial =
   \<open>(term_poly * int) multiset\<close>
 
 definition normalized_poly :: \<open>mset_polynomial \<Rightarrow> bool\<close> where
   \<open>normalized_poly p \<longleftrightarrow>
      distinct_mset (fst `# p) \<and>
      0 \<notin># snd `# p\<close>
 
 lemma normalized_poly_simps[simp]:
   \<open>normalized_poly {#}\<close>
   \<open>normalized_poly (add_mset t p) \<longleftrightarrow> snd t \<noteq> 0 \<and>
     fst t \<notin># fst `# p \<and> normalized_poly p\<close>
   by (auto simp: normalized_poly_def)
 
 lemma normalized_poly_mono:
   \<open>normalized_poly B \<Longrightarrow> A \<subseteq># B \<Longrightarrow> normalized_poly A\<close>
   unfolding normalized_poly_def
   by (auto intro: distinct_mset_mono image_mset_subseteq_mono)
 
 definition mult_poly_by_monom :: \<open>term_poly * int \<Rightarrow> mset_polynomial \<Rightarrow> mset_polynomial\<close> where
   \<open>mult_poly_by_monom  = (\<lambda>ys q. image_mset (\<lambda>xs. (fst xs + fst ys, snd ys * snd xs)) q)\<close>
 
 
 definition mult_poly_raw :: \<open>mset_polynomial \<Rightarrow> mset_polynomial \<Rightarrow> mset_polynomial\<close> where
   \<open>mult_poly_raw p q =
     (sum_mset ((\<lambda>y. mult_poly_by_monom y q) `# p))\<close>
 
 
 definition remove_powers :: \<open>mset_polynomial \<Rightarrow> mset_polynomial\<close> where
   \<open>remove_powers xs =  image_mset (apfst remdups_mset) xs\<close>
 
 
 definition all_vars_mset :: \<open>mset_polynomial \<Rightarrow> string multiset\<close> where
-  \<open>all_vars_mset p = \<Union># (fst `# p)\<close>
+  \<open>all_vars_mset p = \<Sum>\<^sub># (fst `# p)\<close>
 
 abbreviation all_vars :: \<open>mset_polynomial \<Rightarrow> string set\<close> where
   \<open>all_vars p \<equiv> set_mset (all_vars_mset p)\<close>
 
 definition add_to_coefficient :: \<open>_ \<Rightarrow> mset_polynomial \<Rightarrow> mset_polynomial\<close>  where
   \<open>add_to_coefficient = (\<lambda>(a, n) b. {#(a', _) \<in># b. a' \<noteq> a#} +
              (if n + sum_mset (snd `# {#(a', _) \<in># b. a' = a#}) = 0 then {#}
                else {#(a, n + sum_mset (snd `# {#(a', _) \<in># b. a' = a#}))#}))\<close>
 
 definition normalize_poly :: \<open>mset_polynomial \<Rightarrow> mset_polynomial\<close> where
   \<open>normalize_poly p = fold_mset add_to_coefficient {#} p\<close>
 
 lemma add_to_coefficient_simps:
   \<open>n + sum_mset (snd `# {#(a', _) \<in># b. a' = a#}) \<noteq> 0 \<Longrightarrow>
     add_to_coefficient (a, n) b = {#(a', _) \<in># b. a' \<noteq> a#} +
              {#(a, n + sum_mset (snd `# {#(a', _) \<in># b. a' = a#}))#}\<close>
   \<open>n + sum_mset (snd `# {#(a', _) \<in># b. a' = a#}) = 0 \<Longrightarrow>
     add_to_coefficient (a, n) b = {#(a', _) \<in># b. a' \<noteq> a#}\<close> and
   add_to_coefficient_simps_If:
   \<open>add_to_coefficient (a, n) b = {#(a', _) \<in># b. a' \<noteq> a#} +
              (if n + sum_mset (snd `# {#(a', _) \<in># b. a' = a#}) = 0 then {#}
                else {#(a, n + sum_mset (snd `# {#(a', _) \<in># b. a' = a#}))#})\<close>
   by (auto simp: add_to_coefficient_def)
 
 interpretation comp_fun_commute \<open>add_to_coefficient\<close>
 proof -
   have [iff]:
     \<open>a \<noteq> aa \<Longrightarrow>
     ((case x of (a', _) \<Rightarrow> a' = a) \<and> (case x of (a', _) \<Rightarrow> a' \<noteq> aa)) \<longleftrightarrow>
     (case x of (a', _) \<Rightarrow> a' = a)\<close> for a' aa a x
     by auto
   show \<open>comp_fun_commute add_to_coefficient\<close>
     unfolding add_to_coefficient_def
     by standard
      (auto intro!: ext simp: filter_filter_mset ac_simps add_eq_0_iff)
 qed
 
 lemma normalized_poly_normalize_poly[simp]:
   \<open>normalized_poly (normalize_poly p)\<close>
   unfolding normalize_poly_def
   apply (induction p)
   subgoal by auto
   subgoal for x p
     by (cases x)
       (auto simp: add_to_coefficient_simps_If
       intro: normalized_poly_mono)
   done
 
 
 subsection \<open>Addition\<close>
 
 inductive add_poly_p :: \<open>mset_polynomial \<times> mset_polynomial \<times> mset_polynomial \<Rightarrow> mset_polynomial \<times> mset_polynomial \<times> mset_polynomial \<Rightarrow> bool\<close> where
 add_new_coeff_r:
     \<open>add_poly_p (p, add_mset x q, r) (p, q, add_mset x r)\<close> |
 add_new_coeff_l:
     \<open>add_poly_p (add_mset x p, q, r) (p, q, add_mset x r)\<close> |
 add_same_coeff_l:
     \<open>add_poly_p (add_mset (x, n) p, q, add_mset (x, m) r) (p, q, add_mset (x, n + m) r)\<close> |
 add_same_coeff_r:
     \<open>add_poly_p (p, add_mset (x, n) q, add_mset (x, m) r) (p, q, add_mset (x, n + m) r)\<close> |
 rem_0_coeff:
     \<open>add_poly_p (p, q, add_mset (x, 0) r) (p, q, r)\<close>
 
 inductive_cases add_poly_pE: \<open>add_poly_p S T\<close>
 
 lemmas add_poly_p_induct =
   add_poly_p.induct[split_format(complete)]
 
 lemma add_poly_p_empty_l:
   \<open>add_poly_p\<^sup>*\<^sup>* (p, q, r) ({#}, q, p + r)\<close>
   apply (induction p arbitrary: r)
   subgoal by auto
   subgoal
     by (metis (no_types, lifting) add_new_coeff_l r_into_rtranclp
       rtranclp_trans union_mset_add_mset_left union_mset_add_mset_right)
   done
 
 lemma add_poly_p_empty_r:
   \<open>add_poly_p\<^sup>*\<^sup>* (p, q, r) (p, {#}, q + r)\<close>
   apply (induction q arbitrary: r)
   subgoal by auto
   subgoal
     by (metis (no_types, lifting) add_new_coeff_r r_into_rtranclp
       rtranclp_trans union_mset_add_mset_left union_mset_add_mset_right)
   done
 
 lemma add_poly_p_sym:
   \<open>add_poly_p (p, q, r) (p', q', r') \<longleftrightarrow> add_poly_p (q, p, r) (q', p', r')\<close>
   apply (rule iffI)
   subgoal
     by (cases rule: add_poly_p.cases, assumption)
       (auto intro: add_poly_p.intros)
   subgoal
     by (cases rule: add_poly_p.cases, assumption)
       (auto intro: add_poly_p.intros)
   done
 
 lemma wf_if_measure_in_wf:
   \<open>wf R \<Longrightarrow> (\<And>a b. (a, b) \<in> S \<Longrightarrow> (\<nu> a, \<nu> b)\<in>R) \<Longrightarrow> wf S\<close>
   by (metis in_inv_image wfE_min wfI_min wf_inv_image)
 
 lemma lexn_n:
   \<open>n > 0 \<Longrightarrow> (x # xs, y # ys) \<in> lexn r n \<longleftrightarrow>
   (length xs = n-1 \<and> length ys = n-1) \<and> ((x, y) \<in> r \<or> (x = y \<and> (xs, ys) \<in> lexn r (n - 1)))\<close>
   apply (cases n)
    apply simp
   by (auto simp: map_prod_def image_iff lex_prod_def)
 
 lemma wf_add_poly_p:
   \<open>wf {(x, y). add_poly_p y x}\<close>
   by (rule wf_if_measure_in_wf[where R = \<open>lexn less_than 3\<close> and
      \<nu> = \<open>\<lambda>(a,b,c). [size a , size b, size c]\<close>])
     (auto simp: add_poly_p.simps wf_lexn
      simp: lexn_n simp del: lexn.simps(2))
 
 lemma mult_poly_by_monom_simps[simp]:
   \<open>mult_poly_by_monom t {#} = {#}\<close>
   \<open>mult_poly_by_monom t (ps + qs) =  mult_poly_by_monom t ps + mult_poly_by_monom t qs\<close>
   \<open>mult_poly_by_monom a (add_mset p ps) = add_mset (fst a + fst p, snd a * snd p) (mult_poly_by_monom a ps)\<close>
 proof -
   interpret comp_fun_commute \<open>(\<lambda>xs. add_mset (xs + t))\<close> for t
     by standard auto
   show
     \<open>mult_poly_by_monom t (ps + qs) =  mult_poly_by_monom t ps + mult_poly_by_monom t qs\<close> for t
     by (induction ps)
       (auto simp: mult_poly_by_monom_def)
   show
     \<open>mult_poly_by_monom a (add_mset p ps) = add_mset (fst a + fst p, snd a * snd p) (mult_poly_by_monom a ps)\<close>
     \<open>mult_poly_by_monom t {#} = {#}\<close>for t
     by (auto simp: mult_poly_by_monom_def)
 qed
 
 inductive mult_poly_p :: \<open>mset_polynomial \<Rightarrow> mset_polynomial \<times> mset_polynomial \<Rightarrow> mset_polynomial \<times> mset_polynomial \<Rightarrow> bool\<close>
   for q :: mset_polynomial where
 mult_step:
     \<open>mult_poly_p q (add_mset (xs, n) p, r) (p, (\<lambda>(ys, m). (remdups_mset (xs + ys), n * m)) `# q + r)\<close>
 
 
 lemmas mult_poly_p_induct = mult_poly_p.induct[split_format(complete)]
 
 subsection \<open>Normalisation\<close>
 
 inductive normalize_poly_p :: \<open>mset_polynomial \<Rightarrow> mset_polynomial \<Rightarrow> bool\<close>where
 rem_0_coeff[simp, intro]:
     \<open>normalize_poly_p p q \<Longrightarrow> normalize_poly_p (add_mset (xs, 0) p) q\<close> |
 merge_dup_coeff[simp, intro]:
     \<open>normalize_poly_p p q \<Longrightarrow> normalize_poly_p (add_mset (xs, m) (add_mset (xs, n) p)) (add_mset (xs, m + n) q)\<close> |
 same[simp, intro]:
     \<open>normalize_poly_p p p\<close> |
 keep_coeff[simp, intro]:
     \<open>normalize_poly_p p q \<Longrightarrow> normalize_poly_p (add_mset x p) (add_mset x q)\<close>
 
 
 subsection \<open>Correctness\<close>
 text \<open>
   This locales maps string polynomials to real polynomials.
 \<close>
 locale poly_embed =
   fixes \<phi> :: \<open>string \<Rightarrow> nat\<close>
   assumes \<phi>_inj: \<open>inj \<phi>\<close>
 begin
 
 definition poly_of_vars :: "term_poly \<Rightarrow> ('a :: {comm_semiring_1}) mpoly" where
   \<open>poly_of_vars xs = fold_mset (\<lambda>a b. Var (\<phi> a) * b) (1 :: 'a mpoly) xs\<close>
 
 lemma poly_of_vars_simps[simp]:
   shows
     \<open>poly_of_vars (add_mset x xs) = Var (\<phi> x) * (poly_of_vars xs :: ('a :: {comm_semiring_1}) mpoly)\<close> (is ?A) and
     \<open>poly_of_vars (xs + ys) = poly_of_vars xs * (poly_of_vars ys :: ('a :: {comm_semiring_1}) mpoly)\<close> (is ?B)
 proof -
   interpret comp_fun_commute \<open>(\<lambda>a b. (b :: 'a :: {comm_semiring_1} mpoly) * Var (\<phi> a))\<close>
     by standard
       (auto simp: algebra_simps ac_simps
          Var_def times_monomial_monomial intro!: ext)
 
   show ?A
     by (auto simp: poly_of_vars_def comp_fun_commute_axioms fold_mset_fusion
       ac_simps)
   show ?B
     apply (auto simp: poly_of_vars_def ac_simps)
     by (simp add: local.comp_fun_commute_axioms local.fold_mset_fusion
       semiring_normalization_rules(18))
 qed
 
 
 definition mononom_of_vars where
   \<open>mononom_of_vars \<equiv> (\<lambda>(xs, n). (+) (Const n * poly_of_vars xs))\<close>
 
 interpretation comp_fun_commute \<open>mononom_of_vars\<close>
   by standard
     (auto simp: algebra_simps ac_simps mononom_of_vars_def
        Var_def times_monomial_monomial intro!: ext)
 
 lemma [simp]:
   \<open>poly_of_vars {#} = 1\<close>
   by (auto simp: poly_of_vars_def)
 
 lemma mononom_of_vars_add[simp]:
   \<open>NO_MATCH 0 b \<Longrightarrow> mononom_of_vars xs b = Const (snd xs) * poly_of_vars (fst xs) + b\<close>
   by (cases xs)
     (auto simp: ac_simps mononom_of_vars_def)
 
 definition polynomial_of_mset :: \<open>mset_polynomial \<Rightarrow> _\<close> where
   \<open>polynomial_of_mset p = sum_mset (mononom_of_vars `# p) 0\<close>
 
 lemma polynomial_of_mset_append[simp]:
   \<open>polynomial_of_mset (xs + ys) = polynomial_of_mset xs + polynomial_of_mset ys\<close>
   by (auto simp: ac_simps Const_def polynomial_of_mset_def)
 
 lemma polynomial_of_mset_Cons[simp]:
   \<open>polynomial_of_mset (add_mset x ys) = Const (snd x) * poly_of_vars (fst x) + polynomial_of_mset ys\<close>
   by (cases x)
     (auto simp: ac_simps polynomial_of_mset_def mononom_of_vars_def)
 
 lemma polynomial_of_mset_empty[simp]:
   \<open>polynomial_of_mset {#} = 0\<close>
   by (auto simp: polynomial_of_mset_def)
 
 lemma polynomial_of_mset_mult_poly_by_monom[simp]:
   \<open>polynomial_of_mset (mult_poly_by_monom x ys) =
        (Const (snd x) * poly_of_vars (fst x) * polynomial_of_mset ys)\<close>
  by (induction ys)
    (auto simp: Const_mult algebra_simps)
 
 lemma polynomial_of_mset_mult_poly_raw[simp]:
   \<open>polynomial_of_mset (mult_poly_raw xs ys) = polynomial_of_mset xs * polynomial_of_mset ys\<close>
   unfolding mult_poly_raw_def
   by (induction xs arbitrary: ys)
    (auto simp: Const_mult algebra_simps)
 
 lemma polynomial_of_mset_uminus:
   \<open>polynomial_of_mset {#case x of (a, b) \<Rightarrow> (a, - b). x \<in># za#} =
     - polynomial_of_mset za\<close>
   by (induction za)
     auto
 
 
 lemma X2_X_polynomial_bool_mult_in:
   \<open>Var (x1) * (Var (x1) * p) -  Var (x1) * p \<in> More_Modules.ideal polynomial_bool\<close>
   using ideal_mult_right_in[OF  X2_X_in_pac_ideal[of x1 \<open>{}\<close>, unfolded pac_ideal_def], of p]
   by (auto simp: right_diff_distrib ac_simps power2_eq_square)
 
 
 lemma polynomial_of_list_remove_powers_polynomial_bool:
   \<open>(polynomial_of_mset xs) - polynomial_of_mset (remove_powers xs) \<in> ideal polynomial_bool\<close>
 proof (induction xs)
   case empty
   then show \<open>?case\<close> by (auto simp: remove_powers_def ideal.span_zero)
 next
   case (add x xs)
   have H1: \<open>x1 \<in># x2 \<Longrightarrow>
        Var (\<phi> x1) * poly_of_vars x2 - p \<in> More_Modules.ideal polynomial_bool \<longleftrightarrow>
        poly_of_vars x2 - p \<in> More_Modules.ideal polynomial_bool
        \<close> for x1 x2 p
     apply (subst (2) ideal.span_add_eq[symmetric,
       of \<open>Var (\<phi> x1) * poly_of_vars x2 - poly_of_vars x2\<close>])
     apply (drule multi_member_split)
     apply (auto simp: X2_X_polynomial_bool_mult_in)
     done
 
   have diff: \<open>poly_of_vars (x) - poly_of_vars (remdups_mset (x)) \<in> ideal polynomial_bool\<close> for x
     by (induction x)
      (auto simp: remove_powers_def ideal.span_zero H1
       simp flip: right_diff_distrib intro!: ideal.span_scale)
   have [simp]: \<open>polynomial_of_mset xs -
     polynomial_of_mset (apfst remdups_mset `# xs)
     \<in> More_Modules.ideal polynomial_bool \<Longrightarrow>
     poly_of_vars ys * poly_of_vars ys -
     poly_of_vars ys * poly_of_vars (remdups_mset ys)
     \<in> More_Modules.ideal polynomial_bool \<Longrightarrow>
     polynomial_of_mset xs + Const y * poly_of_vars ys -
     (polynomial_of_mset (apfst remdups_mset `# xs) +
     Const y * poly_of_vars (remdups_mset ys))
     \<in> More_Modules.ideal polynomial_bool\<close> for y ys
     by (metis add_diff_add diff ideal.scale_right_diff_distrib ideal.span_add ideal.span_scale)
   show ?case
     using add
     apply (cases x)
     subgoal for ys y
       using ideal_mult_right_in2[OF diff, of \<open>poly_of_vars ys\<close> ys]
       by (auto simp: remove_powers_def right_diff_distrib
         ideal.span_diff ideal.span_add field_simps)
     done
 qed
 
 lemma add_poly_p_polynomial_of_mset:
   \<open>add_poly_p (p, q, r) (p', q', r') \<Longrightarrow>
     polynomial_of_mset r + (polynomial_of_mset p + polynomial_of_mset q) =
     polynomial_of_mset r' + (polynomial_of_mset p' + polynomial_of_mset q')\<close>
   apply (induction rule: add_poly_p_induct)
   subgoal
     by auto
   subgoal
     by auto
   subgoal
     by (auto simp: algebra_simps Const_add)
   subgoal
     by (auto simp: algebra_simps Const_add)
   subgoal
     by (auto simp: algebra_simps Const_add)
   done
 
 lemma rtranclp_add_poly_p_polynomial_of_mset:
   \<open>add_poly_p\<^sup>*\<^sup>* (p, q, r) (p', q', r') \<Longrightarrow>
     polynomial_of_mset r + (polynomial_of_mset p + polynomial_of_mset q) =
     polynomial_of_mset r' + (polynomial_of_mset p' + polynomial_of_mset q')\<close>
   by (induction rule: rtranclp_induct[of add_poly_p \<open>(_, _, _)\<close> \<open>(_, _, _)\<close>, split_format(complete), of for r])
     (auto dest: add_poly_p_polynomial_of_mset)
 
 
 lemma rtranclp_add_poly_p_polynomial_of_mset_full:
   \<open>add_poly_p\<^sup>*\<^sup>* (p, q, {#}) ({#}, {#}, r') \<Longrightarrow>
     polynomial_of_mset r' = (polynomial_of_mset p + polynomial_of_mset q)\<close>
   by (drule rtranclp_add_poly_p_polynomial_of_mset)
     (auto simp: ac_simps add_eq_0_iff)
 
 lemma poly_of_vars_remdups_mset:
   \<open>poly_of_vars (remdups_mset (xs)) - (poly_of_vars xs)
     \<in> More_Modules.ideal polynomial_bool\<close>
   apply (induction xs)
   subgoal by (auto simp: ideal.span_zero)
   subgoal for x xs
     apply (cases \<open>x \<in># xs\<close>)
      apply (metis (no_types, lifting) X2_X_polynomial_bool_mult_in diff_add_cancel diff_diff_eq2
         ideal.span_diff insert_DiffM poly_of_vars_simps(1) remdups_mset_singleton_sum)
     by (metis (no_types, lifting) ideal.span_scale poly_of_vars_simps(1) remdups_mset_singleton_sum
         right_diff_distrib)
   done
 
 lemma polynomial_of_mset_mult_map:
   \<open>polynomial_of_mset
      {#case x of (ys, n) \<Rightarrow> (remdups_mset (ys + xs), n * m). x \<in># q#} -
     Const m * (poly_of_vars xs * polynomial_of_mset q)
     \<in> More_Modules.ideal polynomial_bool\<close>
   (is \<open>?P q \<in> _\<close>)
 proof (induction q)
   case empty
   then show ?case by (auto simp: algebra_simps ideal.span_zero)
 next
   case (add x q)
   then have uP:  \<open>-?P q \<in> More_Modules.ideal polynomial_bool\<close>
     using ideal.span_neg by blast
   have \<open> Const b * (Const m * poly_of_vars (remdups_mset (a + xs))) -
            Const b * (Const m * (poly_of_vars a * poly_of_vars xs))
            \<in> More_Modules.ideal polynomial_bool\<close> for a b
     by (auto simp: Const_mult simp flip: right_diff_distrib' poly_of_vars_simps
         intro!: ideal.span_scale poly_of_vars_remdups_mset)
   then show ?case
     apply (subst ideal.span_add_eq2[symmetric, OF uP])
     apply (cases x)
     apply (auto simp: field_simps Const_mult  simp flip:
         intro!: ideal.span_scale poly_of_vars_remdups_mset)
     done
 qed
 
 lemma mult_poly_p_mult_ideal:
   \<open>mult_poly_p q (p, r) (p', r') \<Longrightarrow>
      (polynomial_of_mset p' * polynomial_of_mset q + polynomial_of_mset r') - (polynomial_of_mset p * polynomial_of_mset q + polynomial_of_mset r)
        \<in> ideal polynomial_bool\<close>
 proof (induction rule: mult_poly_p_induct)
   case (mult_step xs n p r)
   show ?case
     by (auto simp: algebra_simps polynomial_of_mset_mult_map)
 qed
 
 lemma rtranclp_mult_poly_p_mult_ideal:
   \<open>(mult_poly_p q)\<^sup>*\<^sup>* (p, r) (p', r') \<Longrightarrow>
      (polynomial_of_mset p' * polynomial_of_mset q + polynomial_of_mset r') - (polynomial_of_mset p * polynomial_of_mset q + polynomial_of_mset r)
        \<in> ideal polynomial_bool\<close>
   apply (induction p' r' rule: rtranclp_induct[of \<open>mult_poly_p q\<close> \<open>(p, r)\<close> \<open>(p', q')\<close> for p' q', split_format(complete)])
   subgoal
     by (auto simp: ideal.span_zero)
   subgoal for a b aa ba
     apply (drule mult_poly_p_mult_ideal)
     apply (drule ideal.span_add)
     apply assumption
     by (auto simp: group_add_class.diff_add_eq_diff_diff_swap
         add.inverse_distrib_swap ac_simps add_diff_eq
       simp flip:  diff_add_eq_diff_diff_swap)
   done
 
 lemma rtranclp_mult_poly_p_mult_ideal_final:
   \<open>(mult_poly_p q)\<^sup>*\<^sup>* (p, {#}) ({#}, r) \<Longrightarrow>
     (polynomial_of_mset r) - (polynomial_of_mset p * polynomial_of_mset q)
        \<in> ideal polynomial_bool\<close>
   by (drule rtranclp_mult_poly_p_mult_ideal) auto
 
 lemma normalize_poly_p_poly_of_mset:
   \<open>normalize_poly_p p q \<Longrightarrow> polynomial_of_mset p = polynomial_of_mset q\<close>
   apply (induction rule: normalize_poly_p.induct)
   apply (auto simp: Const_add algebra_simps)
   done
 
 
 lemma rtranclp_normalize_poly_p_poly_of_mset:
   \<open>normalize_poly_p\<^sup>*\<^sup>* p q \<Longrightarrow> polynomial_of_mset p = polynomial_of_mset q\<close>
   by (induction rule: rtranclp_induct)
     (auto simp: normalize_poly_p_poly_of_mset)
 
 end
 
 
 text \<open>It would be nice to have the property in the other direction too, but this requires a deep
 dive into the definitions of polynomials.\<close>
 locale poly_embed_bij = poly_embed +
   fixes V N
   assumes \<phi>_bij: \<open>bij_betw \<phi> V N\<close>
 begin
 
 definition \<phi>' :: \<open>nat \<Rightarrow> string\<close> where
   \<open>\<phi>' = the_inv_into V \<phi>\<close>
 
 lemma \<phi>'_\<phi>[simp]:
   \<open>x \<in> V \<Longrightarrow> \<phi>' (\<phi> x) = x\<close>
   using \<phi>_bij unfolding \<phi>'_def
   by (meson bij_betw_imp_inj_on the_inv_into_f_f)
 
 lemma \<phi>_\<phi>'[simp]:
   \<open>x \<in> N \<Longrightarrow> \<phi> (\<phi>' x) = x\<close>
   using \<phi>_bij unfolding \<phi>'_def
   by (meson f_the_inv_into_f_bij_betw)
 
 end
 
 end