diff --git a/thys/Design_Theory/BIBD.thy b/thys/Design_Theory/BIBD.thy
--- a/thys/Design_Theory/BIBD.thy
+++ b/thys/Design_Theory/BIBD.thy
@@ -1,943 +1,977 @@
 (* Title: BIBD 
    Author: Chelsea Edmonds
 *)
 
 theory BIBD imports Block_Designs
 begin 
 
 section \<open>BIBD's\<close>
 text \<open>BIBD's are perhaps the most commonly studied type of design in combinatorial design theory,
 and usually the first type of design explored in a design theory course. 
 These designs are a type of t-design, where $t = 2$\<close>
 
 subsection \<open>BIBD Basics\<close>
 locale bibd = t_design \<V> \<B> \<k> 2 \<Lambda> 
   for point_set ("\<V>") and block_collection ("\<B>") 
     and u_block_size ("\<k>") and index ("\<Lambda>")
 
 begin
 
 lemma min_block_size_2: "\<k> \<ge> 2" 
   using block_size_t by simp
 
 lemma points_index_pair: "y \<in> \<V> \<Longrightarrow> x \<in> \<V> \<Longrightarrow> x \<noteq> y \<Longrightarrow>  size ({# bl \<in># \<B> . {x, y} \<subseteq> bl#}) = \<Lambda>"
-  using balanced card_2_iff empty_subsetI insert_subset points_index_def
-  by (metis of_nat_numeral)
+  using balanced card_2_iff empty_subsetI insert_subset points_index_def by metis
 
 lemma index_one_empty_rm_blv [simp]:
   assumes "\<Lambda> = 1" and " blv \<in># \<B>" and "p \<subseteq> blv" and "card p = 2" 
   shows "{#bl \<in># remove1_mset blv \<B> . p \<subseteq> bl#} = {#}"
 proof -
   have blv_in: "blv \<in># filter_mset ((\<subseteq>) p) \<B>"
     using assms by simp
   have "p \<subseteq> \<V>" using assms wellformed by auto
   then have "size (filter_mset ((\<subseteq>) p) \<B>) = 1" 
     using balanced assms by (simp add: points_index_def)
   then show ?thesis using blv_in filter_diff_mset filter_single_mset
     by (metis (no_types, lifting) add_mset_eq_single assms(3) insert_DiffM size_1_singleton_mset) 
 qed 
 
 lemma index_one_alt_bl_not_exist:
   assumes "\<Lambda> = 1" and " blv \<in># \<B>" and "p \<subseteq> blv" and "card p = 2" 
   shows" \<And> bl. bl \<in># remove1_mset blv \<B> \<Longrightarrow> \<not> (p \<subseteq> bl) "
   using index_one_empty_rm_blv
   by (metis assms(1) assms(2) assms(3) assms(4) filter_mset_empty_conv)
 
 subsection \<open>Necessary Conditions for Existence\<close>
 
 text \<open>The necessary conditions on the existence of a $(v, k, \lambda)$-bibd are one of the 
 fundamental first theorems on designs. Proofs based off MATH3301 lecture notes \cite{HerkeLectureNotes2016}
  and Stinson \cite{stinsonCombinatorialDesignsConstructions2004}\<close>
 
 lemma necess_cond_1_rhs: 
   assumes "x \<in> \<V>"
   shows "size ({# p \<in># (mset_set (\<V> - {x}) \<times># {# bl \<in># \<B> . x \<in> bl #}). fst p \<in> snd p#}) = \<Lambda> * (\<v>- 1)"
 proof -
   let ?M = "mset_set (\<V> - {x})"
   let ?B = "{# bl \<in># \<B> . x \<in> bl #}"
   have m_distinct: "distinct_mset ?M" using assms mset_points_distinct_diff_one by simp
   have y_point: "\<And> y . y \<in># ?M \<Longrightarrow> y \<in> \<V>" using assms
     by (simp add: finite_sets) 
   have b_contents: "\<And> bl. bl \<in># ?B \<Longrightarrow> x \<in> bl" using assms by auto
   have "\<And> y. y \<in># ?M \<Longrightarrow> y \<noteq> x" using assms
     by (simp add: finite_sets) 
-  then have "\<And> y .y \<in># ?M \<Longrightarrow> size ({# bl \<in># ?B . {x, y} \<subseteq> bl#}) = nat \<Lambda>" 
-    using points_index_pair filter_filter_mset_ss_member y_point assms finite_sets index_ge_zero 
-    by (metis nat_0_le nat_int_comparison(1))
-  then have  "\<And> y .y \<in># ?M \<Longrightarrow> size ({# bl \<in># ?B . x \<in> bl \<and> y \<in> bl#}) = nat \<Lambda>"
+  then have "\<And> y .y \<in># ?M \<Longrightarrow> size ({# bl \<in># ?B . {x, y} \<subseteq> bl#}) = \<Lambda>" 
+    using points_index_pair filter_filter_mset_ss_member y_point assms finite_sets
+    by metis
+  then have  "\<And> y .y \<in># ?M \<Longrightarrow> size ({# bl \<in># ?B . x \<in> bl \<and> y \<in> bl#}) = \<Lambda>"
     by auto
-  then have bl_set_size: "\<And> y . y \<in># ?M \<Longrightarrow> size ({# bl \<in># ?B .  y \<in> bl#}) = nat \<Lambda>" 
+  then have bl_set_size: "\<And> y . y \<in># ?M \<Longrightarrow> size ({# bl \<in># ?B .  y \<in> bl#}) = \<Lambda>" 
     using b_contents by (metis (no_types, lifting) filter_mset_cong) 
-  then have final_size: "size (\<Sum>p\<in>#?M . ({#p#} \<times># {#bl \<in># ?B. p \<in> bl#})) = size (?M) * (nat \<Lambda>)" 
-    using m_distinct size_Union_distinct_cart_prod_filter bl_set_size index_ge_zero by blast  
+  then have final_size: "size (\<Sum>p\<in>#?M . ({#p#} \<times># {#bl \<in># ?B. p \<in> bl#})) = size (?M) * \<Lambda>" 
+    using m_distinct size_Union_distinct_cart_prod_filter bl_set_size by blast  
   have "size ?M = \<v> - 1" using v_non_zero
     by (simp add: assms(1) finite_sets) 
   thus ?thesis using final_size 
-    by (simp add: set_break_down_left index_ge_zero) 
+    by (simp add: set_break_down_left) 
 qed
 
 lemma necess_cond_1_lhs: 
   assumes "x \<in> \<V>"
   shows "size ({# p \<in># (mset_set (\<V> - {x}) \<times># {# bl \<in># \<B> . x \<in> bl #}). fst p \<in> snd p#}) 
       = (\<B> rep x) * (\<k> - 1)" 
     (is "size ({# p \<in># (?M \<times># ?B). fst p \<in> snd p#}) = (\<B> rep x) * (\<k> - 1) ")
 proof -
   have "\<And> y. y \<in># ?M \<Longrightarrow> y \<noteq> x" using assms
     by (simp add: finite_sets)
   have distinct_m: "distinct_mset ?M" using assms mset_points_distinct_diff_one by simp
   have finite_M: "finite (\<V> - {x})" using finite_sets by auto
   have block_choices: "size ?B = \<B> rep x"
     by (simp add: assms(1) point_replication_number_def)
   have bl_size: "\<forall> bl \<in># ?B. card {p \<in> \<V> . p \<in> bl } = \<k> " using uniform_unfold_point_set by simp
   have x_in_set: "\<forall> bl \<in># ?B . {x} \<subseteq> {p \<in> \<V>. p \<in> bl}" using assms by auto
   then have "\<forall> bl \<in># ?B. card {p \<in> (\<V> - {x}) . p \<in> bl } = card ({p \<in> \<V> . p \<in> bl } - {x})" 
     by (simp add: set_filter_diff_card)
   then have "\<forall> bl \<in># ?B. card {p \<in> (\<V> - {x}) . p \<in> bl } = \<k> - 1" 
     using bl_size x_in_set card_Diff_subset finite_sets k_non_zero by auto
-  then have "\<And> bl . bl \<in># ?B \<Longrightarrow> size {#p \<in># ?M . p \<in> bl#} = nat (\<k> - 1)" 
+  then have "\<And> bl . bl \<in># ?B \<Longrightarrow> size {#p \<in># ?M . p \<in> bl#} = \<k> - 1" 
     using assms finite_M card_size_filter_eq by auto
-  then have "size (\<Sum>bl\<in>#?B. ( {# p \<in># ?M . p \<in> bl #} \<times># {#bl#})) = size (?B) * nat (\<k> - 1)" 
+  then have "size (\<Sum>bl\<in>#?B. ( {# p \<in># ?M . p \<in> bl #} \<times># {#bl#})) = size (?B) * (\<k> - 1)" 
     using distinct_m size_Union_distinct_cart_prod_filter2 by blast
   thus ?thesis using block_choices k_non_zero by (simp add: set_break_down_right)
 qed
 
 lemma r_constant: "x \<in> \<V> \<Longrightarrow> (\<B> rep x) * (\<k> -1) = \<Lambda> * (\<v> - 1)"
   using necess_cond_1_rhs necess_cond_1_lhs design_points_nempty by force
 
 lemma replication_number_value:
   assumes "x \<in> \<V>"
   shows "(\<B> rep x) = \<Lambda> * (\<v> - 1) div (\<k> - 1)"
-  using min_block_size_2 r_constant assms diff_gt_0_iff_gt diff_self zle_diff1_eq numeral_le_one_iff
-  by (metis less_int_code(1) linorder_neqE_linordered_idom nonzero_mult_div_cancel_right semiring_norm(69))
+  using min_block_size_2 r_constant assms
+  by (metis diff_is_0_eq diffs0_imp_equal div_by_1 k_non_zero nonzero_mult_div_cancel_right 
+      one_div_two_eq_zero one_le_numeral zero_neq_one)
   
 lemma r_constant_alt: "\<forall> x \<in> \<V>. \<B> rep x = \<Lambda> * (\<v> - 1) div (\<k> - 1)"
   using r_constant replication_number_value by blast 
 
 end 
 
 text \<open>Using the first necessary condition, it is possible to show that a bibd has 
 a constant replication number\<close>
 
 sublocale bibd \<subseteq> constant_rep_design \<V> \<B>  "(\<Lambda> * (\<v> - 1) div (\<k> - 1))"
   using r_constant_alt by (unfold_locales) simp_all
 
 lemma (in t_design) bibdI [intro]: "\<t> = 2 \<Longrightarrow> bibd \<V> \<B> \<k> \<Lambda>\<^sub>t"
   using t_lt_order block_size_t by (unfold_locales) (simp_all)
 
 context bibd
 begin
 
 abbreviation "\<r> \<equiv> (\<Lambda> * (\<v> - 1) div (\<k> - 1))"
 
 lemma necessary_condition_one: 
   shows "\<r> * (\<k> - 1) = \<Lambda> * (\<v> - 1)"
   using necess_cond_1_rhs necess_cond_1_lhs design_points_nempty rep_number by auto
 
 lemma bibd_point_occ_rep: 
   assumes "x \<in> bl"
   assumes "bl \<in># \<B>"
   shows  "(\<B> - {#bl#}) rep x = \<r> - 1"
 proof -
   have xin: "x \<in> \<V>" using assms wf_invalid_point by blast
   then have rep: "size {# blk \<in># \<B>. x \<in> blk #} = \<r>" using rep_number_unfold_set by simp
   have "(\<B> - {#bl#}) rep x = size {# blk \<in># (\<B> - {#bl#}). x \<in> blk #}" 
     by (simp add: point_replication_number_def)
   then have "(\<B> - {#bl#}) rep x = size {# blk \<in># \<B>. x \<in> blk #} - 1"
     by (simp add: assms size_Diff_singleton) 
   then show ?thesis using assms rep r_gzero by simp
 qed 
 
 lemma necess_cond_2_lhs: "size {# x \<in># (mset_set \<V> \<times># \<B>) . (fst x) \<in> (snd x)  #} = \<v> * \<r>" 
 proof -
   let ?M = "mset_set \<V>"
-  have "\<And> p . p \<in># ?M \<Longrightarrow> size ({# bl \<in># \<B> . p \<in> bl #}) = nat (\<r>)"
+  have "\<And> p . p \<in># ?M \<Longrightarrow> size ({# bl \<in># \<B> . p \<in> bl #}) = \<r>"
     using finite_sets rep_number_unfold_set r_gzero nat_eq_iff2 by auto 
-  then have "size (\<Sum>p\<in>#?M. ({#p#} \<times># {#bl \<in># \<B>. p \<in> bl#})) = size ?M * nat (\<r>)" 
+  then have "size (\<Sum>p\<in>#?M. ({#p#} \<times># {#bl \<in># \<B>. p \<in> bl#})) = size ?M * (\<r>)" 
     using mset_points_distinct size_Union_distinct_cart_prod_filter by blast
   thus ?thesis using r_gzero
     by (simp add: set_break_down_left)  
 qed
 
 lemma necess_cond_2_rhs: "size {# x \<in># (mset_set \<V> \<times># \<B>) . (fst x) \<in> (snd x)  #} = \<b>*\<k>" 
   (is "size {# x \<in># (?M \<times># ?B). (fst x) \<in> (snd x)  #} = \<b>*\<k>")
 proof -
-  have "\<And> bl . bl \<in># ?B \<Longrightarrow> size ({# p \<in># ?M . p \<in> bl #}) = nat \<k>" 
+  have "\<And> bl . bl \<in># ?B \<Longrightarrow> size ({# p \<in># ?M . p \<in> bl #}) = \<k>" 
     using uniform k_non_zero uniform_unfold_point_set_mset by fastforce
-  then have "size (\<Sum>bl\<in>#?B. ( {# p \<in># ?M . p \<in> bl #} \<times># {#bl#})) = size (?B) * (nat \<k>)" 
+  then have "size (\<Sum>bl\<in>#?B. ( {# p \<in># ?M . p \<in> bl #} \<times># {#bl#})) = size (?B) * \<k>" 
     using mset_points_distinct size_Union_distinct_cart_prod_filter2 by blast
   thus ?thesis using k_non_zero by (simp add: set_break_down_right)
 qed
 
 lemma necessary_condition_two:
   shows "\<v> * \<r> = \<b> * \<k>"
   using necess_cond_2_lhs necess_cond_2_rhs by simp
 
 theorem admissability_conditions:
 "\<r> * (\<k> - 1) = \<Lambda> * (\<v> - 1)"
 "\<v> * \<r> = \<b> * \<k>"
   using necessary_condition_one necessary_condition_two by auto
 
 subsubsection \<open>BIBD Param Relationships\<close>
 
 lemma bibd_block_number: "\<b> = \<Lambda> * \<v> * (\<v> - 1) div (\<k> * (\<k>-1))"
 proof -
   have "\<b> * \<k> = (\<v> * \<r>)" using necessary_condition_two by simp
   then have k_dvd: "\<k> dvd (\<v> * \<r>)" by (metis dvd_triv_right) 
   then have "\<b> = (\<v> * \<r>) div \<k>" using necessary_condition_two min_block_size_2 by auto
   then have "\<b> = (\<v> * ((\<Lambda> * (\<v> - 1) div (\<k> - 1)))) div \<k>" by simp
   then have "\<b> = (\<v> * \<Lambda> * (\<v> - 1)) div ((\<k> - 1)* \<k>)" using necessary_condition_one 
-      necessary_condition_two dvd_div_div_eq_mult dvd_div_eq_0_iff
-    by (smt (z3) dvd_triv_right mult.assoc mult.commute mult.left_commute mult_eq_0_iff ) 
+      necessary_condition_two dvd_div_div_eq_mult dvd_div_eq_0_iff dvd_triv_right mult.assoc 
+      mult.commute mult.left_commute mult_eq_0_iff
+    by (smt (z3) b_non_zero) 
   then show ?thesis by (simp add: mult.commute) 
 qed
 
 lemma symmetric_condition_1: "\<Lambda> * (\<v> - 1) = \<k> * (\<k> - 1) \<Longrightarrow> \<b> = \<v> \<and> \<r> = \<k>"
   using b_non_zero bibd_block_number mult_eq_0_iff necessary_condition_two necessary_condition_one 
   by auto
 
 lemma index_lt_replication: "\<Lambda> < \<r>"
 proof -
   have 1: "\<r> * (\<k> - 1) = \<Lambda> * (\<v> - 1)" using admissability_conditions by simp
   have lhsnot0: "\<r> * (\<k> - 1) \<noteq> 0"
-    using no_zero_divisors rep_not_zero zdiv_eq_0_iff by blast 
-  then have rhsnot0: "\<Lambda> * (\<v> - 1) \<noteq> 0" using 1 by simp 
+    using no_zero_divisors rep_not_zero by (metis div_by_0) 
+  then have rhsnot0: "\<Lambda> * (\<v> - 1) \<noteq> 0" using 1 by presburger 
   have "\<k> - 1 < \<v> - 1" using incomplete b_non_zero bibd_block_number not_less_eq by fastforce 
-  thus ?thesis using 1 lhsnot0 rhsnot0
-    by (smt (verit, best) k_non_zero mult_le_less_imp_less r_gzero) 
+  thus ?thesis using 1 lhsnot0 rhsnot0 k_non_zero mult_le_less_imp_less r_gzero
+    by (metis div_greater_zero_iff less_or_eq_imp_le nat_less_le nat_neq_iff) 
 qed
 
 lemma index_not_zero: "\<Lambda> \<ge> 1"
-  using index_ge_zero index_lt_replication int_one_le_iff_zero_less by fastforce 
+  by (metis div_0 leI less_one mult_not_zero rep_not_zero) 
 
 lemma r_ge_two: "\<r> \<ge> 2"
   using index_lt_replication index_not_zero by linarith
 
 lemma block_num_gt_rep: "\<b> > \<r>"
 proof -
   have fact: "\<b> * \<k> = \<v> * \<r>" using admissability_conditions by auto
   have lhsnot0: "\<b> * \<k> \<noteq> 0" using k_non_zero b_non_zero by auto 
   then have rhsnot0: "\<v> * \<r> \<noteq> 0" using fact by simp
   then show ?thesis using incomplete lhsnot0
     using complement_rep_number constant_rep_design.r_gzero incomplete_imp_incomp_block by fastforce 
 qed
 
 lemma bibd_subset_occ: 
   assumes "x \<subseteq> bl" and "bl \<in># \<B>" and "card x = 2"
   shows "size {# blk \<in># (\<B> - {#bl#}). x \<subseteq> blk #} = \<Lambda> - 1"
 proof - 
   have index: "size {# blk \<in># \<B>. x \<subseteq> blk #} = \<Lambda>" using points_index_def balanced assms
-    by (metis (full_types) of_nat_numeral subset_eq wf_invalid_point) 
+    by (metis (full_types) subset_eq wf_invalid_point) 
   then have "size {# blk \<in># (\<B> - {#bl#}). x \<subseteq> blk #} = size {# blk \<in># \<B>. x \<subseteq> blk #} - 1" 
     by (simp add: assms size_Diff_singleton) 
   then show ?thesis using assms index_not_zero index by simp
 qed
 
 lemma necess_cond_one_param_balance: "\<b> > \<v> \<Longrightarrow> \<r> > \<k>"
-  using necessary_condition_two
-  by (smt mult_nonneg_nonneg nonzero_mult_div_cancel_right of_nat_0_le_iff r_gzero zdiv_mono2)
+  using necessary_condition_two b_positive
+  by (metis div_le_mono2 div_mult_self1_is_m div_mult_self_is_m nat_less_le r_gzero v_non_zero)
 
 subsection \<open>Constructing New bibd's\<close>
 text \<open>There are many constructions on bibd's to establish new bibds (or other types of designs). 
 This section demonstrates this using both existing constructions, and by defining new constructions.\<close>
 subsubsection \<open>BIBD Complement, Multiple, Combine\<close>
 
 lemma comp_params_index_pair:
   assumes "{x, y} \<subseteq> \<V>"
   assumes "x \<noteq> y"
   shows "\<B>\<^sup>C index {x, y} = \<b> + \<Lambda> - 2*\<r>"
 proof -
   have xin: "x \<in> \<V>" and yin: "y \<in> \<V>" using assms by auto
   have ge: "2*\<r> \<ge> \<Lambda>" using index_lt_replication
     using r_gzero by linarith 
-  have "size {# b \<in># \<B> . x \<in> b \<and> y \<in> b#} =  \<Lambda>" using points_index_pair assms by simp
-  then have lambda: "size {# b \<in># \<B> . x \<in> b \<and> y \<in> b#} = nat \<Lambda>" 
-    using index_ge_zero by auto 
-  have "\<B>\<^sup>C index {x, y} = size {# b \<in># \<B> . x \<notin> b \<and> y \<notin> b #}" 
+  have lambda: "size {# b \<in># \<B> . x \<in> b \<and> y \<in> b#} = \<Lambda>" using points_index_pair assms by simp
+  have s1: "\<B>\<^sup>C index {x, y} = size {# b \<in># \<B> . x \<notin> b \<and> y \<notin> b #}" 
     using complement_index_2 assms by simp
-  also have "\<dots> = size \<B> - (size {# b \<in># \<B> . \<not> (x \<notin> b \<and> y \<notin> b) #})" 
+  also have s2: "... = size \<B> - (size {# b \<in># \<B> . \<not> (x \<notin> b \<and> y \<notin> b) #})" 
     using size_filter_neg by blast
   also have "... = size \<B> - (size {# b \<in># \<B> . x \<in> b \<or> y \<in> b#})" by auto
   also have "... = \<b> - (size {# b \<in># \<B> . x \<in> b \<or> y \<in> b#})" by (simp add: of_nat_diff)
-  also have "... = \<b> - (size {# b \<in># \<B> . x \<in> b#} +  
+  finally have "\<B>\<^sup>C index {x, y} = \<b> - (size {# b \<in># \<B> . x \<in> b#} +  
     size {# b \<in># \<B> . y \<in> b#} -  size {# b \<in># \<B> . x \<in> b \<and> y \<in> b#})" 
-    by (simp add: mset_size_partition_dep) 
-  also have "... = \<b> - (nat \<r> + nat \<r> - nat (\<Lambda>))" using rep_number_unfold_set lambda xin yin
-    by (metis (no_types, lifting) nat_int)
-  finally have "\<B>\<^sup>C index {x, y} = \<b> - (2*\<r> - \<Lambda>)"
-    using index_ge_zero index_lt_replication by linarith
+    by (simp add: mset_size_partition_dep s2 s1) 
+  then have "\<B>\<^sup>C index {x, y} = \<b> - (\<r> + \<r> - \<Lambda>)" using rep_number_unfold_set lambda xin yin
+    by presburger
+  then have "\<B>\<^sup>C index {x, y} = \<b> - (2*\<r> - \<Lambda>)"
+    using index_lt_replication by (metis mult_2) 
   thus ?thesis using ge diff_diff_right by simp  
 qed
 
 lemma complement_bibd_index: 
   assumes "ps \<subseteq> \<V>"
   assumes "card ps = 2"
   shows "\<B>\<^sup>C index ps = \<b> + \<Lambda> - 2*\<r>"
 proof -
   obtain x y where set: "ps = {x, y}" using b_non_zero bibd_block_number diff_is_0_eq incomplete 
     mult_0_right nat_less_le design_points_nempty assms by (metis card_2_iff) 
   then have "x \<noteq> y" using assms by auto 
   thus ?thesis using comp_params_index_pair assms
     by (simp add: set)
 qed
 
 lemma complement_bibd: 
   assumes "\<k> \<le> \<v> - 2" 
   shows "bibd \<V> \<B>\<^sup>C (\<v> - \<k>) (\<b> + \<Lambda> - 2*\<r>)"
 proof -
   interpret des: incomplete_design \<V> "\<B>\<^sup>C" "(\<v> - \<k>)" 
     using assms complement_incomplete by blast
   show ?thesis proof (unfold_locales, simp_all)
     show "2 \<le> des.\<v>" using assms block_size_t by linarith 
     show "\<And>ps. ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> 
-      \<B>\<^sup>C index ps = \<b> + \<Lambda> - 2 * (\<Lambda> * (des.\<v> - 1) div (\<k> - 1))" 
+      \<B>\<^sup>C index ps = \<b> + \<Lambda> - 2 * (\<Lambda> * (des.\<v> - Suc 0) div (\<k> - Suc 0))" 
       using complement_bibd_index by simp
     show "2 \<le> des.\<v> - \<k>" using assms block_size_t by linarith 
   qed
 qed
 
 lemma multiple_bibd: "n > 0 \<Longrightarrow> bibd \<V> (multiple_blocks n) \<k> (\<Lambda> * n)"
   using multiple_t_design by (simp add: bibd_def)  
 
 end 
 
 locale two_bibd_eq_points = two_t_designs_eq_points \<V> \<B> \<k> \<B>' 2 \<Lambda> \<Lambda>'
   + des1: bibd \<V> \<B> \<k> \<Lambda> + des2: bibd \<V> \<B>' \<k> \<Lambda>' for \<V> \<B> \<k> \<B>' \<Lambda> \<Lambda>'
 begin
 
 lemma combine_is_bibd: "bibd \<V>\<^sup>+ \<B>\<^sup>+ \<k> (\<Lambda> + \<Lambda>')"
   by (unfold_locales)
 
 sublocale combine_bibd: bibd "\<V>\<^sup>+" "\<B>\<^sup>+" "\<k>" "(\<Lambda> + \<Lambda>')"
   by (unfold_locales)
 
 end 
 
 subsubsection \<open>Derived Designs\<close>
 text \<open>A derived bibd takes a block from a valid bibd as the new point sets, and the intersection 
 of that block with other blocks as it's block set\<close>
 
 locale bibd_block_transformations = bibd + 
   fixes block :: "'a set" ("bl")
   assumes valid_block: "bl \<in># \<B>"
 begin
 
 definition derived_blocks :: "'a set multiset" ("(\<B>\<^sup>D)") where 
 "\<B>\<^sup>D \<equiv> {# bl \<inter> b . b \<in># (\<B> - {#bl#}) #}"
 
 lemma derive_define_flip: "{# b \<inter> bl . b \<in># (\<B> - {#bl#}) #} = \<B>\<^sup>D"
   by (simp add: derived_blocks_def inf_sup_aci(1))
 
 lemma derived_points_order: "card bl = \<k>"
   using uniform valid_block by simp
 
 lemma derived_block_num: "bl \<in># \<B> \<Longrightarrow> size \<B>\<^sup>D = \<b> - 1"
-  apply (simp add: derived_blocks_def size_remove1_mset_If valid_block)
-  using valid_block int_ops(6) by fastforce
+  by (simp add: derived_blocks_def size_remove1_mset_If valid_block)
 
 lemma derived_is_wellformed:  "b \<in># \<B>\<^sup>D \<Longrightarrow> b \<subseteq> bl"
   by (simp add: derived_blocks_def valid_block) (auto)
 
 lemma derived_point_subset_orig: "ps \<subseteq> bl \<Longrightarrow> ps \<subset> \<V>"
   by (simp add: valid_block incomplete_imp_proper_subset subset_psubset_trans) 
 
 lemma derived_obtain_orig_block: 
   assumes "b \<in># \<B>\<^sup>D"
   obtains b2 where "b = b2 \<inter> bl" and "b2 \<in># remove1_mset bl \<B>"
   using assms derived_blocks_def by auto
 
 sublocale derived_incidence_sys: incidence_system "bl" "\<B>\<^sup>D"
   using derived_is_wellformed valid_block by (unfold_locales) (auto)
 
 sublocale derived_fin_incidence_system: finite_incidence_system "bl" "\<B>\<^sup>D"
   using valid_block finite_blocks by (unfold_locales) simp_all
 
 lemma derived_blocks_nempty:
   assumes "\<And> b .b \<in># remove1_mset bl \<B> \<Longrightarrow> bl |\<inter>| b > 0"
   assumes "bld \<in># \<B>\<^sup>D"
   shows "bld \<noteq> {}"
 proof -
   obtain bl2 where inter: "bld = bl2 \<inter> bl" and member: "bl2 \<in># remove1_mset bl \<B>" 
     using assms derived_obtain_orig_block by blast
   then have "bl |\<inter>| bl2 > 0" using assms(1) by blast
   thus ?thesis using intersection_number_empty_iff finite_blocks valid_block
     by (metis Int_commute dual_order.irrefl inter) 
 qed
 
 lemma derived_is_design:
   assumes "\<And> b. b \<in># remove1_mset bl \<B> \<Longrightarrow> bl |\<inter>| b > 0"
   shows "design bl \<B>\<^sup>D"
 proof -
   interpret fin: finite_incidence_system "bl" "\<B>\<^sup>D"
     by (unfold_locales)
   show ?thesis using assms derived_blocks_nempty by (unfold_locales) simp
 qed
 
 lemma derived_is_proper: 
   assumes "\<And> b. b \<in># remove1_mset bl \<B> \<Longrightarrow> bl |\<inter>| b > 0"
   shows "proper_design bl \<B>\<^sup>D"
 proof -
   interpret des: design "bl" "\<B>\<^sup>D" 
     using derived_is_design assms by fastforce 
   have "\<b> - 1 > 1" using block_num_gt_rep r_ge_two by linarith  
   then show ?thesis by (unfold_locales) (simp add: derived_block_num valid_block)
 qed
 
 
 subsubsection \<open>Residual Designs\<close>
 text \<open>Similar to derived designs, a residual design takes the complement of a block bl as it's new
 point set, and the complement of all other blocks with respect to bl.\<close>
 
 definition residual_blocks :: "'a set multiset" ("(\<B>\<^sup>R)") where
 "\<B>\<^sup>R \<equiv> {# b - bl . b \<in># (\<B> - {#bl#}) #}" 
 
 lemma residual_order: "card (bl\<^sup>c) = \<v> - \<k>" 
-  apply (simp add: valid_block wellformed block_complement_size)
-  using block_size_lt_v derived_points_order by auto
+  by (simp add: valid_block wellformed block_complement_size)
 
 lemma residual_block_num: "size (\<B>\<^sup>R) = \<b> - 1"
   using b_positive by (simp add: residual_blocks_def size_remove1_mset_If valid_block int_ops(6))
 
 lemma residual_obtain_orig_block: 
   assumes "b \<in># \<B>\<^sup>R"
   obtains bl2 where "b = bl2 - bl" and "bl2 \<in># remove1_mset bl \<B>"
   using assms residual_blocks_def by auto
 
 lemma residual_blocks_ss: assumes "b \<in># \<B>\<^sup>R" shows "b \<subseteq> \<V>"
 proof -
   have "b \<subseteq> (bl\<^sup>c)" using residual_obtain_orig_block
     by (metis Diff_mono assms block_complement_def in_diffD order_refl wellformed)
   thus ?thesis
     using block_complement_subset_points by auto 
 qed
 
 lemma residual_blocks_exclude: "b \<in># \<B>\<^sup>R \<Longrightarrow> x \<in> b \<Longrightarrow> x \<notin> bl"
   using residual_obtain_orig_block by auto
 
 lemma residual_is_wellformed:  "b \<in># \<B>\<^sup>R \<Longrightarrow> b \<subseteq> (bl\<^sup>c)"
   apply (auto simp add: residual_blocks_def)
   by (metis DiffI block_complement_def in_diffD wf_invalid_point) 
 
 sublocale residual_incidence_sys: incidence_system "bl\<^sup>c" "\<B>\<^sup>R"
   using residual_is_wellformed by (unfold_locales)
 
 lemma residual_is_finite: "finite (bl\<^sup>c)"
   by (simp add: block_complement_def finite_sets)
 
 sublocale residual_fin_incidence_sys: finite_incidence_system "bl\<^sup>c" "\<B>\<^sup>R"
   using residual_is_finite by (unfold_locales) 
 
 lemma residual_blocks_nempty:
   assumes "bld \<in># \<B>\<^sup>R"
   assumes "multiplicity bl = 1" 
   shows "bld \<noteq> {}"
 proof -
   obtain bl2 where inter: "bld = bl2 - bl" and member: "bl2 \<in># remove1_mset bl \<B>" 
     using assms residual_blocks_def by auto 
   then have ne: "bl2 \<noteq> bl" using assms
     by (metis count_eq_zero_iff in_diff_count less_one union_single_eq_member)
   have "card bl2 = card bl" using uniform valid_block member
-    by (metis in_diffD of_nat_eq_iff)  
+    using in_diffD by fastforce
   then have "card (bl2 - bl) > 0" 
     using finite_blocks member uniform set_card_diff_ge_zero valid_block by (metis in_diffD ne) 
   thus ?thesis using inter by fastforce 
 qed
 
 lemma residual_is_design: "multiplicity bl = 1 \<Longrightarrow> design (bl\<^sup>c) \<B>\<^sup>R"
   using residual_blocks_nempty by (unfold_locales)
 
 lemma residual_is_proper: 
   assumes "multiplicity bl = 1" 
   shows "proper_design (bl\<^sup>c) \<B>\<^sup>R"
 proof -
   interpret des: design "bl\<^sup>c" "\<B>\<^sup>R" using residual_is_design assms by blast 
   have "\<b> - 1 > 1" using r_ge_two block_num_gt_rep by linarith 
   then show ?thesis using residual_block_num by (unfold_locales) auto
 qed
 
 end
 
 subsection \<open>Symmetric BIBD's\<close>
 text \<open>Symmetric bibd's are those where the order of the design equals the number of blocks\<close>
 
 locale symmetric_bibd = bibd + 
   assumes symmetric: "\<b> = \<v>"
 begin
 
 lemma rep_value_sym: "\<r> = \<k>"
   using b_non_zero local.symmetric necessary_condition_two by auto
 
 lemma symmetric_condition_2: "\<Lambda> * (\<v> - 1) = \<k> * (\<k> - 1)"
   using necessary_condition_one rep_value_sym by auto
 
 lemma sym_design_vk_gt_kl: 
   assumes "\<k> \<ge> \<Lambda> + 2"
   shows "\<v> - \<k> > \<k> - \<Lambda>"
 proof (rule ccontr)
+  define k l v where kdef: "k \<equiv> int \<k>" and ldef: "l \<equiv> int \<Lambda>" and vdef: "v \<equiv> int \<v>"
   assume "\<not> (\<v> - \<k> > \<k> - \<Lambda>)"
-  then have "\<v> \<le> 2 * \<k> - \<Lambda>"
-    by linarith
-  then have "\<v> - 1 \<le> 2 * \<k> - \<Lambda> - 1" by linarith
-  then have "\<Lambda>* (\<v> - 1) \<le> \<Lambda>*( 2 * \<k> - \<Lambda> - 1)"
-    using index_ge_zero mult_le_cancel_left by fastforce 
-  then have "\<k> * (\<k> - 1) \<le> \<Lambda>*( 2 * \<k> - \<Lambda> - 1)"
-    by (simp add: symmetric_condition_2)
-  then have "\<k> * (\<k> - 1) - \<Lambda>*( 2 * \<k> - \<Lambda> - 1) \<le> 0" by linarith
-  then have "(\<k> - \<Lambda>)*(\<k> - \<Lambda> - 1) \<le> 0"
-    by (simp add: mult.commute right_diff_distrib')
-  then have "\<k> = \<Lambda> \<or> \<k> = \<Lambda> + 1"
+  then have a: "\<not> (v - k > k - l)" using kdef ldef vdef
+    by (metis block_size_lt_v index_lt_replication less_imp_le_nat of_nat_diff of_nat_less_imp_less 
+        rep_value_sym) 
+  have lge: "l \<ge> 0" using ldef by simp 
+  have sym: "l * (v- 1) = k * (k - 1)" 
+    using symmetric_condition_2 ldef vdef kdef
+    by (metis (mono_tags, lifting) block_size_lt_v int_ops(2) k_non_zero le_trans of_nat_diff of_nat_mult) 
+  then have "v \<le> 2 * k - l" using a by linarith
+  then have "v - 1 \<le> 2 * k - l - 1" by linarith
+  then have "l* (v - 1) \<le> l*( 2 * k - l - 1)"
+    using lge mult_le_cancel_left by fastforce 
+  then have "k * (k - 1) \<le> l*( 2 * k - l - 1)"
+    by (simp add: sym)
+  then have "k * (k - 1) - l*( 2 * k - l - 1) \<le> 0" by linarith
+  then have "k^2 - k - l* 2 * k + l^2 + l \<le> 0" using  mult.commute right_diff_distrib'
+    by (smt (z3) mult_cancel_left1 power2_diff ring_class.ring_distribs(2)) 
+  then have "(k - l)*(k - l - 1) \<le> 0" using  mult.commute right_diff_distrib'
+    by (smt (z3) \<open>k * (k - 1) \<le> l * (2 * k - l - 1)\<close> combine_common_factor) 
+  then have "k = l \<or> k = l + 1"
     using mult_le_0_iff by force
-  thus False using assms
-    by simp 
+  thus False using assms kdef ldef by auto
 qed
 
 end 
 
 context bibd
 begin
 
 lemma symmetric_bibdI: "\<b> = \<v> \<Longrightarrow> symmetric_bibd \<V> \<B> \<k> \<Lambda>"
   by unfold_locales simp
 
 lemma symmetric_bibdII: "\<Lambda> * (\<v> - 1) = \<k> * (\<k> - 1) \<Longrightarrow> symmetric_bibd \<V> \<B> \<k> \<Lambda>"
   using symmetric_condition_1 by unfold_locales blast 
 
 lemma symmetric_not_admissable: "\<Lambda> * (\<v> - 1) \<noteq> \<k> * (\<k> - 1) \<Longrightarrow> \<not> symmetric_bibd \<V> \<B> \<k> \<Lambda>"
   using symmetric_bibd.symmetric_condition_2 by blast 
 end
 
 context symmetric_bibd
 begin
 
 subsubsection \<open>Intersection Property on Symmetric BIBDs\<close>
 text \<open>Below is a proof of an important property on symmetric BIBD's regarding the equivalence
 of intersection numbers and the design index. This is an intuitive counting proof, and involved
 significantly more work in a formal environment. Based of Lecture Note \cite{HerkeLectureNotes2016}\<close>
 
 lemma intersect_mult_set_eq_block:
   assumes "blv \<in># \<B>"
   shows "p \<in># \<Sum>\<^sub>#{# mset_set (bl \<inter> blv) .bl \<in># (\<B> - {#blv#})#} \<longleftrightarrow> p \<in> blv"
 proof (auto, simp add: assms finite_blocks)
   assume assm: "p \<in> blv"
   then have "(\<B> - {#blv#}) rep p > 0" using bibd_point_occ_rep r_ge_two assms by auto 
   then obtain bl where "bl \<in># (\<B> - {#blv#}) \<and> p \<in> bl" using assms rep_number_g0_exists by metis
   then show "\<exists>x\<in>#remove1_mset blv \<B>. p \<in># mset_set (x \<inter> blv)" 
     using assms assm finite_blocks by auto 
 qed
 
 lemma intersect_mult_set_block_subset_iff:
   assumes "blv \<in># \<B>"
   assumes "p \<in># \<Sum>\<^sub>#{# mset_set {y .y \<subseteq> blv \<inter> b2 \<and> card y = 2} .b2 \<in># (\<B> - {#blv#})#}"
   shows "p \<subseteq> blv"
 proof (rule subsetI)
   fix x
   assume asm: "x \<in> p"
   obtain b2 where "p \<in># mset_set {y . y \<subseteq> blv \<inter> b2 \<and> card y = 2} \<and> b2 \<in>#(\<B> - {#blv#})" 
     using assms by blast
   then have "p \<subseteq> blv \<inter> b2"
     by (metis (no_types, lifting) elem_mset_set equals0D infinite_set_mset_mset_set mem_Collect_eq) 
   thus "x \<in> blv" using asm by auto
 qed
 
 lemma intersect_mult_set_block_subset_card:
   assumes "blv \<in># \<B>"
   assumes "p \<in># \<Sum>\<^sub>#{# mset_set {y .y \<subseteq> blv \<inter> b2 \<and> card y = 2} .b2 \<in># (\<B> - {#blv#})#}"
   shows "card p = 2"
 proof -
   obtain b2 where "p \<in># mset_set {y . y \<subseteq> blv \<inter> b2 \<and> card y = 2} \<and> b2 \<in>#(\<B> - {#blv#})" 
     using assms by blast
   thus ?thesis
     by (metis (mono_tags, lifting) elem_mset_set equals0D infinite_set_mset_mset_set mem_Collect_eq) 
 qed
 
 lemma intersect_mult_set_block_with_point_exists: 
   assumes "blv \<in># \<B>" and  "p \<subseteq> blv" and "\<Lambda> \<ge> 2" and "card p = 2"
   shows "\<exists>x\<in>#remove1_mset blv \<B>. p \<in># mset_set {y. y \<subseteq> blv \<and> y \<subseteq> x \<and> card y = 2}"
 proof -
   have "size {#b \<in># \<B> . p \<subseteq> b#} = \<Lambda>" using points_index_def assms 
-    by (metis balanced_alt_def_all dual_order.trans of_nat_numeral wellformed) 
+    by (metis balanced_alt_def_all dual_order.trans wellformed) 
   then have "size {#bl \<in># (\<B> - {#blv#}) . p \<subseteq> bl#} \<ge> 1"  
     using assms by (simp add: size_Diff_singleton)
   then obtain bl where "bl \<in># (\<B> - {#blv#}) \<and> p \<subseteq> bl" using assms filter_mset_empty_conv
      by (metis diff_diff_cancel diff_is_0_eq' le_numeral_extra(4) size_empty zero_neq_one) 
   thus ?thesis 
     using assms finite_blocks by auto 
 qed
 
 lemma intersect_mult_set_block_subset_iff_2:
   assumes "blv \<in># \<B>" and  "p \<subseteq> blv" and "\<Lambda> \<ge> 2" and "card p = 2"
   shows "p \<in># \<Sum>\<^sub>#{# mset_set {y .y \<subseteq> blv \<inter> b2 \<and> card y = 2} .b2 \<in># (\<B> - {#blv#})#}"
   by (auto simp add: intersect_mult_set_block_with_point_exists assms)
 
 lemma sym_sum_mset_inter_sets_count: 
   assumes "blv \<in># \<B>"
   assumes "p \<in> blv"
   shows "count (\<Sum>\<^sub>#{# mset_set (bl \<inter> blv) .bl \<in># (\<B> - {#blv#})#}) p = \<r> - 1" 
     (is "count (\<Sum>\<^sub>#?M) p = \<r> - 1")
 proof -
   have size_inter: "size {# mset_set (bl \<inter> blv) | bl  \<in># (\<B> - {#blv#}) . p \<in> bl#} = \<r> - 1"
     using bibd_point_occ_rep point_replication_number_def
     by (metis assms(1) assms(2) size_image_mset)  
   have inter_finite: "\<forall> bl \<in># (\<B> - {#blv#}) . finite (bl \<inter> blv)"
     by (simp add: assms(1) finite_blocks)
   have "\<And> bl . bl \<in># (\<B> - {#blv#}) \<Longrightarrow> p \<in> bl \<longrightarrow> count (mset_set (bl \<inter> blv)) p = 1"
     using assms count_mset_set(1) inter_finite by simp 
   then have "\<And> bl . bl \<in># {#b1 \<in>#(\<B> - {#blv#}) . p \<in> b1#} \<Longrightarrow> count (mset_set (bl \<inter> blv)) p = 1"
     by (metis (full_types) count_eq_zero_iff count_filter_mset) 
   then have pin: "\<And> P. P \<in># {# mset_set (bl \<inter> blv) | bl \<in># (\<B> - {#blv#}) . p \<in> bl#} 
       \<Longrightarrow> count P p = 1" by blast
   have "?M = {# mset_set (bl \<inter> blv) | bl \<in># (\<B> - {#blv#}) . p \<in> bl#} 
       + {# mset_set (bl \<inter> blv) | bl \<in># (\<B> - {#blv#}) . p \<notin> bl#}"
     by (metis image_mset_union multiset_partition) 
   then have "count (\<Sum>\<^sub>#?M) p = size {# mset_set (bl \<inter> blv) | bl \<in># (\<B> - {#blv#}) . p \<in> bl#} " 
     using pin by (auto simp add: count_sum_mset)
   then show ?thesis using size_inter by linarith   
 qed
 
 lemma sym_sum_mset_inter_sets_size: 
   assumes "blv \<in># \<B>"
   shows "size (\<Sum>\<^sub>#{# mset_set (bl \<inter> blv) .bl \<in># (\<B> - {#blv#})#}) = \<k> * (\<r> - 1)" 
     (is "size (\<Sum>\<^sub>#?M) = \<k>* (\<r> - 1)")
 proof - 
   have eq: "set_mset (\<Sum>\<^sub>#{# mset_set (bl \<inter> blv) .bl \<in># (\<B> - {#blv#})#}) = blv" 
     using intersect_mult_set_eq_block assms by auto
   then have k: "card (set_mset (\<Sum>\<^sub>#?M)) = \<k>"
     by (simp add: assms)
   have "\<And> p. p \<in># (\<Sum>\<^sub>#?M) \<Longrightarrow> count (\<Sum>\<^sub>#?M) p = \<r> - 1" 
     using sym_sum_mset_inter_sets_count assms eq by blast 
-  thus ?thesis using k size_multiset_int_count by metis
+  thus ?thesis using k size_multiset_set_mset_const_count by metis
 qed
 
 lemma sym_sum_inter_num: 
   assumes "b1 \<in># \<B>" 
   shows "(\<Sum>b2 \<in>#(\<B> - {#b1#}). b1 |\<inter>| b2) = \<k>* (\<r> - 1)"
 proof -
   have "(\<Sum>b2 \<in>#(\<B> - {#b1#}). b1 |\<inter>| b2) = (\<Sum>b2 \<in>#(\<B> - {#b1#}). size (mset_set (b1 \<inter> b2)))" 
     by (simp add: intersection_number_def)
   also have "... = size (\<Sum>\<^sub>#{#mset_set (b1 \<inter> bl). bl \<in># (\<B> - {#b1#})#})"
     by (auto simp add: size_big_union_sum) 
   also have "... =  size (\<Sum>\<^sub>#{#mset_set (bl \<inter> b1). bl \<in># (\<B> - {#b1#})#})"
     by (metis Int_commute) 
   finally have "(\<Sum>b2 \<in>#(\<B> - {#b1#}). b1 |\<inter>| b2) = \<k> * (\<r> - 1)" 
     using sym_sum_mset_inter_sets_size assms by auto
   then show ?thesis by simp
 qed
 
-lemma choose_two_int: 
-  assumes " x \<ge> 0" 
-  shows "nat (x :: int) choose 2 = ((x ::int) * ( x - 1)) div 2 " 
-  using choose_two assms dvd_div_mult_self even_numeral int_nat_eq mult_cancel_right2 mult_eq_0_iff 
-    mult_nonneg_nonneg nat_diff_distrib' nat_mult_distrib nat_one_as_int 
-    numeral_Bit0_div_2 numerals(1) of_nat_numeral zdiv_int by (smt (verit)) (* Slow *)
-
 lemma sym_sum_mset_inter2_sets_count: 
   assumes "blv \<in># \<B>"
   assumes "p \<subseteq> blv"
   assumes "card p = 2"
   shows "count (\<Sum>\<^sub>#{#mset_set {y .y \<subseteq> blv \<inter> b2 \<and> card y = 2}. b2 \<in># (\<B> - {#blv#})#}) p = \<Lambda> - 1" 
     (is "count (\<Sum>\<^sub>#?M) p = \<Lambda> - 1")
 proof -
   have size_inter: "size {# mset_set {y .y \<subseteq> blv \<inter> b2 \<and> card y = 2} | b2 \<in># (\<B> - {#blv#}) . p \<subseteq> b2#} 
       = \<Lambda> - 1"
     using bibd_subset_occ assms by simp
   have "\<forall> b2 \<in># (\<B> - {#blv#}) . p \<subseteq> b2 \<longrightarrow> count (mset_set{y .y \<subseteq> blv \<inter> b2 \<and> card y = 2}) p = 1"
     using assms(2) count_mset_set(1) assms(3) by (auto simp add: assms(1) finite_blocks)
   then have "\<forall> bl \<in># {#b1 \<in>#(\<B> - {#blv#}) . p \<subseteq> b1#}. 
       count (mset_set {y .y \<subseteq> blv \<inter> bl \<and> card y = 2}) p = 1"
     using count_eq_zero_iff count_filter_mset by (metis (no_types, lifting)) 
   then have pin: "\<forall> P \<in># {# mset_set {y .y \<subseteq> blv \<inter> b2 \<and> card y = 2} | b2 \<in># (\<B> - {#blv#}) . p \<subseteq> b2#}. 
       count P p = 1"
     using count_eq_zero_iff count_filter_mset by blast
   have "?M = {# mset_set {y .y \<subseteq> blv \<inter> b2 \<and> card y = 2} | b2 \<in># (\<B> - {#blv#}) . p \<subseteq> b2#} + 
               {# mset_set {y .y \<subseteq> blv \<inter> b2 \<and> card y = 2} | b2 \<in># (\<B> - {#blv#}) . \<not> (p \<subseteq> b2)#}" 
     by (metis image_mset_union multiset_partition) 
   then have "count (\<Sum>\<^sub>#?M) p = 
       size {# mset_set {y .y \<subseteq> blv \<inter> b2 \<and> card y = 2} | b2 \<in># (\<B> - {#blv#}) . p \<subseteq> b2#}" 
     using pin by (auto simp add: count_sum_mset)
   then show ?thesis using size_inter by linarith  
 qed
 
 lemma sym_sum_mset_inter2_sets_size: 
   assumes "blv \<in># \<B>"
   shows "size (\<Sum>\<^sub>#{#mset_set {y .y \<subseteq> blv \<inter> b2 \<and> card y = 2}. b2 \<in># (\<B> - {#blv#})#}) = 
-    ((nat \<k>) choose 2) * (\<Lambda> -1)" 
-    (is "size (\<Sum>\<^sub>#?M) = ((nat \<k>) choose 2) * (\<Lambda> -1)")
+    ( \<k> choose 2) * (\<Lambda> -1)" 
+    (is "size (\<Sum>\<^sub>#?M) = (\<k> choose 2) * (\<Lambda> -1)")
 proof (cases "\<Lambda> = 1")
   case True
   have empty: "\<And> b2 . b2 \<in># remove1_mset blv \<B> \<Longrightarrow> {y .y \<subseteq> blv \<and> y \<subseteq> b2 \<and> card y = 2} = {}" 
     using index_one_alt_bl_not_exist assms True by blast
   then show ?thesis using sum_mset.neutral True by (simp add: empty)
 next
   case False
   then have index_min: "\<Lambda> \<ge> 2" using index_not_zero by linarith 
   have subset_card: "\<And> x . x \<in># (\<Sum>\<^sub>#?M) \<Longrightarrow> card x = 2"
   proof -
     fix x
     assume a: "x \<in># (\<Sum>\<^sub>#?M)"
     then obtain b2 where "x \<in># mset_set {y . y \<subseteq> blv \<inter> b2 \<and> card y = 2} \<and> b2 \<in>#(\<B> - {#blv#})" 
       by blast
     thus "card x = 2" using mem_Collect_eq
       by (metis (mono_tags, lifting) elem_mset_set equals0D infinite_set_mset_mset_set)
   qed
   have eq: "set_mset (\<Sum>\<^sub>#?M) = {bl . bl \<subseteq> blv \<and> card bl = 2}" 
   proof
     show "set_mset (\<Sum>\<^sub>#?M) \<subseteq> {bl . bl \<subseteq> blv \<and> card bl = 2}"
       using subset_card intersect_mult_set_block_subset_iff assms by blast
     show "{bl . bl \<subseteq> blv \<and> card bl = 2} \<subseteq> set_mset (\<Sum>\<^sub>#?M)"
       using intersect_mult_set_block_subset_iff_2 assms index_min by blast
   qed
-  have "card blv = (nat \<k>)" using uniform assms by (metis nat_int) 
-  then have k: "card (set_mset (\<Sum>\<^sub>#?M)) = ((nat \<k>) choose 2)" using eq n_subsets
+  have "card blv =  \<k>" using uniform assms by simp
+  then have k: "card (set_mset (\<Sum>\<^sub>#?M)) = (\<k> choose 2)" using eq n_subsets
     by (simp add: n_subsets assms finite_blocks) 
-  thus ?thesis using k size_multiset_int_count sym_sum_mset_inter2_sets_count assms eq subset_card
-    by (metis (no_types, lifting) intersect_mult_set_block_subset_iff)
+  thus ?thesis using k size_multiset_set_mset_const_count sym_sum_mset_inter2_sets_count assms eq 
+    by (metis (no_types, lifting) intersect_mult_set_block_subset_iff subset_card)
 qed
 
 lemma sum_choose_two_inter_num: 
   assumes "b1 \<in># \<B>" 
-  shows "(\<Sum>b2 \<in># (\<B> - {#b1#}). (nat (b1 |\<inter>| b2) choose 2)) = ((\<Lambda> * (\<Lambda> - 1) div 2)) * (\<v> -1)"
+  shows "(\<Sum>b2 \<in># (\<B> - {#b1#}). ((b1 |\<inter>| b2) choose 2)) = ((\<Lambda> * (\<Lambda> - 1) div 2)) * (\<v> -1)"
 proof - 
-  have div_fact: "2 dvd (\<Lambda> * (\<Lambda> - 1))"by simp
-  have div_fact_2: "2 dvd (\<Lambda> * (\<v> - 1))" using symmetric_condition_2 by simp
-  have "(\<Sum>b2 \<in># (\<B> - {#b1#}). (nat (b1 |\<inter>| b2) choose 2)) = (\<Sum>b2 \<in># (\<B> - {#b1#}). nat (b1 |\<inter>|\<^sub>2 b2 ))" 
+  have div_fact: "2 dvd (\<Lambda> * (\<Lambda> - 1))"
+    by fastforce 
+  have div_fact_2: "2 dvd (\<Lambda> * (\<v> - 1))" using symmetric_condition_2 by fastforce
+  have "(\<Sum>b2 \<in># (\<B> - {#b1#}). ((b1 |\<inter>| b2) choose 2)) = (\<Sum>b2 \<in># (\<B> - {#b1#}). (b1 |\<inter>|\<^sub>2 b2 ))" 
     using n_inter_num_choose_design_inter assms by (simp add: in_diffD)
-  then have sum_fact: "(\<Sum>b2 \<in># (\<B> - {#b1#}).(nat (b1 |\<inter>| b2) choose 2)) 
-      = ((nat \<k>) choose 2) * (\<Lambda> -1)" 
+  then have sum_fact: "(\<Sum>b2 \<in># (\<B> - {#b1#}).((b1 |\<inter>| b2) choose 2)) 
+      = (\<k> choose 2) * (\<Lambda> -1)" 
     using assms sym_sum_mset_inter2_sets_size 
     by (auto simp add: size_big_union_sum n_intersect_num_subset_def)
-  have "((nat \<k>) choose 2) * (\<Lambda> -1) = ((\<Lambda> * (\<v> - 1) div 2)) * (\<Lambda> -1)" 
-    using choose_two_int symmetric_condition_2 k_non_zero by auto 
-  then have "((nat \<k>) choose 2) * (\<Lambda> -1) = ((\<Lambda> * (\<Lambda> - 1) div 2)) * (\<v> -1)" 
+  have "(\<k> choose 2) * (\<Lambda> -1) = ((\<Lambda> * (\<v> - 1) div 2)) * (\<Lambda> -1)" 
+    using choose_two symmetric_condition_2 k_non_zero by auto 
+  then have "(\<k> choose 2) * (\<Lambda> -1) = ((\<Lambda> * (\<Lambda> - 1) div 2)) * (\<v> -1)" 
     using div_fact div_fact_2 by (smt div_mult_swap mult.assoc mult.commute) 
   then show ?thesis using sum_fact by simp
 qed
 
 lemma sym_sum_inter_num_sq: 
   assumes "b1 \<in># \<B>" 
   shows "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2) = \<Lambda>^2 * ( \<v> - 1)"
 proof - 
-  have dvd: "2 dvd (( \<v> - 1) * (\<Lambda> * (\<Lambda> - 1)))" by simp
-  have a: "(\<Sum>b2 \<in>#(\<B> - {#b1#}). int (nat (b1 |\<inter>| b2) choose 2)) = 
+  have dvd: "2 dvd (( \<v> - 1) * (\<Lambda> * (\<Lambda> - 1)))" by fastforce
+  have inner_dvd: "\<forall> bl \<in># (remove1_mset b1 \<B>). 2 dvd ((b1 |\<inter>| bl) *  ((b1 |\<inter>| bl) - 1))"
+    by force
+  have diff_le: "\<And> bl . bl \<in># (remove1_mset b1 \<B>) \<Longrightarrow> (b1 |\<inter>| bl) \<le> (b1 |\<inter>| bl)^2"
+    by (simp add: power2_nat_le_imp_le)
+  have a: "(\<Sum>b2 \<in>#(\<B> - {#b1#}). ((b1 |\<inter>| b2) choose 2)) = 
             (\<Sum>bl \<in># (remove1_mset b1 \<B>).  ((b1 |\<inter>| bl) *  ((b1 |\<inter>| bl) - 1)) div 2)" 
-    using choose_two_int by (simp add: intersection_num_non_neg)
-  have b: "(\<Sum>b2 \<in>#(\<B> - {#b1#}). int (nat (b1 |\<inter>| b2) choose 2)) = 
-              (\<Sum>b2 \<in>#(\<B> - {#b1#}). (nat (b1 |\<inter>| b2) choose 2))" by simp
-  have "(\<Sum>b2 \<in>#(\<B> - {#b1#}). (nat (b1 |\<inter>| b2) choose 2)) = ((\<Lambda> * (\<Lambda> - 1)) div 2) * ( \<v> - 1)" 
+    using choose_two by (simp add: intersection_num_non_neg)
+  have b: "(\<Sum>b2 \<in>#(\<B> - {#b1#}). ((b1 |\<inter>| b2) choose 2)) = 
+              (\<Sum>b2 \<in>#(\<B> - {#b1#}). ((b1 |\<inter>| b2) choose 2))" by simp
+  have gtsq: "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2) \<ge> (\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl))"
+    by (simp add: diff_le sum_mset_mono) 
+  have "(\<Sum>b2 \<in>#(\<B> - {#b1#}). ((b1 |\<inter>| b2) choose 2)) = ((\<Lambda> * (\<Lambda> - 1)) div 2) * ( \<v> - 1)" 
     using sum_choose_two_inter_num assms by blast 
   then have start: "(\<Sum>bl \<in># (remove1_mset b1 \<B>). ((b1 |\<inter>| bl) *  ((b1 |\<inter>| bl) - 1)) div 2) 
                         = ((\<Lambda> * (\<Lambda> - 1)) div 2) * (\<v> - 1)"
     using a b by linarith
   have sum_dvd: "2 dvd (\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl) *  ((b1 |\<inter>| bl) - 1))"
-    by (simp add: sum_mset_dvd) 
+    using sum_mset_dvd
+    by (metis (no_types, lifting) dvd_mult dvd_mult2 dvd_refl odd_two_times_div_two_nat) 
   then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl) * ((b1 |\<inter>| bl) - 1)) div 2 
-      = (\<v> - 1) * ((\<Lambda> * (\<Lambda> - 1)) div 2)" 
-    using start by (simp add: sum_mset_distrib_div_if_dvd)
+      =  ((\<Lambda> * (\<Lambda> - 1)) div 2) * (\<v> - 1)" 
+    using start sum_mset_distrib_div_if_dvd inner_dvd
+    by (metis (mono_tags, lifting) image_mset_cong2)
+  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl) * ((b1 |\<inter>| bl) - 1)) div 2 
+      =  (\<v> - 1) * ((\<Lambda> * (\<Lambda> - 1)) div 2)"
+    by simp 
+  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl) * ((b1 |\<inter>| bl) - 1))  
+      =  (\<v> - 1) * (\<Lambda> * (\<Lambda> - 1))"
+    by (metis (no_types, lifting) div_mult_swap dvdI dvd_div_eq_iff dvd_mult dvd_mult2 odd_two_times_div_two_nat sum_dvd) 
+  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2 - (b1 |\<inter>| bl))  
+      =  (\<v> - 1) * (\<Lambda> * (\<Lambda> - 1))"
+    using diff_mult_distrib2
+    by (metis (no_types, lifting) multiset.map_cong0 nat_mult_1_right power2_eq_square)  
   then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2) 
-      - (\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)) = ((\<v> - 1) * (\<Lambda> * (\<Lambda> - 1)))"
-    using sum_dvd dvd 
-    by (simp add: dvd_div_eq_iff  div_mult_swap int_distrib(4) power2_eq_square sum_mset_add_diff)
-  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2) - (\<Lambda> * (\<v> - 1)) = ((\<v> - 1) * (\<Lambda> * (\<Lambda> - 1)))" 
+      - (\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)) = (\<v> - 1) * (\<Lambda> * (\<Lambda> - 1))"
+    using sum_mset_add_diff_nat[of "(remove1_mset b1 \<B>)" "\<lambda> bl . (b1 |\<inter>| bl)" "\<lambda> bl . (b1 |\<inter>| bl)^2"]  
+      diff_le by presburger  
+  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2) 
+      = (\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)) + (\<v> - 1) * (\<Lambda> * (\<Lambda> - 1))" using gtsq
+    by (metis le_add_diff_inverse) 
+  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2) =  (\<Lambda> * (\<v> - 1)) + ((\<v> - 1) * (\<Lambda> * (\<Lambda> - 1)))" 
     using sym_sum_inter_num assms rep_value_sym symmetric_condition_2 by auto 
-  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2) = (\<Lambda> * (\<v> - 1)) * (\<Lambda> - 1) + (\<Lambda> * (\<v> - 1))"
-    using diff_eq_eq by fastforce 
-  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2) = (\<Lambda> * (\<v> - 1)) * (\<Lambda> - 1 + 1)" 
-    using int_distrib(2) by (metis mult_numeral_1_right numeral_One)
+  then have prev: "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2) = (\<Lambda> * (\<v> - 1)) * (\<Lambda> - 1) + (\<Lambda> * (\<v> - 1))"
+    by fastforce 
+  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2) = (\<Lambda> * (\<v> - 1)) * (\<Lambda>)"
+    by (metis Nat.le_imp_diff_is_add add_mult_distrib2 index_not_zero nat_mult_1_right) 
+  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (b1 |\<inter>| bl)^2) = \<Lambda> * \<Lambda> * (\<v> - 1)"
+    using mult.commute by simp 
   thus ?thesis by (simp add: power2_eq_square)
 qed
 
 lemma sym_sum_inter_num_to_zero: 
   assumes "b1 \<in># \<B>" 
-  shows "(\<Sum>bl \<in># (remove1_mset b1 \<B>). ((b1 |\<inter>| bl) - \<Lambda>)^2) = 0"
+  shows "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (int (b1 |\<inter>| bl) - (int \<Lambda>))^2) = 0"
 proof -
   have rm1_size: "size (remove1_mset b1 \<B>) = \<v> - 1" using assms b_non_zero int_ops(6) 
     by (auto simp add: symmetric size_remove1_mset_If)
-  have "\<And> bl . bl \<in># (remove1_mset b1 \<B>) \<Longrightarrow> ((b1 |\<inter>| bl) - \<Lambda>)^2 = 
-        (((b1 |\<inter>| bl)^2) - (2 * \<Lambda> * (b1 |\<inter>| bl)) + (\<Lambda>^2))"
+  have  "(\<Sum>bl \<in># (remove1_mset b1 \<B>). ((int (b1 |\<inter>| bl))^2)) = 
+    (\<Sum>bl \<in># (remove1_mset b1 \<B>). (((b1 |\<inter>| bl))^2))" by simp
+  then have ssi: "(\<Sum>bl \<in># (remove1_mset b1 \<B>). ((int (b1 |\<inter>| bl))^2)) = \<Lambda>^2 * (\<v> - 1)" 
+    using sym_sum_inter_num_sq assms by simp 
+  have "\<And> bl . bl \<in># (remove1_mset b1 \<B>) \<Longrightarrow> (int (b1 |\<inter>| bl) - (int \<Lambda>))^2 = 
+        (((int (b1 |\<inter>| bl))^2) - (2 * (int \<Lambda>) * (int (b1 |\<inter>| bl))) + ((int \<Lambda>)^2))"
     by (simp add: power2_diff)
-  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). ((b1 |\<inter>| bl) - \<Lambda>)^2) = 
-              (\<Sum>bl \<in># (remove1_mset b1 \<B>). (((b1 |\<inter>| bl)^2) - (2 * \<Lambda> * (b1 |\<inter>| bl)) + (\<Lambda>^2)))"
+  then have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (int (b1 |\<inter>| bl) - (int \<Lambda>))^2) = 
+              (\<Sum>bl \<in># (remove1_mset b1 \<B>). (((int (b1 |\<inter>| bl))^2) - (2 * (int \<Lambda>) * (int (b1 |\<inter>| bl))) + ((int \<Lambda>)^2)))"
     using sum_over_fun_eq by auto
-  also have "... = \<Lambda>^2 * (\<v> - 1) - 2 * \<Lambda> * (\<Sum>bl \<in># (remove1_mset b1 \<B>). ((b1 |\<inter>| bl))) 
-      + (\<v> - 1) * (\<Lambda>^2)"
-    using sym_sum_inter_num_sq rm1_size 
-    by (simp add: assms sum_mset.distrib  sum_mset_add_diff sum_mset_distrib_left) 
-  finally have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). ((b1 |\<inter>| bl) - \<Lambda>)^2) = 0"
-    using rep_value_sym symmetric_condition_2 sym_sum_inter_num assms 
+  also have "... = (\<Sum>bl \<in># (remove1_mset b1 \<B>). (((int (b1 |\<inter>| bl))^2) 
+      -  (2 * (int \<Lambda>) * (int (b1 |\<inter>| bl))))) + (\<Sum> bl \<in># (remove1_mset b1 \<B>) . ((int \<Lambda>)^2))" 
+    by (simp add: sum_mset.distrib) 
+  also have "... = (\<Sum>bl \<in># (remove1_mset b1 \<B>). ((int (b1 |\<inter>| bl))^2)) 
+      - (\<Sum>bl \<in># (remove1_mset b1 \<B>). (2 * (int \<Lambda>) * (int (b1 |\<inter>| bl)))) + (\<Sum> bl \<in># (remove1_mset b1 \<B>) . ((int \<Lambda>)^2))" 
+    using sum_mset_add_diff_int[of "(\<lambda> bl . ((int (b1 |\<inter>| bl))^2))" "(\<lambda> bl . (2 * (int \<Lambda>) * (int (b1 |\<inter>| bl))))" "(remove1_mset b1 \<B>)"] 
+    by simp
+  also have "... =  \<Lambda>^2 * (\<v> - 1) - 2 * (int \<Lambda>) *(\<Sum>bl \<in># (remove1_mset b1 \<B>). ((b1 |\<inter>| bl))) 
+      + (\<v> - 1) * ((int \<Lambda>)^2)" using ssi rm1_size assms by (simp add: sum_mset_distrib_left)
+  also have "... =  2 * \<Lambda>^2 * (\<v> - 1) - 2 * (int \<Lambda>) *(\<k>* (\<r> - 1))" 
+    using  sym_sum_inter_num assms by simp
+  also have "... = 2 * \<Lambda>^2 * (\<v> - 1) - 2 * (int \<Lambda>) * (\<Lambda> * (\<v> - 1))" 
+    using rep_value_sym symmetric_condition_2 by simp
+  finally have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (int (b1 |\<inter>| bl) - int \<Lambda>)^2) = 0" 
     by (auto simp add: power2_eq_square)
   thus ?thesis by simp
 qed
 
 theorem sym_block_intersections_index [simp]: 
   assumes "b1 \<in># \<B>"
   assumes "b2 \<in># (\<B> - {#b1#})"
   shows "b1 |\<inter>| b2 = \<Lambda>"
 proof - 
-  have pos: "\<And> bl . ((b1 |\<inter>| bl) - \<Lambda>)^2 \<ge> 0" by simp
-  have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). ((b1 |\<inter>| bl) - \<Lambda>)^2) = 0" 
-    using sym_sum_inter_num_to_zero assms by simp
-  then have "\<And> bl.  bl \<in> set_mset (remove1_mset b1 \<B>) \<Longrightarrow> ((b1 |\<inter>| bl) - \<Lambda>)^2 = 0" 
+  define l where l_def: "l = int \<Lambda>" 
+  then have pos: "\<And> bl . (int (b1 |\<inter>| bl) - l)^2 \<ge> 0" by simp
+  have "(\<Sum>bl \<in># (remove1_mset b1 \<B>). (int (b1 |\<inter>| bl) - l)^2) = 0" 
+    using sym_sum_inter_num_to_zero assms l_def by simp
+  then have "\<And> bl.  bl \<in> set_mset (remove1_mset b1 \<B>) \<Longrightarrow> (int (b1 |\<inter>| bl) - l)^2 = 0" 
     using sum_mset_0_iff_ge_0 pos by (metis (no_types, lifting)) 
-  thus ?thesis
-    using assms(2) by auto 
+  then have "\<And> bl.  bl \<in> set_mset (remove1_mset b1 \<B>) \<Longrightarrow> int (b1 |\<inter>| bl) = l"
+    by auto 
+  thus ?thesis using assms(2) l_def of_nat_eq_iff by blast 
 qed
 
 subsubsection \<open>Symmetric BIBD is Simple\<close>
 
 lemma sym_block_mult_one [simp]:
   assumes "bl \<in># \<B>"
   shows "multiplicity bl = 1"
 proof (rule ccontr)
   assume "\<not> (multiplicity bl = 1)"
   then have not: "multiplicity bl \<noteq> 1" by simp
   have "multiplicity bl \<noteq> 0" using assms
     by simp 
   then have m: "multiplicity bl \<ge> 2" using not by linarith
   then have blleft: "bl \<in># (\<B> - {#bl#})"
     using in_diff_count by fastforce
   have "bl |\<inter>| bl = \<k>" using k_non_zero assms
     by (simp add: intersection_number_def) 
   then have keql: "\<k> = \<Lambda>" using sym_block_intersections_index blleft assms by simp
   then have "\<v> = \<k>"
     using keql index_lt_replication rep_value_sym block_size_lt_v diffs0_imp_equal k_non_zero zero_diff by linarith 
   then show False using incomplete
     by simp
 qed
 
 end 
 
 sublocale symmetric_bibd \<subseteq> simple_design
   by unfold_locales simp
 
 subsubsection \<open>Residual/Derived Sym BIBD Constructions\<close>
 text \<open>Using the intersect result, we can reason further on residual and derived designs. 
 Proofs based off lecture notes \cite{HerkeLectureNotes2016}\<close>
 
 locale symmetric_bibd_block_transformations = symmetric_bibd + bibd_block_transformations
 begin 
 
 lemma derived_block_size [simp]: 
   assumes "b \<in># \<B>\<^sup>D"
   shows "card b = \<Lambda>"
 proof -
   obtain bl2 where set: "bl2 \<in># remove1_mset bl \<B>" and inter: "b = bl2 \<inter> bl" 
     using derived_blocks_def assms by (meson derived_obtain_orig_block) 
   then have "card b = bl2 |\<inter>| bl"
     by (simp add: intersection_number_def) 
   thus ?thesis using sym_block_intersections_index
     using set intersect_num_commute valid_block by fastforce
 qed
 
 lemma derived_points_index [simp]: 
   assumes "ps \<subseteq> bl"
   assumes "card ps = 2"
   shows "\<B>\<^sup>D index  ps = \<Lambda> - 1"
 proof -
   have b_in: "\<And> b . b \<in># (remove1_mset bl \<B>) \<Longrightarrow> ps \<subseteq> b \<Longrightarrow> ps \<subseteq> b \<inter> bl"
     using assms by blast 
   then have orig: "ps \<subseteq> \<V>"
     using valid_block assms wellformed by blast
   then have lam: "size {# b \<in># \<B> . ps \<subseteq> b #} = \<Lambda>" using balanced
     by (simp add: assms(2)  points_index_def) 
   then have "size {# b \<in># remove1_mset bl \<B> . ps \<subseteq> b #} = size {# b \<in># \<B> . ps \<subseteq> b #} - 1"
     using assms valid_block by (simp add: size_Diff_submset)
   then have "size {# b \<in># remove1_mset bl \<B> . ps \<subseteq> b #} = \<Lambda> - 1" 
     using lam index_not_zero by linarith 
   then have "size  {# bl \<inter> b |  b \<in># (remove1_mset bl \<B>) . ps \<subseteq> bl \<inter> b #} = \<Lambda> - 1" 
     using b_in by (metis (no_types, lifting) Int_subset_iff filter_mset_cong size_image_mset)
   then have "size {# x \<in># {# bl \<inter> b . b \<in># (remove1_mset bl \<B>) #} . ps \<subseteq> x #} = \<Lambda> - 1"
     by (metis image_mset_filter_swap) 
   then have "size {# x \<in># \<B>\<^sup>D . ps \<subseteq> x #} = \<Lambda> - 1" by (simp add: derived_blocks_def)
   thus ?thesis by (simp add: points_index_def)
 qed
 
 lemma sym_derive_design_bibd: 
   assumes "\<Lambda> > 1"
   shows "bibd bl \<B>\<^sup>D \<Lambda> (\<Lambda> - 1)"
 proof -
   interpret des: proper_design bl "\<B>\<^sup>D" using derived_is_proper assms valid_block by auto 
   have "\<Lambda> < \<k>" using index_lt_replication rep_value_sym by linarith 
   then show ?thesis using derived_block_size assms derived_points_index derived_points_order
     by (unfold_locales) (simp_all)
 qed
 
 lemma residual_block_size [simp]: 
   assumes "b \<in># \<B>\<^sup>R"
   shows "card b = \<k> - \<Lambda>"
 proof -
   obtain bl2 where sub: "b = bl2 - bl" and mem: "bl2 \<in># remove1_mset bl \<B>" 
     using assms residual_blocks_def by auto 
   then have "card b = card bl2 - card (bl2 \<inter> bl)"
     using card_Diff_subset_Int valid_block finite_blocks
     by (simp add: card_Diff_subset_Int)  
   then have "card b = card bl2 - bl2 |\<inter>| bl" 
-    using intersection_number_def finite_blocks card_inter_lt_single
-    by (metis assms derived_fin_incidence_system.finite_sets finite_Diff2 of_nat_diff 
-        residual_fin_incidence_sys.finite_blocks sub)
+    using finite_blocks card_inter_lt_single by (simp add: intersection_number_def)
   thus ?thesis using sym_block_intersections_index uniform
     by (metis valid_block in_diffD intersect_num_commute mem)
 qed
 
 lemma residual_index [simp]: 
   assumes "ps \<subseteq> bl\<^sup>c"
   assumes "card ps = 2"
   shows  "(\<B>\<^sup>R) index ps = \<Lambda>"
 proof - 
   have a: "\<And> b . (b \<in># remove1_mset bl \<B> \<Longrightarrow> ps \<subseteq> b \<Longrightarrow>  ps \<subseteq> (b - bl))" using assms
     by (smt DiffI block_comp_elem_alt_left in_diffD subset_eq wellformed) 
   have b: "\<And> b . (b \<in># remove1_mset bl \<B> \<Longrightarrow>  ps \<subseteq> (b - bl) \<Longrightarrow>  ps \<subseteq> b)"
     by auto 
   have not_ss: "\<not> (ps \<subseteq> bl)" using set_diff_non_empty_not_subset blocks_nempty t_non_zero assms 
     block_complement_def by fastforce 
   have "\<B>\<^sup>R index ps = size {# x \<in># {# b - bl . b \<in># (remove1_mset bl \<B>) #} . ps \<subseteq> x #}" 
     using assms valid_block by (simp add: points_index_def residual_blocks_def)
   also have "... = size  {# b - bl |  b \<in># (remove1_mset bl \<B>) . ps \<subseteq> b - bl #} "
     by (metis image_mset_filter_swap)
   finally have "\<B>\<^sup>R index ps = size  {#  b \<in># (remove1_mset bl \<B>) . ps \<subseteq> b #} " using a b
     by (metis (no_types, lifting) filter_mset_cong size_image_mset)
   thus ?thesis 
     using balanced not_ss assms points_index_alt_def block_complement_subset_points by auto 
 qed
 
 lemma sym_residual_design_bibd: 
   assumes "\<k> \<ge> \<Lambda> + 2"
   shows "bibd (bl\<^sup>c) \<B>\<^sup>R (\<k> - \<Lambda>) \<Lambda>"
 proof -
   interpret des: proper_design "bl\<^sup>c" "\<B>\<^sup>R" 
     using residual_is_proper assms(1) valid_block sym_block_mult_one by fastforce
   show ?thesis using residual_block_size assms sym_design_vk_gt_kl residual_order residual_index 
     by(unfold_locales) simp_all
 qed
 
 end
 
 subsection \<open>BIBD's and Other Block Designs\<close>
 text \<open>BIBD's are closely related to other block designs by indirect inheritance\<close>
 
 sublocale bibd \<subseteq> k_\<Lambda>_PBD \<V> \<B> \<Lambda> \<k>
   using block_size_gt_t by (unfold_locales) simp_all
 
 lemma incomplete_PBD_is_bibd: 
   assumes "k < card V" and "k_\<Lambda>_PBD V B \<Lambda> k" 
   shows "bibd V B k \<Lambda>"
 proof -
   interpret inc: incomplete_design V B k using assms 
     by (auto simp add: block_design.incomplete_designI k_\<Lambda>_PBD.axioms(2))
   interpret pairwise_balance: pairwise_balance V B \<Lambda> using assms
     by (auto simp add: k_\<Lambda>_PBD.axioms(1))
   show ?thesis using assms k_\<Lambda>_PBD.block_size_t by (unfold_locales) (simp_all)
 qed
 
 lemma (in bibd) bibd_to_pbdI[intro]: 
   assumes "\<Lambda> = 1" 
   shows "k_PBD \<V> \<B> \<k>"
 proof -
   interpret pbd: k_\<Lambda>_PBD \<V> \<B> \<Lambda> \<k>
     by (simp add: k_\<Lambda>_PBD_axioms)
   show ?thesis using assms by (unfold_locales) (simp_all add: t_lt_order min_block_size_2)
 qed
 
 locale incomplete_PBD = incomplete_design + k_\<Lambda>_PBD
 
 sublocale incomplete_PBD \<subseteq> bibd
   using block_size_t by (unfold_locales) simp
 
 end
\ No newline at end of file
diff --git a/thys/Design_Theory/Block_Designs.thy b/thys/Design_Theory/Block_Designs.thy
--- a/thys/Design_Theory/Block_Designs.thy
+++ b/thys/Design_Theory/Block_Designs.thy
@@ -1,558 +1,551 @@
 (* Title: Block_Designs.thy
    Author: Chelsea Edmonds
 *)
 
 section \<open>Block and Balanced Designs\<close>
 text \<open>We define a selection of the many different types of block and balanced designs, building up 
 to properties required for defining a BIBD, in addition to several base generalisations\<close> 
 
 theory Block_Designs imports Design_Operations
 begin
 
 subsection \<open>Block Designs\<close>
 text \<open>A block design is a design where all blocks have the same size.\<close>
 
 subsubsection \<open>K Block Designs\<close> 
 text \<open>An important generalisation of a typical block design is the $\mathcal{K}$ block design, 
 where all blocks must have a size $x$ where $x \in \mathcal{K}$\<close>
 locale K_block_design = proper_design +
-  fixes sizes :: "int set" ("\<K>")
-  assumes block_sizes: "bl \<in># \<B> \<Longrightarrow> (int (card bl)) \<in> \<K>"
+  fixes sizes :: "nat set" ("\<K>")
+  assumes block_sizes: "bl \<in># \<B> \<Longrightarrow> card bl \<in> \<K>"
   assumes positive_ints: "x \<in> \<K> \<Longrightarrow> x > 0"
 begin
 
 lemma sys_block_size_subset: "sys_block_sizes \<subseteq> \<K>"
   using block_sizes sys_block_sizes_obtain_bl by blast
 
 end
 
 subsubsection\<open>Uniform Block Design\<close>
 text \<open>The typical uniform block design is defined below\<close>
 locale block_design = proper_design + 
-  fixes u_block_size :: int ("\<k>")
+  fixes u_block_size :: nat ("\<k>")
   assumes uniform [simp]: "bl \<in># \<B> \<Longrightarrow> card bl = \<k>"
 begin
 
 lemma k_non_zero: "\<k> \<ge> 1"
 proof -
   obtain bl where bl_in: "bl \<in># \<B>"
     using design_blocks_nempty by auto 
-  then have "int (card bl) \<ge> 1" using block_size_gt_0
-    by (metis less_not_refl less_one not_le_imp_less of_nat_1 of_nat_less_iff) 
+  then have "card bl \<ge> 1" using block_size_gt_0
+    by (metis less_not_refl less_one not_le_imp_less) 
   thus ?thesis by (simp add: bl_in)
 qed
 
 lemma uniform_alt_def_all: "\<forall> bl \<in># \<B> .card bl = \<k>"
   using uniform by auto 
 
 lemma uniform_unfold_point_set: "bl \<in># \<B> \<Longrightarrow> card {p \<in> \<V>. p \<in> bl} = \<k>"
   using uniform wellformed by (simp add: Collect_conj_eq inf.absorb_iff2) 
 
 lemma uniform_unfold_point_set_mset: "bl \<in># \<B> \<Longrightarrow> size {#p \<in># mset_set \<V>. p \<in> bl #} = \<k>"
   using uniform_unfold_point_set by (simp add: finite_sets) 
 
 lemma sys_block_sizes_uniform [simp]:  "sys_block_sizes  = {\<k>}"
 proof -
   have "sys_block_sizes = {bs . \<exists> bl . bs = card bl \<and> bl\<in># \<B>}" by (simp add: sys_block_sizes_def)
   then have "sys_block_sizes  = {bs . bs = \<k>}" using uniform uniform_unfold_point_set 
       b_positive block_set_nempty_imp_block_ex
     by (smt (verit, best) Collect_cong design_blocks_nempty)
   thus ?thesis by auto
 qed
 
 lemma sys_block_sizes_uniform_single: "is_singleton (sys_block_sizes)"
   by simp
 
 lemma uniform_size_incomp: "\<k> \<le> \<v> - 1 \<Longrightarrow> bl \<in># \<B> \<Longrightarrow> incomplete_block bl"
-  using uniform k_non_zero of_nat_less_iff zle_diff1_eq by metis
+  using uniform k_non_zero 
+  by (metis block_size_lt_v diff_diff_cancel diff_is_0_eq' less_numeral_extra(1) nat_less_le)
 
 lemma uniform_complement_block_size:
   assumes "bl \<in># \<B>\<^sup>C"
   shows "card bl = \<v> - \<k>"
 proof -
   obtain bl' where bl_assm: "bl = bl'\<^sup>c \<and> bl' \<in># \<B>" 
     using wellformed assms by (auto simp add: complement_blocks_def)
   then have "int (card bl') = \<k>" by simp
   thus ?thesis using bl_assm block_complement_size wellformed
     by (simp add: block_size_lt_order of_nat_diff) 
 qed
 
 lemma uniform_complement[intro]: 
   assumes "\<k> \<le> \<v> - 1"
   shows "block_design \<V> \<B>\<^sup>C (\<v> - \<k>)"
 proof - 
   interpret des: proper_design \<V> "\<B>\<^sup>C" 
     using  uniform_size_incomp assms complement_proper_design by auto 
   show ?thesis using assms uniform_complement_block_size by (unfold_locales) (simp)
 qed
 
 lemma block_size_lt_v: "\<k> \<le> \<v>"
   using v_non_zero block_size_lt_v design_blocks_nempty uniform by auto 
 
 end
 
 lemma (in proper_design) block_designI[intro]: "(\<And> bl . bl \<in># \<B> \<Longrightarrow> card bl = k) 
   \<Longrightarrow> block_design \<V> \<B> k"
   by (unfold_locales) (auto)
 
 context block_design 
 begin
 
 lemma block_design_multiple: "n > 0 \<Longrightarrow> block_design \<V> (multiple_blocks n) \<k>"
   using elem_in_repeat_in_original multiple_proper_design proper_design.block_designI 
-  by (metis block_set_nempty_imp_block_ex design_blocks_nempty int_int_eq uniform_alt_def_all) 
+  by (metis uniform_alt_def_all)
 
 end
 text \<open>A uniform block design is clearly a type of $K$\_block\_design with a singleton $K$ set\<close>
 sublocale block_design \<subseteq> K_block_design \<V> \<B> "{\<k>}"
   using k_non_zero uniform by unfold_locales simp_all
 
 subsubsection \<open>Incomplete Designs\<close>
 text \<open>An incomplete design is a design where $k < v$, i.e. no block is equal to the point set\<close>
 locale incomplete_design = block_design + 
   assumes incomplete: "\<k> < \<v>"
 
 begin
 
 lemma incomplete_imp_incomp_block: "bl \<in># \<B> \<Longrightarrow> incomplete_block bl"
   using incomplete uniform uniform_size_incomp by fastforce  
 
 lemma incomplete_imp_proper_subset: "bl \<in># \<B> \<Longrightarrow> bl \<subset> \<V>"
-  by (simp add: incomplete_block_proper_subset incomplete_imp_incomp_block wellformed)
+  using incomplete_block_proper_subset incomplete_imp_incomp_block by auto
 end
 
 lemma (in block_design) incomplete_designI[intro]: "\<k> < \<v> \<Longrightarrow> incomplete_design \<V> \<B> \<k>"
   by unfold_locales auto
 
 context incomplete_design
 begin
 
 lemma multiple_incomplete: "n > 0 \<Longrightarrow> incomplete_design \<V> (multiple_blocks n) \<k>"
   using block_design_multiple incomplete by (simp add: block_design.incomplete_designI) 
 
 lemma complement_incomplete: "incomplete_design \<V> (\<B>\<^sup>C) (\<v> - \<k>)"
 proof -
   have "\<v> - \<k> < \<v>" using v_non_zero k_non_zero by linarith
   thus ?thesis using uniform_complement incomplete incomplete_designI
     by (simp add: block_design.incomplete_designI) 
 qed
 
 end
 
 subsection \<open>Balanced Designs\<close>
 text \<open>t-wise balance is a design with the property that all point subsets of size $t$ occur in 
 $\lambda_t$ blocks\<close>
 
 locale t_wise_balance = proper_design + 
-  fixes grouping :: int ("\<t>") and index :: int ("\<Lambda>\<^sub>t")
+  fixes grouping :: nat ("\<t>") and index :: nat ("\<Lambda>\<^sub>t")
   assumes t_non_zero: "\<t> \<ge> 1"
   assumes t_lt_order: "\<t> \<le> \<v>"
   assumes balanced [simp]: "ps \<subseteq> \<V> \<Longrightarrow> card ps = \<t> \<Longrightarrow> \<B> index ps = \<Lambda>\<^sub>t"
 begin
 
+lemma t_non_zero_suc: "\<t> \<ge> Suc 0"
+  using t_non_zero by auto
+
 lemma balanced_alt_def_all: "\<forall> ps \<subseteq> \<V> . card ps = \<t> \<longrightarrow> \<B> index ps = \<Lambda>\<^sub>t"
   using balanced by auto
 
 end
 
 lemma (in proper_design) t_wise_balanceI[intro]: "\<t> \<le> \<v> \<Longrightarrow> \<t> \<ge> 1 \<Longrightarrow> 
   (\<And> ps . ps \<subseteq> \<V> \<Longrightarrow> card ps = \<t>  \<Longrightarrow> \<B> index ps = \<Lambda>\<^sub>t) \<Longrightarrow> t_wise_balance \<V> \<B> \<t> \<Lambda>\<^sub>t"
   by (unfold_locales) auto
 
 context t_wise_balance
 begin
 
 lemma obtain_t_subset_points:
   obtains T where "T \<subseteq> \<V>" "card T = \<t>" "finite T"
-  using obtain_subset_with_card_int_n design_points_nempty t_lt_order t_non_zero finite_sets
-  by (metis int_one_le_iff_zero_less less_eq_int_code(1) linorder_not_le verit_la_generic)
+  using obtain_subset_with_card_n design_points_nempty t_lt_order t_non_zero finite_sets by auto
 
 lemma multiple_t_wise_balance_index [simp]:
   assumes "ps \<subseteq> \<V>"
   assumes "card ps = \<t>"
   shows "(multiple_blocks n) index ps = \<Lambda>\<^sub>t * n"
   using multiple_point_index balanced assms by fastforce 
 
 lemma multiple_t_wise_balance: 
   assumes "n > 0" 
   shows "t_wise_balance \<V> (multiple_blocks n) \<t> (\<Lambda>\<^sub>t * n)"
 proof - 
   interpret des: proper_design \<V> "(multiple_blocks n)" by (simp add: assms multiple_proper_design)  
   show ?thesis using t_non_zero t_lt_order multiple_t_wise_balance_index 
     by (unfold_locales) (simp_all)
 qed
 
 lemma twise_set_pair_index: "ps \<subseteq> \<V> \<Longrightarrow> ps2 \<subseteq> \<V> \<Longrightarrow> ps \<noteq> ps2 \<Longrightarrow> card ps = \<t> \<Longrightarrow> card ps2 = \<t> 
   \<Longrightarrow> \<B> index ps = \<B> index ps2"
-  using balanced by (metis of_nat_eq_iff) 
+  using balanced by simp 
 
 lemma t_wise_balance_alt: "ps \<subseteq> \<V> \<Longrightarrow> card ps = \<t> \<Longrightarrow> \<B> index ps = l2 
   \<Longrightarrow> (\<And> ps . ps \<subseteq> \<V> \<Longrightarrow> card ps = \<t> \<Longrightarrow> \<B> index ps = l2)"
   using twise_set_pair_index by blast
 
-lemma index_ge_zero: "\<Lambda>\<^sub>t \<ge> 0"
-proof -
-  obtain ps where "ps \<subseteq> \<V> \<and> card ps = \<t>" using t_non_zero t_lt_order obtain_subset_with_card_n
-    by (metis dual_order.trans of_nat_le_iff zero_le_imp_eq_int zero_le_one)
-  thus ?thesis
-    using balanced_alt_def_all of_nat_0_le_iff by blast
-qed
-
 lemma index_1_imp_mult_1 [simp]: 
   assumes "\<Lambda>\<^sub>t = 1"
   assumes "bl \<in># \<B>"
   assumes "card bl \<ge> \<t>"
   shows "multiplicity bl = 1"
 proof (rule ccontr)
   assume "\<not> (multiplicity bl = 1)"
   then have not: "multiplicity bl \<noteq> 1" by simp
   have "multiplicity bl \<noteq> 0" using assms by simp 
   then have m: "multiplicity bl \<ge> 2" using not by linarith
   obtain ps where ps: "ps \<subseteq> bl \<and> card ps = \<t>"
     using assms obtain_t_subset_points
-    by (metis obtain_subset_with_card_int_n of_nat_0_le_iff) 
+    by (metis obtain_subset_with_card_n) 
   then have "\<B> index ps \<ge> 2"
     using m points_index_count_min ps by blast
   then show False using balanced ps antisym_conv2 not_numeral_less_zero numeral_le_one_iff 
       points_index_ps_nin semiring_norm(69) zero_neq_numeral
-    by (metis assms(1) int_int_eq int_ops(2)) 
+    by (metis assms(1))
 qed
 
 end
 
 subsubsection \<open>Sub-types of t-wise balance\<close>
 
 text \<open>Pairwise balance is when $t = 2$. These are commonly of interest\<close>
 locale pairwise_balance = t_wise_balance \<V> \<B> 2 \<Lambda> 
   for point_set ("\<V>") and block_collection ("\<B>") and index ("\<Lambda>")
 
 text \<open>We can combine the balance properties with $K$\_block design to define tBD's 
 (t-wise balanced designs), and PBD's (pairwise balanced designs)\<close>
 
 locale tBD = t_wise_balance + K_block_design +
   assumes block_size_gt_t: "k \<in> \<K> \<Longrightarrow> k \<ge> \<t>"
 
 locale \<Lambda>_PBD = pairwise_balance + K_block_design + 
   assumes block_size_gt_t: "k \<in> \<K> \<Longrightarrow> k \<ge> 2"
 
 sublocale \<Lambda>_PBD \<subseteq> tBD \<V> \<B> 2 \<Lambda> \<K>
   using t_lt_order block_size_gt_t by (unfold_locales) (simp_all)
 
 locale PBD = \<Lambda>_PBD \<V> \<B> 1 \<K> for point_set ("\<V>") and block_collection ("\<B>") and sizes ("\<K>")
 begin
 lemma multiplicity_is_1:
   assumes "bl \<in># \<B>"
   shows "multiplicity bl = 1"
   using block_size_gt_t index_1_imp_mult_1 by (simp add: assms block_sizes) 
 
 end
 
 sublocale PBD \<subseteq> simple_design
   using multiplicity_is_1 by (unfold_locales)
 
 text \<open>PBD's are often only used in the case where $k$ is uniform, defined here.\<close>
 locale k_\<Lambda>_PBD = pairwise_balance + block_design + 
   assumes block_size_t: "2 \<le> \<k>"
 
 sublocale k_\<Lambda>_PBD \<subseteq> \<Lambda>_PBD \<V> \<B> \<Lambda> "{\<k>}"
   using k_non_zero uniform block_size_t by(unfold_locales) (simp_all)
 
 locale k_PBD = k_\<Lambda>_PBD \<V> \<B> 1 \<k> for point_set ("\<V>") and block_collection ("\<B>") and u_block_size ("\<k>")
 
 sublocale k_PBD \<subseteq> PBD \<V> \<B> "{\<k>}"
   using  block_size_t by (unfold_locales, simp_all)
 
 subsubsection \<open>Covering and Packing Designs\<close>
 text \<open>Covering and packing designs involve a looser balance restriction. Upper/lower bounds
 are placed on the points index, instead of a strict equality\<close>
 
 text \<open>A t-covering design is a relaxed version of a tBD, where, for all point subsets of size t, 
 a lower bound is put on the points index\<close>
 locale t_covering_design = block_design +
-  fixes grouping :: int ("\<t>")
-  fixes min_index :: int ("\<Lambda>\<^sub>t")
+  fixes grouping :: nat ("\<t>")
+  fixes min_index :: nat ("\<Lambda>\<^sub>t")
   assumes covering: "ps \<subseteq> \<V> \<Longrightarrow> card ps = \<t> \<Longrightarrow> \<B> index ps \<ge> \<Lambda>\<^sub>t" 
   assumes block_size_t: "\<t> \<le> \<k>"
   assumes t_non_zero: "\<t> \<ge> 1"
 begin
 
 lemma covering_alt_def_all: "\<forall> ps \<subseteq> \<V> . card ps = \<t> \<longrightarrow> \<B> index ps \<ge> \<Lambda>\<^sub>t"
   using covering by auto
 
 end
 
 lemma (in block_design) t_covering_designI [intro]: "t \<le> \<k> \<Longrightarrow> t \<ge> 1 \<Longrightarrow> 
   (\<And> ps. ps \<subseteq> \<V> \<Longrightarrow> card ps = t \<Longrightarrow> \<B> index ps \<ge> \<Lambda>\<^sub>t) \<Longrightarrow> t_covering_design \<V> \<B> \<k> t \<Lambda>\<^sub>t"
   by (unfold_locales) simp_all
 
 text \<open>A t-packing design is a relaxed version of a tBD, where, for all point subsets of size t, 
 an upper bound is put on the points index\<close>
 locale t_packing_design = block_design + 
-  fixes grouping :: int ("\<t>")
-  fixes min_index :: int ("\<Lambda>\<^sub>t")
+  fixes grouping :: nat ("\<t>")
+  fixes min_index :: nat ("\<Lambda>\<^sub>t")
   assumes packing: "ps \<subseteq> \<V> \<Longrightarrow> card ps = \<t> \<Longrightarrow> \<B> index ps \<le> \<Lambda>\<^sub>t"
   assumes block_size_t: "\<t> \<le> \<k>"
   assumes t_non_zero: "\<t> \<ge> 1"
 begin
 
 lemma packing_alt_def_all: "\<forall> ps \<subseteq> \<V> . card ps = \<t> \<longrightarrow> \<B> index ps \<le> \<Lambda>\<^sub>t"
   using packing by auto
 
 end
 
 lemma (in block_design) t_packing_designI [intro]: "t \<le> \<k> \<Longrightarrow> t \<ge> 1 \<Longrightarrow> 
   (\<And> ps . ps \<subseteq> \<V> \<Longrightarrow> card ps = t \<Longrightarrow> \<B> index ps \<le> \<Lambda>\<^sub>t) \<Longrightarrow> t_packing_design \<V> \<B> \<k> t \<Lambda>\<^sub>t"
   by (unfold_locales) simp_all
 
 lemma packing_covering_imp_balance: 
   assumes "t_packing_design V B k t \<Lambda>\<^sub>t" 
   assumes "t_covering_design V B k t \<Lambda>\<^sub>t" 
   shows "t_wise_balance V B t \<Lambda>\<^sub>t"
 proof -
   from assms interpret des: proper_design V B 
     using block_design.axioms(1) t_covering_design.axioms(1) by blast
   show ?thesis 
   proof (unfold_locales)
-    show "1 \<le> t" using assms by (simp add: t_packing_design.t_non_zero)
+    show "1 \<le> t" using assms t_packing_design.t_non_zero by auto
     show "t \<le> des.\<v>" using block_design.block_size_lt_v t_packing_design.axioms(1) 
       by (metis assms(1) dual_order.trans t_packing_design.block_size_t)
     show "\<And>ps. ps \<subseteq> V \<Longrightarrow> card ps = t \<Longrightarrow> B index ps = \<Lambda>\<^sub>t" 
       using t_packing_design.packing t_covering_design.covering by (metis assms dual_order.antisym) 
   qed
 qed
 
 subsection \<open>Constant Replication Design\<close>
 text \<open>When the replication number for all points in a design is constant, it is the 
 design replication number.\<close>
 locale constant_rep_design = proper_design +
-  fixes design_rep_number :: int ("\<r>")
+  fixes design_rep_number :: nat ("\<r>")
   assumes rep_number [simp]: "x \<in> \<V> \<Longrightarrow>  \<B> rep x = \<r>" 
 
 begin
 
 lemma rep_number_alt_def_all: "\<forall> x \<in> \<V>. \<B> rep x = \<r>"
   by (simp)
 
 lemma rep_number_unfold_set: "x \<in> \<V> \<Longrightarrow> size {#bl \<in># \<B> . x \<in> bl#} = \<r>"
   using rep_number by (simp add: point_replication_number_def)
 
 lemma rep_numbers_constant [simp]: "replication_numbers  = {\<r>}"
   unfolding replication_numbers_def using rep_number design_points_nempty Collect_cong finite.cases 
     finite_sets insertCI singleton_conv
   by (smt (verit, ccfv_threshold) fst_conv snd_conv) 
 
 lemma replication_number_single: "is_singleton (replication_numbers)"
   using is_singleton_the_elem by simp
 
 lemma constant_rep_point_pair: "x1 \<in> \<V> \<Longrightarrow> x2 \<in> \<V> \<Longrightarrow> x1 \<noteq> x2 \<Longrightarrow> \<B> rep x1 = \<B> rep x2"
   using rep_number by auto
 
 lemma constant_rep_alt: "x1 \<in> \<V> \<Longrightarrow> \<B> rep x1 = r2 \<Longrightarrow> (\<And> x . x \<in> \<V> \<Longrightarrow> \<B> rep x = r2)"
   by (simp)
 
 lemma constant_rep_point_not_0:
   assumes "x \<in> \<V>" 
   shows "\<B> rep x \<noteq> 0"
 proof (rule ccontr)
   assume "\<not> \<B> rep x \<noteq> 0"
   then have "\<And> x . x \<in> \<V> \<Longrightarrow> \<B> rep x = 0" using rep_number assms by auto
   then have "\<And> x . x \<in> \<V> \<Longrightarrow>  size {#bl \<in># \<B> . x \<in> bl#} = 0" 
     by (simp add: point_replication_number_def)
   then show False using design_blocks_nempty wf_design wf_design_iff wf_invalid_point
     by (metis ex_in_conv filter_mset_empty_conv multiset_nonemptyE size_eq_0_iff_empty)
 qed
 
 lemma rep_not_zero: "\<r> \<noteq> 0"
   using rep_number constant_rep_point_not_0 design_points_nempty by auto 
 
 lemma r_gzero: "\<r> > 0"
-  using point_replication_number_def rep_number constant_rep_design.rep_not_zero
-  by (metis constant_rep_design.intro constant_rep_design_axioms.intro leI of_nat_less_0_iff 
-      proper_design_axioms verit_la_disequality) 
+  using rep_not_zero by auto 
 
 lemma r_lt_eq_b: "\<r> \<le> \<b>"
   using rep_number max_point_rep
   by (metis all_not_in_conv design_points_nempty) 
 
 lemma complement_rep_number: 
   assumes "\<And> bl . bl \<in># \<B> \<Longrightarrow> incomplete_block bl"
   shows "constant_rep_design \<V> \<B>\<^sup>C (\<b> - \<r>)"
 proof - 
   interpret d: proper_design \<V> "(\<B>\<^sup>C)" using complement_proper_design
     by (simp add: assms) 
   show ?thesis using complement_rep_number rep_number by (unfold_locales) simp
 qed
 
 lemma multiple_rep_number: 
   assumes "n > 0"
   shows "constant_rep_design \<V> (multiple_blocks n) (\<r> * n)"
 proof - 
   interpret d: proper_design \<V> "(multiple_blocks n)" using multiple_proper_design
     by (simp add: assms) 
   show ?thesis using multiple_point_rep_num by (unfold_locales) (simp_all)
 qed
 end
 
 lemma (in proper_design) constant_rep_designI [intro]: "(\<And> x . x \<in> \<V> \<Longrightarrow> \<B> rep x = \<r>) 
     \<Longrightarrow> constant_rep_design \<V> \<B> \<r>"
   by unfold_locales auto
 
 subsection \<open>T-designs\<close>
 text \<open>All the before mentioned designs build up to the concept of a t-design, which has uniform 
 block size and is t-wise balanced. We limit $t$ to be less than $k$, so the balance condition has 
 relevance\<close>
 locale t_design = incomplete_design + t_wise_balance + 
   assumes block_size_t: "\<t> \<le> \<k>"
 begin
 
 lemma point_indices_balanced: "point_indices \<t> = {\<Lambda>\<^sub>t}" 
 proof -
-  have "point_indices \<t> = {i . \<exists> ps . i = \<B> index ps \<and> int (card ps) = \<t> \<and> ps \<subseteq> \<V>}"
+  have "point_indices \<t> = {i . \<exists> ps . i = \<B> index ps \<and> card ps = \<t> \<and> ps \<subseteq> \<V>}"
     by (simp add: point_indices_def) 
   then have "point_indices  \<t> = {i . i = \<Lambda>\<^sub>t}" using balanced Collect_cong obtain_t_subset_points 
-     by smt 
+     by (smt (verit, best)) 
   thus ?thesis by auto
 qed
 
 lemma point_indices_singleton: "is_singleton (point_indices \<t>)"
   using point_indices_balanced is_singleton_the_elem by simp
 
 end
 
 lemma t_designI [intro]: 
   assumes "incomplete_design V B k"
   assumes "t_wise_balance V B t \<Lambda>\<^sub>t"
   assumes "t \<le> k"
   shows "t_design V B k t \<Lambda>\<^sub>t"
   by (simp add: assms(1) assms(2) assms(3) t_design.intro t_design_axioms.intro)
 
 sublocale t_design \<subseteq> t_covering_design \<V> \<B> \<k> \<t> \<Lambda>\<^sub>t
   using t_non_zero by (unfold_locales) (auto simp add: block_size_t)
 
 sublocale t_design \<subseteq> t_packing_design \<V> \<B> \<k> \<t> \<Lambda>\<^sub>t
   using t_non_zero by (unfold_locales) (auto simp add: block_size_t)
 
 lemma t_design_pack_cov [intro]: 
   assumes "k < card V"
   assumes "t_covering_design V B k t \<Lambda>\<^sub>t"
   assumes "t_packing_design V B k t \<Lambda>\<^sub>t"
   shows "t_design V B k t \<Lambda>\<^sub>t"
 proof -
   from assms interpret id: incomplete_design V B k
     using block_design.incomplete_designI t_packing_design.axioms(1)
-    by (metis of_nat_less_iff) 
+    by blast 
   from assms interpret balance: t_wise_balance V B t \<Lambda>\<^sub>t 
     using packing_covering_imp_balance by blast 
   show ?thesis using assms(3) 
     by (unfold_locales) (simp_all add: t_packing_design.block_size_t)
 qed
 
 sublocale t_design \<subseteq> tBD \<V> \<B> \<t> \<Lambda>\<^sub>t "{\<k>}"
   using uniform k_non_zero block_size_t by (unfold_locales) simp_all
 
 context t_design 
 begin
 
 lemma multiple_t_design: "n > 0 \<Longrightarrow> t_design \<V> (multiple_blocks n) \<k> \<t> (\<Lambda>\<^sub>t * n)"
   using multiple_t_wise_balance multiple_incomplete block_size_t by (simp add: t_designI)
 
 lemma t_design_min_v: "\<v> > 1"
   using k_non_zero incomplete by simp
 
 end
 
 subsection \<open>Steiner Systems\<close>
 
 text \<open>Steiner systems are a special type of t-design where $\Lambda_t = 1$\<close>
 locale steiner_system = t_design \<V> \<B> \<k> \<t> 1 
   for point_set ("\<V>") and block_collection ("\<B>") and u_block_size ("\<k>") and grouping ("\<t>")
 
 begin
 
 lemma block_multiplicity [simp]: 
   assumes "bl \<in># \<B>"
   shows "multiplicity bl = 1"
   by (simp add: assms block_size_t)
 
 end
 
 sublocale steiner_system \<subseteq> simple_design
   by unfold_locales (simp)
 
 lemma (in t_design) steiner_systemI[intro]: "\<Lambda>\<^sub>t = 1 \<Longrightarrow> steiner_system \<V> \<B> \<k> \<t>"
   using t_non_zero t_lt_order block_size_t
   by unfold_locales auto
 
 subsection \<open>Combining block designs\<close>
 text \<open>We define some closure properties for various block designs under the combine operator.
 This is done using locales to reason on multiple instances of the same type of design, building 
 on what was presented in the design operations theory\<close>
 
 locale two_t_wise_eq_points = two_designs_proper \<V> \<B> \<V> \<B>' + des1: t_wise_balance \<V> \<B> \<t> \<Lambda>\<^sub>t + 
   des2: t_wise_balance \<V> \<B>' \<t> \<Lambda>\<^sub>t' for \<V> \<B> \<t> \<Lambda>\<^sub>t \<B>' \<Lambda>\<^sub>t'
 begin
 
 lemma combine_t_wise_balance_index: "ps \<subseteq> \<V> \<Longrightarrow> card ps = \<t> \<Longrightarrow> \<B>\<^sup>+ index ps = (\<Lambda>\<^sub>t + \<Lambda>\<^sub>t')"
   using des1.balanced des2.balanced by (simp add: combine_points_index)
 
 lemma combine_t_wise_balance: "t_wise_balance \<V>\<^sup>+ \<B>\<^sup>+ \<t> (\<Lambda>\<^sub>t + \<Lambda>\<^sub>t')"
-proof (unfold_locales, simp add: des1.t_non_zero)
+proof (unfold_locales, simp add: des1.t_non_zero_suc)
   have "card \<V>\<^sup>+  \<ge> card \<V>" by simp 
   then show "\<t> \<le> card (\<V>\<^sup>+)" using des1.t_lt_order by linarith 
   show "\<And>ps. ps \<subseteq> \<V>\<^sup>+ \<Longrightarrow> card ps = \<t> \<Longrightarrow> (\<B>\<^sup>+ index ps) = \<Lambda>\<^sub>t + \<Lambda>\<^sub>t'" 
     using combine_t_wise_balance_index by blast 
 qed
 
 sublocale combine_t_wise_des: t_wise_balance "\<V>\<^sup>+" "\<B>\<^sup>+" "\<t>" "(\<Lambda>\<^sub>t + \<Lambda>\<^sub>t')"
   using combine_t_wise_balance by auto
 
 end
 
 locale two_k_block_designs = two_designs_proper \<V> \<B> \<V>' \<B>' + des1: block_design \<V> \<B> \<k> + 
   des2: block_design \<V>' \<B>' \<k> for \<V> \<B> \<k> \<V>' \<B>'
 begin
 
 lemma block_design_combine: "block_design \<V>\<^sup>+ \<B>\<^sup>+ \<k>"
   using des1.uniform des2.uniform by (unfold_locales) (auto)
 
 sublocale combine_block_des: block_design "\<V>\<^sup>+" "\<B>\<^sup>+" "\<k>"
   using block_design_combine by simp
 
 end
 
 locale two_rep_designs_eq_points = two_designs_proper \<V> \<B> \<V> \<B>' + des1: constant_rep_design \<V> \<B> \<r> + 
   des2: constant_rep_design \<V> \<B>' \<r>' for \<V> \<B> \<r> \<B>' \<r>' 
 begin
 
 lemma combine_rep_number: "constant_rep_design \<V>\<^sup>+ \<B>\<^sup>+ (\<r> + \<r>')"
   using combine_rep_number des1.rep_number des2.rep_number by (unfold_locales) (simp)
 
 sublocale combine_const_rep: constant_rep_design "\<V>\<^sup>+" "\<B>\<^sup>+" "(\<r> + \<r>')"
   using combine_rep_number by simp
 
 end
 
 locale two_incomplete_designs = two_k_block_designs \<V> \<B> \<k> \<V>' \<B>' + des1: incomplete_design \<V> \<B> \<k> + 
   des2: incomplete_design \<V>' \<B>' \<k> for \<V> \<B> \<k> \<V>' \<B>'
 begin
 
 lemma combine_is_incomplete: "incomplete_design \<V>\<^sup>+ \<B>\<^sup>+ \<k>"
   using combine_order des1.incomplete des2.incomplete by (unfold_locales) (simp)
 
 sublocale combine_incomplete: incomplete_design "\<V>\<^sup>+" "\<B>\<^sup>+" "\<k>"
   using combine_is_incomplete by simp
 end
 
 locale two_t_designs_eq_points = two_incomplete_designs \<V> \<B> \<k> \<V> \<B>' 
   + two_t_wise_eq_points \<V> \<B> \<t> \<Lambda>\<^sub>t \<B>' \<Lambda>\<^sub>t' + des1: t_design \<V> \<B> \<k> \<t> \<Lambda>\<^sub>t + 
   des2: t_design \<V> \<B>' \<k> \<t> \<Lambda>\<^sub>t' for \<V> \<B> \<k> \<B>' \<t> \<Lambda>\<^sub>t \<Lambda>\<^sub>t'
 begin
 
 lemma combine_is_t_des: "t_design \<V>\<^sup>+ \<B>\<^sup>+ \<k> \<t> (\<Lambda>\<^sub>t + \<Lambda>\<^sub>t')"
   using des1.block_size_t des2.block_size_t by (unfold_locales)
 
 sublocale combine_t_des: t_design "\<V>\<^sup>+" "\<B>\<^sup>+" "\<k>" "\<t>" "(\<Lambda>\<^sub>t + \<Lambda>\<^sub>t')"
   using combine_is_t_des by blast
 
 end
 end
\ No newline at end of file
diff --git a/thys/Design_Theory/Design_Basics.thy b/thys/Design_Theory/Design_Basics.thy
--- a/thys/Design_Theory/Design_Basics.thy
+++ b/thys/Design_Theory/Design_Basics.thy
@@ -1,824 +1,824 @@
 theory Design_Basics imports Main Multisets_Extras "HOL-Library.Disjoint_Sets"
 begin
 
 section \<open>Design Theory Basics\<close>
 text \<open>All definitions in this section reference the handbook of combinatorial designs
  \cite{colbournHandbookCombinatorialDesigns2007}\<close>
 
 subsection \<open>Initial setup\<close>
 
 text \<open>Enable coercion of nats to ints to aid with reasoning on design properties\<close>
 declare [[coercion_enabled]]
 declare [[coercion "of_nat :: nat \<Rightarrow> int"]]
 
 subsection \<open>Incidence System\<close>
 
 text \<open>An incidence system is defined to be a wellformed set system. i.e. each block is a subset
 of the base point set. Alternatively, an incidence system can be looked at as the point set
 and an incidence relation which indicates if they are in the same block\<close>
 
 locale incidence_system = 
   fixes point_set :: "'a set" ("\<V>")
   fixes block_collection :: "'a set multiset" ("\<B>")
   assumes wellformed: "b \<in># \<B> \<Longrightarrow> b \<subseteq> \<V>"
 begin
 
 definition "\<I> \<equiv> { (x, b) . b \<in># \<B> \<and> x \<in> b}" (* incidence relation *)
 
 definition incident :: "'a \<Rightarrow> 'a set \<Rightarrow> bool" where
 "incident p b \<equiv> (p, b) \<in> \<I>"
 
 text \<open>Defines common notation used to indicate number of points ($v$) and number of blocks ($b$)\<close>
-abbreviation "\<v> \<equiv> int (card \<V>)"
+abbreviation "\<v> \<equiv> card \<V>"
 
-abbreviation "\<b> \<equiv> int (size \<B>)"
+abbreviation "\<b> \<equiv> size \<B>"
 
 text \<open>Basic incidence lemmas\<close>
 
 lemma incidence_alt_def: 
   assumes "p \<in> \<V>"
   assumes "b \<in># \<B>"
   shows "incident p b \<longleftrightarrow> p \<in> b"
   by (auto simp add: incident_def \<I>_def assms)
 
 lemma wf_invalid_point: "x \<notin> \<V> \<Longrightarrow> b \<in># \<B> \<Longrightarrow> x \<notin> b"
   using wellformed by auto
 
 lemma block_set_nempty_imp_block_ex: "\<B> \<noteq> {#} \<Longrightarrow> \<exists> bl . bl \<in># \<B>"
   by auto
 
 text \<open>Abbreviations for all incidence systems\<close>
 abbreviation multiplicity :: "'a set \<Rightarrow> nat" where
 "multiplicity b \<equiv> count \<B> b"
 
 abbreviation incomplete_block :: "'a set \<Rightarrow> bool" where
 "incomplete_block bl \<equiv> card bl < card \<V> \<and> bl \<in># \<B>"
 
 lemma incomplete_alt_size: "incomplete_block bl \<Longrightarrow> card bl < \<v>" 
   by simp
 
 lemma incomplete_alt_in: "incomplete_block bl \<Longrightarrow> bl \<in># \<B>"
   by simp
 
 lemma incomplete_alt_imp[intro]: "card bl < \<v> \<Longrightarrow> bl \<in># \<B> \<Longrightarrow> incomplete_block bl"
   by simp
 
 definition design_support :: "'a set set" where
 "design_support \<equiv> set_mset \<B>"
 
 end
 
 subsection \<open>Finite Incidence Systems\<close>
 
 text \<open>These simply require the point set to be finite.
 As multisets are only defined to be finite, it is implied that the block set must be finite already\<close>
 
 locale finite_incidence_system = incidence_system + 
   assumes finite_sets: "finite \<V>"
 begin
 
 lemma finite_blocks: "b \<in># \<B> \<Longrightarrow> finite b"
   using wellformed finite_sets finite_subset by blast 
 
 lemma mset_points_distinct: "distinct_mset (mset_set \<V>)"
   using finite_sets by (simp add: distinct_mset_def)
 
 lemma mset_points_distinct_diff_one: "distinct_mset (mset_set (\<V> - {x}))"
   by (meson count_mset_set_le_one distinct_mset_count_less_1)
 
 lemma finite_design_support: "finite (design_support)"
   using design_support_def by auto 
 
 lemma block_size_lt_order: "bl \<in># \<B> \<Longrightarrow> card bl \<le> card \<V>"
   using wellformed by (simp add: card_mono finite_sets)  
 
 end
 
 subsection \<open>Designs\<close>
 
 text \<open>There are many varied definitions of a design in literature. However, the most
 commonly accepted definition is a finite point set, $V$ and collection of blocks $B$, where
 no block in $B$ can be empty\<close>
 locale design = finite_incidence_system +
   assumes blocks_nempty: "bl \<in># \<B> \<Longrightarrow> bl \<noteq> {}"
 begin
 
 lemma wf_design: "design \<V> \<B>"  by intro_locales
 
 lemma wf_design_iff: "bl \<in># \<B> \<Longrightarrow> design \<V> \<B> \<longleftrightarrow> (bl \<subseteq> \<V> \<and> finite \<V> \<and> bl \<noteq> {})"
   using blocks_nempty wellformed finite_sets
   by (simp add: wf_design) 
 
 text \<open>Reasoning on non empty properties and non zero parameters\<close>
 lemma blocks_nempty_alt: "\<forall> bl \<in># \<B>. bl \<noteq> {}"
   using blocks_nempty by auto
 
 lemma block_set_nempty_imp_points: "\<B> \<noteq> {#} \<Longrightarrow> \<V> \<noteq> {}"
   using wf_design wf_design_iff by auto
 
 lemma b_non_zero_imp_v_non_zero: "\<b> > 0 \<Longrightarrow> \<v> > 0"
   using block_set_nempty_imp_points finite_sets by fastforce
 
 lemma v_eq0_imp_b_eq_0: "\<v> = 0 \<Longrightarrow> \<b> = 0"
   using b_non_zero_imp_v_non_zero by auto
 
 text \<open>Size lemmas\<close>
 lemma block_size_lt_v: "bl \<in># \<B> \<Longrightarrow> card bl \<le> \<v>"
   by (simp add: card_mono finite_sets wellformed)
 
 lemma block_size_gt_0: "bl \<in># \<B> \<Longrightarrow> card bl > 0"
   using finite_sets blocks_nempty finite_blocks by fastforce
 
 lemma design_cart_product_size: "size ((mset_set \<V>) \<times># \<B>) = \<v> * \<b>"
   by (simp add: size_cartesian_product) 
 
 end
 
 text \<open>Intro rules for design locale\<close>
 
 lemma wf_design_implies: 
   assumes "(\<And> b . b \<in># \<B> \<Longrightarrow> b \<subseteq> V)"
   assumes "\<And> b . b \<in># \<B> \<Longrightarrow> b \<noteq> {}"
   assumes "finite V"
   assumes "\<B> \<noteq> {#}"
   assumes "V \<noteq> {}"
   shows "design V \<B>"
   using assms by (unfold_locales) simp_all
 
 lemma (in incidence_system) finite_sysI[intro]: "finite \<V> \<Longrightarrow> finite_incidence_system \<V> \<B>"
   by (unfold_locales) simp_all
 
 lemma (in finite_incidence_system) designI[intro]: "(\<And> b. b \<in># \<B> \<Longrightarrow> b \<noteq> {}) \<Longrightarrow> \<B> \<noteq> {#}
      \<Longrightarrow> \<V> \<noteq> {} \<Longrightarrow> design \<V> \<B>"
   by (unfold_locales) simp_all
 
 subsection \<open>Core Property Definitions\<close>
 
 subsubsection \<open>Replication Number\<close>
 
 text \<open>The replication number for a point is the number of blocks that point is incident with\<close>
 
-definition point_replication_number :: "'a set multiset \<Rightarrow> 'a \<Rightarrow> int" (infix "rep" 75) where
+definition point_replication_number :: "'a set multiset \<Rightarrow> 'a \<Rightarrow> nat" (infix "rep" 75) where
 "B rep x \<equiv> size {#b \<in># B . x \<in> b#}"
 
 lemma max_point_rep: "B rep x \<le> size B"
   using size_filter_mset_lesseq by (simp add: point_replication_number_def)
 
 lemma rep_number_g0_exists: 
   assumes "B rep x > 0" 
   obtains b where "b \<in># B" and "x \<in> b"
 proof -
   have "size {#b \<in># B . x \<in> b#} > 0" using assms point_replication_number_def
-    by (metis of_nat_0_less_iff)
+    by metis
   thus ?thesis
     by (metis filter_mset_empty_conv nonempty_has_size that) 
 qed
 
 lemma rep_number_on_set_def: "finite B \<Longrightarrow> (mset_set B) rep x = card {b \<in> B . x \<in> b}"
   by (simp add: point_replication_number_def)
 
 lemma point_rep_number_split[simp]: "(A + B) rep x = A rep x + B rep x"
   by (simp add: point_replication_number_def)
 
 lemma point_rep_singleton_val [simp]: "x \<in> b \<Longrightarrow> {#b#} rep x = 1"
   by (simp add: point_replication_number_def)
 
 lemma point_rep_singleton_inval [simp]: "x \<notin> b \<Longrightarrow> {#b#} rep x = 0"
   by (simp add: point_replication_number_def)
 
 context incidence_system
 begin
 
 lemma point_rep_number_alt_def: "\<B> rep x = size {# b \<in># \<B> . x \<in> b#}"
   by (simp add: point_replication_number_def)
 
 lemma rep_number_non_zero_system_point: " \<B> rep x > 0 \<Longrightarrow> x \<in> \<V>"
   using rep_number_g0_exists wellformed
   by (metis wf_invalid_point) 
 
 lemma point_rep_non_existance [simp]: "x \<notin> \<V> \<Longrightarrow> \<B> rep x = 0"
   using wf_invalid_point by (simp add:  point_replication_number_def filter_mset_empty_conv) 
 
 lemma point_rep_number_inv: "size {# b \<in># \<B> . x \<notin> b #} = \<b> - (\<B> rep x)"
 proof -
   have "\<b> = size {# b \<in># \<B> . x \<notin> b #} + size {# b \<in># \<B> . x \<in> b #}"
     using multiset_partition by (metis add.commute size_union)  
   thus ?thesis by (simp add: point_replication_number_def) 
 qed
 
 lemma point_rep_num_inv_non_empty: "(\<B> rep x) < \<b> \<Longrightarrow> \<B> \<noteq> {#} \<Longrightarrow> {# b \<in># \<B> . x \<notin> b #} \<noteq> {#}"
   by (metis diff_zero point_replication_number_def size_empty size_filter_neg verit_comp_simplify1(1))
 
 end
 
 subsubsection \<open>Point Index\<close>
 
 text \<open>The point index of a subset of points in a design, is the number of times those points 
 occur together in a block of the design\<close>
 definition points_index :: "'a set multiset \<Rightarrow> 'a set \<Rightarrow> nat" (infix "index" 75) where
 "B index ps \<equiv> size {#b \<in># B . ps \<subseteq> b#}"
 
 lemma points_index_empty [simp]: "{#} index ps = 0"
   by (simp add: points_index_def)
 
 lemma point_index_distrib: "(B1 + B2) index ps =  B1 index ps + B2 index ps"
   by (simp add: points_index_def)
 
 lemma point_index_diff: "B1 index ps = (B1 + B2) index ps - B2 index ps"
   by (simp add: points_index_def)
 
 lemma points_index_singleton: "{#b#} index ps = 1 \<longleftrightarrow> ps \<subseteq> b"
   by (simp add: points_index_def)
 
 lemma points_index_singleton_zero: "\<not> (ps \<subseteq> b) \<Longrightarrow> {#b#} index ps = 0"
   by (simp add: points_index_def)
 
 lemma points_index_sum: "(\<Sum>\<^sub># B ) index ps = (\<Sum>b \<in># B . (b index ps))"
   using points_index_empty by (induction B) (auto simp add: point_index_distrib)
 
 lemma points_index_block_image_add_eq: 
   assumes "x \<notin> ps"
   assumes "B index ps = l"
   shows "{# insert x b . b \<in># B#} index ps = l"
   using points_index_def by (metis (no_types, lifting) assms filter_mset_cong 
       image_mset_filter_swap2 points_index_def size_image_mset subset_insert)
 
 lemma points_index_on_set_def [simp]: 
   assumes "finite B"
   shows "(mset_set B) index ps = card {b \<in> B. ps \<subseteq> b}"
   by (simp add: points_index_def assms)
 
 lemma points_index_single_rep_num: "B index {x} = B rep x"
   by (simp add: points_index_def point_replication_number_def)
 
 lemma points_index_pair_rep_num: 
   assumes "\<And> b. b \<in># B \<Longrightarrow> x \<in> b"
   shows "B index {x, y} = B rep y"
   using point_replication_number_def points_index_def
   by (metis assms empty_subsetI filter_mset_cong insert_subset)
 
 lemma points_index_0_left_imp: 
   assumes "B index ps = 0"
   assumes "b \<in># B"
   shows "\<not> (ps \<subseteq> b)"
 proof (rule ccontr)
   assume "\<not> \<not> ps \<subseteq> b"
   then have a: "ps \<subseteq> b" by auto
   then have "b \<in># {#bl \<in># B . ps \<subseteq> bl#}" by (simp add: assms(2)) 
   thus False by (metis assms(1) count_greater_eq_Suc_zero_iff count_size_set_repr not_less_eq_eq 
         points_index_def size_filter_mset_lesseq) 
 qed
 
 lemma points_index_0_right_imp: 
   assumes "\<And> b . b \<in># B \<Longrightarrow> (\<not> ps \<subseteq> b)"
   shows "B index ps = 0"
   using assms by (simp add: filter_mset_empty_conv points_index_def)
 
 lemma points_index_0_iff: "B index ps = 0 \<longleftrightarrow> (\<forall> b. b \<in># B \<longrightarrow> (\<not> ps \<subseteq> b))"
   using points_index_0_left_imp points_index_0_right_imp by metis
 
 lemma points_index_gt0_impl_existance: 
   assumes "B index ps > 0"
   shows "(\<exists> bl . (bl \<in># B \<and> ps \<subseteq> bl))"
 proof -
   have "size {#bl \<in># B . ps \<subseteq> bl#} > 0"
     by (metis assms points_index_def)
   then obtain bl where "bl \<in># B" and "ps \<subseteq> bl"
     by (metis filter_mset_empty_conv nonempty_has_size) 
   thus ?thesis by auto
 qed
 
 lemma points_index_one_unique: 
   assumes "B index ps = 1"
   assumes "bl \<in># B" and "ps \<subseteq> bl" and "bl' \<in># B" and "ps \<subseteq> bl'"
   shows "bl = bl'"
 proof (rule ccontr)
   assume assm: "bl \<noteq> bl'"
   then have bl1: "bl \<in># {#bl \<in># B . ps \<subseteq> bl#}" using assms by simp
   then have bl2: "bl'\<in># {#bl \<in># B . ps \<subseteq> bl#}" using assms by simp
   then have "{#bl, bl'#} \<subseteq># {#bl \<in># B . ps \<subseteq> bl#}" using assms by (metis bl1 bl2 points_index_def
         add_mset_subseteq_single_iff assm mset_subset_eq_single size_single subseteq_mset_size_eql) 
   then have "size {#bl \<in># B . ps \<subseteq> bl#} \<ge> 2" using size_mset_mono by fastforce 
   thus False using assms by (metis numeral_le_one_iff points_index_def semiring_norm(69))
 qed
 
 lemma points_index_one_unique_block: 
   assumes "B index ps = 1"
   shows "\<exists>! bl . (bl \<in># B \<and> ps \<subseteq> bl)"
   using assms points_index_gt0_impl_existance points_index_one_unique
   by (metis zero_less_one) 
 
 lemma points_index_one_not_unique_block: 
   assumes "B index ps = 1"
   assumes "ps \<subseteq> bl"
   assumes "bl \<in># B"
   assumes "bl' \<in># B - {#bl#}"
   shows "\<not> ps \<subseteq> bl'"
 proof - 
   have "B = (B - {#bl#}) + {#bl#}" by (simp add: assms(3)) 
   then have "(B - {#bl#}) index ps = B index ps - {#bl#} index ps"
     by (metis point_index_diff) 
   then have "(B - {#bl#}) index ps = 0" using assms points_index_singleton
     by (metis diff_self_eq_0) 
   thus ?thesis using assms(4) points_index_0_left_imp by auto
 qed
 
 lemma (in incidence_system) points_index_alt_def: "\<B> index ps = size {#b \<in># \<B> . ps \<subseteq> b#}"
   by (simp add: points_index_def)
 
 lemma (in incidence_system) points_index_ps_nin: "\<not> (ps \<subseteq> \<V>) \<Longrightarrow> \<B> index ps = 0"
   using points_index_alt_def filter_mset_empty_conv in_mono size_empty subsetI wf_invalid_point
   by metis 
 
 lemma (in incidence_system) points_index_count_bl: 
     "multiplicity bl \<ge> n \<Longrightarrow> ps \<subseteq> bl \<Longrightarrow> count {#bl \<in># \<B> . ps \<subseteq> bl#} bl \<ge> n"
   by simp
 
 lemma (in finite_incidence_system) points_index_zero: 
   assumes "card ps > card \<V>" 
   shows "\<B> index ps = 0"
 proof -
   have "\<And> b. b \<in># \<B> \<Longrightarrow> card ps > card b" 
     using block_size_lt_order card_subset_not_gt_card finite_sets assms by fastforce 
   then have "{#b \<in># \<B> . ps \<subseteq> b#} = {#}"
     by (simp add: card_subset_not_gt_card filter_mset_empty_conv finite_blocks)
   thus ?thesis using points_index_alt_def by simp
 qed
 
 lemma (in design) points_index_subset: 
     "x \<subseteq># {#bl \<in># \<B> . ps \<subseteq> bl#} \<Longrightarrow> ps \<subseteq> \<V> \<Longrightarrow> (\<B> index ps) \<ge> (size x)"
   by (simp add: points_index_def size_mset_mono)
 
 lemma (in design) points_index_count_min: "multiplicity bl \<ge> n \<Longrightarrow> ps \<subseteq> bl \<Longrightarrow> \<B> index ps \<ge> n"
   using points_index_alt_def set_count_size_min by (metis filter_mset.rep_eq) 
 
 subsubsection \<open>Intersection Number\<close>
 
 text \<open>The intersection number of two blocks is the size of the intersection of those blocks. i.e. 
 the number of points which occur in both blocks\<close>
-definition intersection_number :: "'a set \<Rightarrow> 'a set \<Rightarrow> int" (infix "|\<inter>|" 70) where
+definition intersection_number :: "'a set \<Rightarrow> 'a set \<Rightarrow> nat" (infix "|\<inter>|" 70) where
 "b1 |\<inter>| b2 \<equiv> card (b1 \<inter> b2)"
 
 lemma intersection_num_non_neg: "b1 |\<inter>| b2 \<ge> 0"
   by (simp add: intersection_number_def)
 
 lemma intersection_number_empty_iff: 
   assumes "finite b1"
   shows "b1 \<inter> b2 = {} \<longleftrightarrow> b1 |\<inter>| b2 = 0"
   by (simp add: intersection_number_def assms)
 
 lemma intersect_num_commute: "b1 |\<inter>| b2 = b2 |\<inter>| b1"
   by (simp add: inf_commute intersection_number_def) 
 
-definition n_intersect_number :: "'a set \<Rightarrow> nat\<Rightarrow> 'a set \<Rightarrow> int" where
+definition n_intersect_number :: "'a set \<Rightarrow> nat\<Rightarrow> 'a set \<Rightarrow> nat" where
 "n_intersect_number b1 n b2 \<equiv> card { x \<in> Pow (b1 \<inter> b2) . card x = n}"
 
 notation n_intersect_number ("(_ |\<inter>|\<^sub>_ _)" [52, 51, 52] 50)
 
 lemma n_intersect_num_subset_def: "b1 |\<inter>|\<^sub>n b2 = card {x . x \<subseteq> b1 \<inter> b2 \<and> card x = n}"
   using n_intersect_number_def by auto
 
 lemma n_inter_num_one: "finite b1 \<Longrightarrow> finite b2 \<Longrightarrow> b1 |\<inter>|\<^sub>1 b2 = b1 |\<inter>| b2"
   using n_intersect_number_def intersection_number_def card_Pow_filter_one
   by (metis (full_types) finite_Int) 
 
 lemma n_inter_num_choose: "finite b1 \<Longrightarrow> finite b2 \<Longrightarrow> b1 |\<inter>|\<^sub>n b2 = (card (b1 \<inter> b2) choose n)" 
   using n_subsets n_intersect_num_subset_def
   by (metis (full_types) finite_Int) 
 
 lemma set_filter_single: "x \<in> A \<Longrightarrow> {a \<in> A . a = x} = {x}"
   by auto 
 
 lemma (in design) n_inter_num_zero: 
   assumes "b1 \<in># \<B>" and "b2 \<in># \<B>"
   shows "b1 |\<inter>|\<^sub>0 b2 = 1"
 proof -
   have empty: "\<And>x . finite x \<Longrightarrow> card x = 0 \<Longrightarrow> x = {}"
     by simp
   have empt_in: "{} \<in> Pow (b1 \<inter> b2)" by simp
   have "finite (b1 \<inter> b2)" using finite_blocks assms by simp
   then have "\<And> x . x \<in> Pow (b1 \<inter> b2) \<Longrightarrow> finite x" by (meson PowD finite_subset) 
   then have "{x \<in> Pow (b1 \<inter> b2) . card x = 0} = {x \<in> Pow (b1 \<inter> b2) . x = {}}" 
     using empty by (metis card.empty)
   then have "{x \<in> Pow (b1 \<inter> b2) . card x = 0} = {{}}" 
     by (simp add: empt_in set_filter_single Collect_conv_if)
   thus ?thesis by (simp add: n_intersect_number_def)
 qed
 
 lemma (in design) n_inter_num_choose_design: "b1 \<in># \<B> \<Longrightarrow> b2 \<in># \<B> 
     \<Longrightarrow> b1 |\<inter>|\<^sub>n b2 = (card (b1 \<inter> b2) choose n) "
   using finite_blocks by (simp add: n_inter_num_choose)
 
 lemma (in design) n_inter_num_choose_design_inter: "b1 \<in># \<B> \<Longrightarrow> b2 \<in># \<B> 
     \<Longrightarrow> b1 |\<inter>|\<^sub>n b2 = (nat (b1 |\<inter>| b2) choose n) "
   using finite_blocks by (simp add: n_inter_num_choose intersection_number_def)
 
 subsection \<open>Incidence System Set Property Definitions\<close>
 context incidence_system
 begin
 
 text \<open>The set of replication numbers for all points of design\<close>
-definition replication_numbers :: "int set" where
+definition replication_numbers :: "nat set" where
 "replication_numbers \<equiv> {\<B> rep x | x . x \<in> \<V>}"
 
 lemma replication_numbers_non_empty: 
   assumes "\<V> \<noteq> {}"
   shows "replication_numbers \<noteq> {}"
   by (simp add: assms replication_numbers_def) 
 
 lemma obtain_point_with_rep: "r \<in> replication_numbers \<Longrightarrow> \<exists> x. x \<in> \<V> \<and> \<B> rep x = r"
   using replication_numbers_def by auto
 
 lemma point_rep_number_in_set: "x \<in> \<V> \<Longrightarrow> (\<B> rep x) \<in> replication_numbers"
   by (auto simp add: replication_numbers_def)
 
 lemma (in finite_incidence_system) replication_numbers_finite: "finite replication_numbers"
   using finite_sets by (simp add: replication_numbers_def)
 
 text \<open>The set of all block sizes in a system\<close>
 
-definition sys_block_sizes :: "int set" where
-"sys_block_sizes \<equiv> { (int (card bl)) | bl. bl \<in># \<B>}"
+definition sys_block_sizes :: "nat set" where
+"sys_block_sizes \<equiv> { card bl | bl. bl \<in># \<B>}"
 
 lemma block_sizes_non_empty_set: 
   assumes "\<B> \<noteq> {#}"
   shows "sys_block_sizes \<noteq> {}"
 by (simp add: sys_block_sizes_def assms)
 
 lemma finite_block_sizes: "finite (sys_block_sizes)"
   by (simp add: sys_block_sizes_def)
 
 lemma block_sizes_non_empty: 
   assumes "\<B> \<noteq> {#}"
   shows "card (sys_block_sizes) > 0"
   using finite_block_sizes block_sizes_non_empty_set
   by (simp add: assms card_gt_0_iff) 
 
 lemma sys_block_sizes_in: "bl \<in># \<B> \<Longrightarrow> card bl \<in> sys_block_sizes"
   unfolding sys_block_sizes_def by auto 
 
-lemma sys_block_sizes_obtain_bl: "x \<in> sys_block_sizes  \<Longrightarrow> (\<exists> bl \<in># \<B>. int (card bl) = x)"
+lemma sys_block_sizes_obtain_bl: "x \<in> sys_block_sizes  \<Longrightarrow> (\<exists> bl \<in># \<B>. card bl = x)"
   by (auto simp add: sys_block_sizes_def)
 
 text \<open>The set of all possible intersection numbers in a system.\<close>
 
-definition intersection_numbers :: "int set" where
+definition intersection_numbers :: "nat set" where
 "intersection_numbers \<equiv> { b1 |\<inter>| b2 | b1 b2 . b1 \<in># \<B> \<and> b2 \<in># (\<B> - {#b1#})}"
 
 lemma obtain_blocks_intersect_num: "n \<in> intersection_numbers \<Longrightarrow> 
   \<exists> b1 b2. b1 \<in># \<B> \<and> b2 \<in># (\<B> - {#b1#}) \<and>  b1 |\<inter>| b2 = n"
   by (auto simp add: intersection_numbers_def)
 
 lemma intersect_num_in_set: "b1 \<in># \<B> \<Longrightarrow> b2 \<in># (\<B> - {#b1#}) \<Longrightarrow> b1 |\<inter>| b2 \<in> intersection_numbers"
   by (auto simp add: intersection_numbers_def)
 
 text \<open>The set of all possible point indices\<close>
-definition point_indices :: "int \<Rightarrow> int set" where
-"point_indices t \<equiv> {\<B> index ps | ps. int (card ps) = t \<and> ps \<subseteq> \<V>}"
+definition point_indices :: "nat \<Rightarrow> nat set" where
+"point_indices t \<equiv> {\<B> index ps | ps. card ps = t \<and> ps \<subseteq> \<V>}"
 
 lemma point_indices_elem_in: "ps \<subseteq> \<V> \<Longrightarrow> card ps = t \<Longrightarrow> \<B> index ps \<in> point_indices t"
   by (auto simp add: point_indices_def)
 
-lemma point_indices_alt_def: "point_indices t = { \<B> index ps | ps. int (card ps) = t \<and> ps \<subseteq> \<V>}"
+lemma point_indices_alt_def: "point_indices t = { \<B> index ps | ps. card ps = t \<and> ps \<subseteq> \<V>}"
   by (simp add: point_indices_def)
 
 end
 
 subsection \<open>Basic Constructions on designs\<close>
 
 text \<open>This section defines some of the most common universal constructions found in design theory
 involving only a single design\<close>
 
 subsubsection \<open>Design Complements\<close>
 
 context incidence_system
 begin
 
 text \<open>The complement of a block are all the points in the design not in that block. 
 The complement of a design is therefore the original point sets, and set of all block complements\<close>
 definition block_complement:: "'a set \<Rightarrow> 'a set" ("_\<^sup>c" [56] 55) where
 "block_complement b \<equiv> \<V> - b"
 
 definition complement_blocks :: "'a set multiset" ("(\<B>\<^sup>C)")where
 "complement_blocks \<equiv> {# bl\<^sup>c . bl \<in># \<B> #}" 
 
 lemma block_complement_elem_iff: 
   assumes "ps \<subseteq> \<V>"
   shows "ps \<subseteq> bl\<^sup>c \<longleftrightarrow> (\<forall> x \<in> ps. x \<notin> bl)"
   using assms block_complement_def by (auto)
 
 lemma block_complement_inter_empty: "bl1\<^sup>c = bl2 \<Longrightarrow> bl1 \<inter> bl2 = {}"
   using block_complement_def by auto
 
 lemma block_complement_inv: 
   assumes "bl \<in># \<B>"
   assumes "bl\<^sup>c = bl2"
   shows "bl2\<^sup>c = bl"
   by (metis Diff_Diff_Int assms(1) assms(2) block_complement_def inf.absorb_iff2 wellformed)
 
 lemma block_complement_subset_points: "ps \<subseteq> (bl\<^sup>c) \<Longrightarrow> ps \<subseteq> \<V>"
   using block_complement_def by blast
 
 lemma obtain_comp_block_orig: 
   assumes "bl1 \<in># \<B>\<^sup>C"
   obtains bl2 where "bl2 \<in># \<B>" and "bl1 = bl2\<^sup>c"
   using wellformed assms by (auto simp add: complement_blocks_def)
 
 lemma complement_same_b [simp]: "size \<B>\<^sup>C = size \<B>"
   by (simp add: complement_blocks_def)
 
 lemma block_comp_elem_alt_left: "x \<in> bl \<Longrightarrow> ps \<subseteq> bl\<^sup>c \<Longrightarrow> x \<notin> ps"
   by (auto simp add: block_complement_def block_complement_elem_iff)
 
 lemma block_comp_elem_alt_right: "ps \<subseteq> \<V> \<Longrightarrow> (\<And> x . x \<in> ps \<Longrightarrow> x \<notin> bl) \<Longrightarrow> ps \<subseteq> bl\<^sup>c"
   by (auto simp add: block_complement_elem_iff)
 
 lemma complement_index:
   assumes "ps \<subseteq> \<V>"
   shows "\<B>\<^sup>C index ps = size {# b \<in># \<B> . (\<forall> x \<in> ps . x \<notin> b) #}"
 proof -
   have "\<B>\<^sup>C index ps =  size {# b \<in># {# bl\<^sup>c . bl \<in># \<B>#}. ps \<subseteq> b #}"
     by (simp add: complement_blocks_def points_index_def) 
   then have "\<B>\<^sup>C index ps = size {# bl\<^sup>c | bl \<in># \<B> . ps \<subseteq> bl\<^sup>c #}"
     by (metis image_mset_filter_swap)
   thus ?thesis using assms by (simp add: block_complement_elem_iff)
 qed
 
 lemma complement_index_2:
   assumes "{x, y} \<subseteq> \<V>"
   shows "\<B>\<^sup>C index {x, y} = size {# b \<in># \<B> . x \<notin> b \<and> y \<notin> b #}"
 proof -
   have a: "\<And> b. b \<in># \<B> \<Longrightarrow> \<forall> x' \<in> {x, y} . x' \<notin> b \<Longrightarrow> x \<notin> b \<and> y \<notin> b"
     by simp 
   have "\<And> b. b \<in># \<B> \<Longrightarrow> x \<notin> b \<and> y \<notin> b \<Longrightarrow> \<forall> x' \<in> {x, y} . x' \<notin> b "
     by simp 
   thus ?thesis using assms a complement_index
     by (smt (verit) filter_mset_cong) 
 qed
 
 lemma complement_rep_number: 
   assumes "x \<in> \<V>" and "\<B> rep x = r" 
   shows  "\<B>\<^sup>C rep x = \<b> - r"
 proof - 
   have r: "size {#b \<in># \<B> . x \<in> b#} = r" using assms by (simp add: point_replication_number_def)
   then have a: "\<And> b . b \<in># \<B> \<Longrightarrow> x \<in> b \<Longrightarrow> x \<notin> b\<^sup>c"
     by (simp add: block_complement_def)
   have "\<And> b . b \<in># \<B> \<Longrightarrow> x \<notin> b \<Longrightarrow> x \<in> b\<^sup>c"
     by (simp add: assms(1) block_complement_def) 
   then have alt: "(image_mset block_complement \<B>) rep x = size {#b \<in># \<B> . x \<notin> b#}" 
     using a filter_mset_cong image_mset_filter_swap2 point_replication_number_def
     by (smt (verit, ccfv_SIG) size_image_mset) 
   have "\<b> = size {#b \<in># \<B> . x \<in> b#} + size {#b \<in># \<B> . x \<notin> b#}"
     by (metis multiset_partition size_union) 
   thus ?thesis using alt
     by (simp add: r complement_blocks_def)
 qed
 
 lemma complement_blocks_wf: "bl \<in># \<B>\<^sup>C \<Longrightarrow> bl \<subseteq> \<V>"
   by (auto simp add: complement_blocks_def block_complement_def)
 
 lemma complement_wf [intro]: "incidence_system \<V> \<B>\<^sup>C"
   using complement_blocks_wf by (unfold_locales)
 
 interpretation sys_complement: incidence_system "\<V>" "\<B>\<^sup>C"
   using complement_wf by simp 
 end
 
 context finite_incidence_system
 begin
 lemma block_complement_size: "b \<subseteq> \<V> \<Longrightarrow> card (b\<^sup>c) = card \<V> - card b"
   by (simp add: block_complement_def card_Diff_subset finite_subset card_mono of_nat_diff finite_sets)  
 
 lemma block_comp_incomplete: "incomplete_block bl \<Longrightarrow> card (bl\<^sup>c) > 0"
   using block_complement_size by (simp add: wellformed) 
 
 lemma  block_comp_incomplete_nempty: "incomplete_block bl \<Longrightarrow> bl\<^sup>c \<noteq> {}"
   using wellformed block_complement_def finite_blocks
   by (auto simp add: block_complement_size block_comp_incomplete card_subset_not_gt_card)
 
 lemma incomplete_block_proper_subset: "incomplete_block bl \<Longrightarrow> bl \<subset> \<V>"
   using wellformed by fastforce
 
 lemma complement_finite: "finite_incidence_system \<V> \<B>\<^sup>C"
   using complement_wf finite_sets by (simp add: incidence_system.finite_sysI) 
 
 interpretation comp_fin: finite_incidence_system \<V> "\<B>\<^sup>C"
   using complement_finite by simp 
 
 end
 
 context design
 begin
 lemma (in design) complement_design: 
   assumes "\<And> bl . bl \<in># \<B> \<Longrightarrow> incomplete_block bl" 
   shows "design \<V> (\<B>\<^sup>C)"
 proof -
   interpret fin: finite_incidence_system \<V> "\<B>\<^sup>C" using complement_finite by simp
   show ?thesis using assms block_comp_incomplete_nempty wellformed 
     by (unfold_locales) (auto simp add: complement_blocks_def)
 qed
 
 end
 subsubsection \<open>Multiples\<close>
 text \<open>An easy way to construct new set systems is to simply multiply the block collection by some 
 constant\<close>
 
 context incidence_system 
 begin
 
 abbreviation multiple_blocks :: "nat \<Rightarrow> 'a set multiset" where
 "multiple_blocks n \<equiv> repeat_mset n \<B>"
 
 lemma multiple_block_in_original: "b \<in># multiple_blocks n \<Longrightarrow> b \<in># \<B>"
   by (simp add: elem_in_repeat_in_original) 
 
 lemma multiple_block_in: "n > 0 \<Longrightarrow> b \<in># \<B> \<Longrightarrow>  b \<in># multiple_blocks n"
   by (simp add: elem_in_original_in_repeat)
 
 lemma multiple_blocks_gt: "n > 0 \<Longrightarrow> size (multiple_blocks n) \<ge> size \<B>" 
   by (simp)
 
 lemma block_original_count_le: "n > 0 \<Longrightarrow> count \<B> b \<le> count (multiple_blocks n) b"
   using count_repeat_mset by simp 
 
 lemma multiple_blocks_sub: "n > 0 \<Longrightarrow> \<B> \<subseteq># (multiple_blocks n)"
   by (simp add: mset_subset_eqI block_original_count_le) 
 
 lemma multiple_1_same: "multiple_blocks 1 = \<B>"
   by simp
 
 lemma multiple_unfold_1: "multiple_blocks (Suc n) = (multiple_blocks n) + \<B>"
   by simp
 
 lemma multiple_point_rep_num: "(multiple_blocks n) rep x = (\<B> rep x) * n"
 proof (induction n)
   case 0
   then show ?case by (simp add: point_replication_number_def)
 next
   case (Suc n)
   then have "multiple_blocks (Suc n) rep x = \<B> rep x * n + (\<B> rep x)"
     using Suc.IH Suc.prems by (simp add: union_commute point_replication_number_def)
   then show ?case
-    by (simp add: int_distrib(2)) 
+    by (simp)
 qed
 
 lemma multiple_point_index: "(multiple_blocks n) index ps = (\<B> index ps) * n"
   by (induction n) (auto simp add: points_index_def)
 
 lemma repeat_mset_block_point_rel: "\<And>b x. b \<in># multiple_blocks  n \<Longrightarrow> x \<in> b \<Longrightarrow> x \<in> \<V>"
   by (induction n) (auto, meson subset_iff wellformed)
 
 lemma multiple_is_wellformed: "incidence_system \<V> (multiple_blocks n)"
   using repeat_mset_subset_in wellformed repeat_mset_block_point_rel by (unfold_locales) (auto)
 
 lemma  multiple_blocks_num [simp]: "size (multiple_blocks n) = n*\<b>"
   by simp
 
 interpretation mult_sys: incidence_system \<V> "(multiple_blocks n)"
   by (simp add: multiple_is_wellformed)
 
 lemma multiple_block_multiplicity [simp]: "mult_sys.multiplicity n bl = (multiplicity bl) * n"
   by (simp)
 
 lemma multiple_block_sizes_same: 
   assumes "n > 0" 
   shows "sys_block_sizes = mult_sys.sys_block_sizes n"
 proof -
   have def: "mult_sys.sys_block_sizes n = {card bl | bl. bl \<in># (multiple_blocks n)}"
     by (simp add: mult_sys.sys_block_sizes_def) 
   then have eq: "\<And> bl. bl \<in># (multiple_blocks n) \<longleftrightarrow> bl \<in># \<B>"
     using assms multiple_block_in multiple_block_in_original by blast 
   thus ?thesis using def by (simp add: sys_block_sizes_def eq)
 qed 
 
 end
 
 context finite_incidence_system
 begin
 
 lemma multiple_is_finite: "finite_incidence_system \<V> (multiple_blocks n)"
   using multiple_is_wellformed finite_sets by (unfold_locales) (auto simp add: incidence_system_def)
 
 end
 
 context design
 begin
 
 lemma multiple_is_design: "design \<V> (multiple_blocks n)"
 proof -
   interpret fis: finite_incidence_system \<V> "multiple_blocks n" using multiple_is_finite by simp
   show ?thesis using blocks_nempty
     by (unfold_locales) (auto simp add: elem_in_repeat_in_original repeat_mset_not_empty)
 qed
 
 end
 
 subsection \<open>Simple Designs\<close>
 
 text \<open>Simple designs are those in which the multiplicity of each block is at most one. 
 In other words, the block collection is a set. This can significantly ease reasoning.\<close>
 
 locale simple_incidence_system = incidence_system + 
   assumes simple [simp]: "bl \<in># \<B> \<Longrightarrow> multiplicity bl = 1"
 
 begin 
 
 lemma simple_alt_def_all: "\<forall> bl \<in># \<B> . multiplicity bl = 1"
   using simple by auto
   
 lemma simple_blocks_eq_sup: "mset_set (design_support) = \<B>"
   using distinct_mset_def simple design_support_def by (metis distinct_mset_set_mset_ident) 
 
 lemma simple_block_size_eq_card: "\<b> = card (design_support)"
   by (metis simple_blocks_eq_sup size_mset_set)
 
 lemma points_index_simple_def: "\<B> index ps = card {b \<in> design_support . ps \<subseteq> b}"
   using design_support_def points_index_def card_size_filter_eq simple_blocks_eq_sup
   by (metis finite_set_mset) 
 
 lemma replication_num_simple_def: "\<B> rep x = card {b \<in> design_support . x \<in> b}"
   using design_support_def point_replication_number_def card_size_filter_eq simple_blocks_eq_sup
   by (metis finite_set_mset) 
 
 end
 
 locale simple_design = design + simple_incidence_system
 
 text \<open>Additional reasoning about when something is not simple\<close>
 context incidence_system
 begin
 lemma simple_not_multiplicity: "b \<in># \<B> \<Longrightarrow> multiplicity  b > 1 \<Longrightarrow> \<not> simple_incidence_system \<V> \<B>"
   using simple_incidence_system_def simple_incidence_system_axioms_def by (metis nat_neq_iff) 
 
 lemma multiple_not_simple: 
   assumes "n > 1"
   assumes "\<B> \<noteq> {#}"
   shows "\<not> simple_incidence_system \<V> (multiple_blocks n)"
 proof (rule ccontr, simp)
   assume "simple_incidence_system \<V> (multiple_blocks n)"
   then have "\<And> bl. bl \<in># \<B> \<Longrightarrow> count (multiple_blocks n) bl = 1"
     using assms(1) elem_in_original_in_repeat
     by (metis not_gr_zero not_less_zero simple_incidence_system.simple)
   thus False using assms by auto 
 qed
 
 end
 
 subsection \<open>Proper Designs\<close>
 text \<open>Many types of designs rely on parameter conditions that only make sense for non-empty designs. 
 i.e. designs with at least one block, and therefore given well-formed condition, at least one point. 
 To this end we define the notion of a "proper" design\<close>
 
 locale proper_design = design + 
   assumes b_non_zero: "\<b> \<noteq> 0"
 begin
 
 lemma is_proper: "proper_design \<V> \<B>" by intro_locales
 
 lemma v_non_zero: "\<v> > 0"
   using b_non_zero v_eq0_imp_b_eq_0 by auto
 
 lemma b_positive: "\<b> > 0" using b_non_zero
   by (simp add: nonempty_has_size)
 
 lemma design_points_nempty: "\<V> \<noteq> {}"
   using v_non_zero by auto 
 
 lemma design_blocks_nempty: "\<B> \<noteq> {#}"
   using b_non_zero by auto
 
 end
 
 text \<open>Intro rules for a proper design\<close>
 lemma (in design) proper_designI[intro]: "\<b> \<noteq> 0 \<Longrightarrow> proper_design \<V> \<B>"
   by (unfold_locales) simp
 
 lemma proper_designII[intro]: 
   assumes "design V B" and "B \<noteq> {#}" 
   shows "proper_design V B"
 proof -
   interpret des: design V B using assms by simp
   show ?thesis using assms by unfold_locales simp
 qed
 
 text \<open>Reasoning on construction closure for proper designs\<close>
 context proper_design
 begin
 
 lemma multiple_proper_design: 
   assumes "n > 0"
   shows "proper_design \<V> (multiple_blocks n)"
   using multiple_is_design assms design_blocks_nempty multiple_block_in
   by (metis block_set_nempty_imp_block_ex empty_iff proper_designII set_mset_empty) 
 
 lemma complement_proper_design: 
   assumes "\<And> bl . bl \<in># \<B> \<Longrightarrow> incomplete_block bl"
   shows "proper_design \<V> \<B>\<^sup>C"
 proof -
   interpret des: design \<V> "\<B>\<^sup>C"
     by (simp add: assms complement_design)  
   show ?thesis using b_non_zero by (unfold_locales) auto
 qed
 
 end
 end
\ No newline at end of file
diff --git a/thys/Design_Theory/Design_Operations.thy b/thys/Design_Theory/Design_Operations.thy
--- a/thys/Design_Theory/Design_Operations.thy
+++ b/thys/Design_Theory/Design_Operations.thy
@@ -1,528 +1,528 @@
 theory Design_Operations imports Design_Basics
 begin
 
 section \<open>Design Operations\<close>
 text \<open>Incidence systems have a number of very typical computational operations
 which can be used for constructions in design theory. Definitions in this section are based off
 the handbook of combinatorial designs, hypergraph theory \cite{bergeHypergraphsCombinatoricsFinite1989}, 
 and the GAP design theory library \cite{soicherDesignsGroupsComputing2013}\<close>
 
 subsection \<open>Incidence system definitions\<close>
 
 context incidence_system
 begin
 
 text \<open>The basic add point operation only affects the point set of a design\<close>
 definition add_point :: "'a \<Rightarrow> 'a set" where
 "add_point p \<equiv> insert p \<V>"
 
 lemma add_existing_point [simp]: "p \<in> \<V> \<Longrightarrow> add_point p = \<V>"
   using add_point_def by fastforce
 
 lemma add_point_wf: "incidence_system (add_point p) \<B>"
   using wf_invalid_point add_point_def by (unfold_locales) (auto)
 
 text \<open>An extension of the basic add point operation also adds the point to a given set of blocks\<close>
 definition add_point_to_blocks :: "'a \<Rightarrow> 'a set set \<Rightarrow> 'a set multiset" where
 "add_point_to_blocks p bs \<equiv> {# (insert p b) | b \<in># \<B> . b \<in> bs#} + {# b \<in># \<B> . b \<notin> bs#}"
 
 lemma add_point_blocks_blocks_alt: "add_point_to_blocks p bs = 
     image_mset (insert p) (filter_mset (\<lambda> b . b \<in> bs) \<B>) + (filter_mset (\<lambda> b . b \<notin> bs) \<B>)"
   using add_point_to_blocks_def by simp
 
 lemma add_point_existing_blocks: 
   assumes "(\<And> bl . bl \<in> bs \<Longrightarrow> p \<in> bl)" 
   shows "add_point_to_blocks p bs = \<B>"
 proof (simp add: add_point_to_blocks_def)
   have "image_mset (insert p) {#b \<in># \<B>. b \<in> bs#} = {#b \<in># \<B>. b \<in> bs#}" using assms
     by (simp add: image_filter_cong insert_absorb) 
   thus "image_mset (insert p) {#b \<in># \<B>. b \<in> bs#} + {#b \<in># \<B>. b \<notin> bs#} = \<B>" 
     using multiset_partition by simp 
 qed
 
 lemma add_new_point_rep_number: 
   assumes "p \<notin> \<V>"
   shows "(add_point_to_blocks p bs) rep p = size {#b \<in># \<B> . b \<in> bs#}"
 proof -
   have "\<And> b. b \<in># \<B> \<Longrightarrow> b \<notin> bs \<Longrightarrow> p \<notin> b"
     by (simp add: assms wf_invalid_point) 
   then have zero: "{# b \<in># \<B> . b \<notin> bs#} rep p = 0"
     by (simp add: filter_mset_empty_conv point_replication_number_def)
   have "(add_point_to_blocks p bs) rep p = {# (insert p b) | b \<in># \<B> . b \<in> bs#} rep p + {# b \<in># \<B> . b \<notin> bs#} rep p"
     by (simp add: add_point_to_blocks_def)
   then have eq: "(add_point_to_blocks p bs) rep p = {# (insert p b) | b \<in># \<B> . b \<in> bs#} rep p"
     using zero by simp
   have "\<And> bl . bl \<in># {# (insert p b) | b \<in># \<B> . b \<in> bs#} \<Longrightarrow> p \<in> bl" by auto
   then have "{# (insert p b) | b \<in># \<B> . b \<in> bs#} rep p = size {# (insert p b) | b \<in># \<B> . b \<in> bs#}"
     using point_replication_number_def by (metis filter_mset_True filter_mset_cong) 
   thus ?thesis by (simp add: eq) 
 qed
 
 lemma add_point_blocks_wf: "incidence_system (add_point p) (add_point_to_blocks p bs)"
   by (unfold_locales) (auto simp add: add_point_def wf_invalid_point add_point_to_blocks_def)
 
 text \<open>Basic (weak) delete point operation removes a point from both the point set and from any 
 blocks that contain it to maintain wellformed property\<close>
 definition del_point :: "'a \<Rightarrow> 'a set" where
 "del_point p \<equiv> \<V> - {p}" 
 
 definition del_point_blocks:: "'a \<Rightarrow> 'a set multiset" where
 "del_point_blocks p \<equiv> {# (bl - {p}) . bl \<in># \<B> #}"
 
 lemma del_point_block_count: "size (del_point_blocks p) = size \<B>"
   by (simp add: del_point_blocks_def)
 
 lemma remove_invalid_point_block: "p \<notin> \<V> \<Longrightarrow> bl \<in># \<B> \<Longrightarrow> bl - {p} = bl"
   using wf_invalid_point by blast
 
 lemma del_invalid_point: "p \<notin> \<V> \<Longrightarrow> (del_point p) = \<V>"
   by (simp add: del_point_def)
 
 lemma del_invalid_point_blocks: "p \<notin> \<V> \<Longrightarrow> (del_point_blocks p) = \<B>"
   using del_invalid_point
   by (auto simp add: remove_invalid_point_block del_point_blocks_def) 
 
 lemma delete_point_p_not_in_bl_blocks: "(\<And> bl. bl \<in># \<B> \<Longrightarrow> p \<notin> bl) \<Longrightarrow> (del_point_blocks p) = \<B>"
   by (simp add: del_point_blocks_def)
 
 lemma delete_point_blocks_wf: "b \<in># (del_point_blocks p) \<Longrightarrow> b \<subseteq> \<V> - {p}"
   unfolding del_point_blocks_def using wellformed by auto
 
 lemma delete_point_blocks_sub: 
   assumes "b \<in># (del_point_blocks p)" 
   obtains bl where "bl \<in># \<B> \<and> b \<subseteq> bl"
   using assms by (auto simp add: del_point_blocks_def)
 
 lemma delete_point_split_blocks: "del_point_blocks p = 
   {# bl \<in>#\<B> . p \<notin> bl#} + {# bl - {p} | bl \<in># \<B> . p \<in> bl#}"
 proof -
   have sm: "\<And> bl . p \<notin> bl \<Longrightarrow> bl - {p} = bl" by simp 
   have "del_point_blocks p = {# (bl - {p}) . bl \<in># \<B> #}" by (simp add: del_point_blocks_def)
   also have "... = {# (bl - {p}) | bl \<in># \<B> . p \<notin> bl #} + {# (bl - {p}) | bl \<in># \<B> . p \<in> bl #}"
     using multiset_partition by (metis image_mset_union union_commute) 
   finally have "del_point_blocks p = {#bl | bl \<in># \<B> . p \<notin> bl#} + 
       {# (bl - {p}) | bl \<in># \<B> . p \<in> bl #}"
     using sm mem_Collect_eq
     by (metis (mono_tags, lifting) Multiset.set_mset_filter  multiset.map_cong) 
   thus ?thesis by simp
 qed
 
 lemma delete_point_index_eq: 
   assumes "ps \<subseteq> (del_point p)"
   shows "(del_point_blocks p) index ps = \<B> index ps"
 proof -
   have eq: "filter_mset ((\<subseteq>) ps) {#bl - {p}. bl \<in># \<B>#} = 
       image_mset (\<lambda> b . b - {p}) (filter_mset (\<lambda> b. ps \<subseteq> b - {p}) \<B>)"
     using filter_mset_image_mset by blast
   have "p \<notin> ps" using assms del_point_def by blast 
   then have "\<And> bl . ps \<subseteq> bl \<longleftrightarrow> ps \<subseteq> bl - {p}" by blast
   then have "((filter_mset (\<lambda> b. ps \<subseteq> b - {p}) \<B>)) = (filter_mset (\<lambda> b . ps \<subseteq> b) \<B>)" by auto 
   then have "size (image_mset (\<lambda> b . b - {p}) (filter_mset (\<lambda> b. ps \<subseteq> b - {p}) \<B>)) 
       = \<B> index ps" 
     by (simp add: points_index_def) 
   thus ?thesis using eq
     by (simp add: del_point_blocks_def points_index_def) 
 qed
 
 lemma delete_point_wf: "incidence_system (del_point p) (del_point_blocks p)"
   using delete_point_blocks_wf del_point_def by (unfold_locales) auto
 
 text \<open>The concept of a strong delete point comes from hypergraph theory. When a point is deleted, 
 any blocks containing it are also deleted\<close>
 definition str_del_point_blocks :: "'a \<Rightarrow> 'a set multiset" where
 "str_del_point_blocks p \<equiv> {# bl \<in># \<B> . p \<notin> bl#}"
 
 lemma str_del_point_blocks_alt: "str_del_point_blocks p = \<B> - {# bl \<in># \<B> . p \<in> bl#}"  
   using add_diff_cancel_left' multiset_partition by (metis str_del_point_blocks_def) 
 
 lemma delete_point_strong_block_in:  "p \<notin> bl \<Longrightarrow> bl \<in># \<B>  \<Longrightarrow> bl \<in># str_del_point_blocks p"
   by (simp add: str_del_point_blocks_def)
 
 lemma delete_point_strong_block_not_in: "p \<in> bl \<Longrightarrow> bl \<notin># (str_del_point_blocks) p"
   by (simp add: str_del_point_blocks_def)
 
 lemma delete_point_strong_block_in_iff: "bl \<in># \<B> \<Longrightarrow> bl \<in># str_del_point_blocks p \<longleftrightarrow> p \<notin> bl"
   using delete_point_strong_block_in delete_point_strong_block_not_in
   by (simp add: str_del_point_blocks_def)
 
 lemma delete_point_strong_block_subset: "str_del_point_blocks p \<subseteq># \<B>"
   by (simp add: str_del_point_blocks_def)
 
 lemma delete_point_strong_block_in_orig: "bl \<in># str_del_point_blocks p \<Longrightarrow> bl \<in># \<B>"
   using delete_point_strong_block_subset by (metis mset_subset_eqD) 
 
 lemma delete_invalid_pt_strong_eq: "p \<notin> \<V> \<Longrightarrow> \<B> = str_del_point_blocks p"
   unfolding str_del_point_blocks_def using wf_invalid_point empty_iff
   by (metis Multiset.diff_cancel filter_mset_eq_conv set_mset_empty subset_mset.order_refl)
 
 lemma strong_del_point_index_alt: 
   assumes "ps \<subseteq> (del_point p)"
   shows "(str_del_point_blocks p) index ps = 
     \<B> index ps - {# bl \<in># \<B> . p \<in> bl#} index ps"
   using str_del_point_blocks_alt points_index_def
   by (metis filter_diff_mset multiset_filter_mono multiset_filter_subset  size_Diff_submset)
 
 lemma strong_del_point_incidence_wf: "incidence_system (del_point p) (str_del_point_blocks p)"
   using wellformed str_del_point_blocks_def del_point_def by (unfold_locales) auto
 
 text \<open>Add block operation\<close>
 
 definition add_block :: "'a set \<Rightarrow> 'a set multiset" where 
 "add_block b \<equiv> \<B> + {#b#}"
 
 lemma add_block_alt: "add_block b = add_mset b \<B>"
   by (simp add: add_block_def)
 
 lemma add_block_rep_number_in: 
   assumes "x \<in> b"
   shows "(add_block b) rep x = \<B> rep x + 1"
 proof -
   have "(add_block b) = {#b#} + \<B>" by (simp add: add_block_def) 
   then have split: "(add_block b) rep x = {#b#} rep x + \<B> rep x"
     by (metis point_rep_number_split)
   have "{#b#} rep x = 1" using assms by simp
   thus ?thesis using split by auto
 qed
 
 lemma add_block_rep_number_not_in: "x \<notin> b \<Longrightarrow> (add_block b) rep x = \<B> rep x"
   using point_rep_number_split add_block_alt point_rep_singleton_inval
   by (metis add.right_neutral union_mset_add_mset_right)
 
 lemma add_block_index_in: 
   assumes "ps \<subseteq> b"
   shows "(add_block b) index ps = \<B> index ps + 1"
 proof -
   have "(add_block b) = {#b#} + \<B>" by (simp add: add_block_def) 
   then have split: "(add_block b) index ps = {#b#} index ps + \<B> index ps"
     by (metis point_index_distrib)
   have "{#b#} index ps = 1" using assms points_index_singleton by auto
   thus ?thesis using split by simp
 qed
 
 lemma add_block_index_not_in: "\<not> (ps \<subseteq> b) \<Longrightarrow> (add_block b) index ps = \<B> index ps"
   using point_index_distrib points_index_singleton_zero
   by (metis add.right_neutral add_block_def)
 
 text \<open>Note the add block incidence system is defined slightly differently then textbook 
 definitions due to the modification to the point set. This ensures the operation is closed, 
 where otherwise a condition that $b \subseteq \mathcal{V}$ would be required.\<close>
 lemma add_block_wf: "incidence_system (\<V> \<union> b) (add_block b)"
   using wellformed add_block_def by (unfold_locales) auto
 
 lemma add_block_wf_cond: "b \<subseteq> \<V> \<Longrightarrow> incidence_system \<V> (add_block b)"
   using add_block_wf by (metis sup.order_iff) 
 
 text \<open>Delete block removes a block from the block set. The point set is unchanged\<close>
 definition del_block :: "'a set \<Rightarrow> 'a set multiset" where
 "del_block b \<equiv> \<B> - {#b#}"
 
 lemma delete_block_subset: "(del_block b) \<subseteq># \<B>"
   by (simp add: del_block_def)
 
 lemma delete_invalid_block_eq: "b \<notin># \<B> \<Longrightarrow> del_block b = \<B>"
   by (simp add: del_block_def)
 
 lemma delete_block_wf: "incidence_system \<V> (del_block b)"
   by (unfold_locales) (simp add: del_block_def in_diffD wellformed) 
 
 text \<open>The strong delete block operation effectively deletes the block, as well as 
 all points in that block\<close>
 definition str_del_block :: "'a set \<Rightarrow> 'a set multiset" where
 "str_del_block b \<equiv> {# bl - b | bl \<in># \<B> . bl \<noteq> b #}"
 
 lemma strong_del_block_alt_def: "str_del_block b = {# bl - b . bl \<in># removeAll_mset b \<B> #}"
   by (simp add: filter_mset_neq str_del_block_def)
 
 lemma strong_del_block_wf: "incidence_system (\<V> - b) (str_del_block b)"
   using wf_invalid_point str_del_block_def by (unfold_locales) auto
 
 lemma str_del_block_del_point: 
   assumes "{x} \<notin># \<B>"
   shows "str_del_block {x} = (del_point_blocks x)"
 proof -
   have neqx: "\<And> bl. bl \<in># \<B> \<Longrightarrow> bl \<noteq> {x}" using assms by auto
   have "str_del_block {x} = {# bl - {x} | bl \<in># \<B> . bl \<noteq> {x} #}" by (simp add: str_del_block_def)
   then have "str_del_block {x} = {# bl - {x} . bl \<in># \<B> #}" using assms neqx
     by (simp add: filter_mset_cong) 
   thus ?thesis by (simp add: del_point_blocks_def)
 qed
 
 subsection \<open>Incidence System Interpretations\<close>
 text \<open>It is easy to interpret all operations as incidence systems in there own right. 
 These can then be used to prove local properties on the new constructions, as well 
 as reason on interactions between different operation sequences\<close>
 
 interpretation add_point_sys: incidence_system "add_point p" "\<B>"
   using add_point_wf by simp
 
 lemma add_point_sys_rep_numbers: "add_point_sys.replication_numbers p = 
     replication_numbers \<union> {\<B> rep p}"
   using add_point_sys.replication_numbers_def replication_numbers_def add_point_def by auto
 
 interpretation del_point_sys: incidence_system "del_point p" "del_point_blocks p"
   using delete_point_wf by auto
 
 interpretation add_block_sys: incidence_system "\<V> \<union> bl" "add_block bl"
   using add_block_wf by simp
 
 interpretation del_block_sys: incidence_system "\<V>" "del_block bl"
   using delete_block_wf by simp 
 
 lemma add_del_block_inv: 
   assumes "bl \<subseteq> \<V>"
   shows "add_block_sys.del_block bl bl = \<B>"
   using add_block_sys.del_block_def add_block_def by simp
 
 lemma del_add_block_inv: "bl \<in># \<B> \<Longrightarrow> del_block_sys.add_block bl bl = \<B>"
   using del_block_sys.add_block_def del_block_def wellformed by fastforce
 
 lemma del_invalid_add_block_eq: "bl \<notin># \<B> \<Longrightarrow> del_block_sys.add_block bl bl = add_block bl"
   using del_block_sys.add_block_def by (simp add: delete_invalid_block_eq) 
 
 lemma add_delete_point_inv: 
   assumes "p \<notin> \<V>"
   shows "add_point_sys.del_point p p = \<V>"
 proof -
   have "(add_point_sys.del_point p p) = (insert p \<V>) - {p}"
     using add_point_sys.del_point_def del_block_sys.add_point_def by auto 
   thus ?thesis 
     by (simp add: assms) 
 qed
 end
 
 subsection \<open>Operation Closure for Designs\<close>
 
 context finite_incidence_system 
 begin
 
 lemma add_point_finite: "finite_incidence_system (add_point p) \<B>"
   using add_point_wf finite_sets add_point_def 
   by (unfold_locales) (simp_all add: incidence_system_def)
 
 lemma add_point_to_blocks_finite: "finite_incidence_system (add_point p) (add_point_to_blocks p bs)"
   using add_point_blocks_wf add_point_finite finite_incidence_system.finite_sets 
     incidence_system.finite_sysI by blast
 
 lemma delete_point_finite: 
     "finite_incidence_system (del_point p) (del_point_blocks p)"
   using finite_sets delete_point_wf 
   by (unfold_locales) (simp_all add: incidence_system_def del_point_def)
 
 lemma del_point_order: 
   assumes "p \<in> \<V>"
   shows "card (del_point p) = \<v> - 1"
 proof -
   have vg0: "card \<V> > 0" using assms finite_sets card_gt_0_iff by auto 
   then have "card (del_point p) = card \<V> - 1" using assms del_point_def
-    by (metis card_Diff_singleton finite_sets)
+    by (metis card_Diff_singleton)
   thus ?thesis
     using vg0 by linarith 
 qed
 
 lemma strong_del_point_finite:"finite_incidence_system (del_point p) (str_del_point_blocks p)"
   using strong_del_point_incidence_wf del_point_def
   by (intro_locales) (simp_all add: finite_incidence_system_axioms_def finite_sets)
 
 lemma add_block_fin: "finite b \<Longrightarrow> finite_incidence_system (\<V> \<union> b) (add_block b)"
   using wf_invalid_point finite_sets add_block_def by (unfold_locales) auto
 
 lemma add_block_fin_cond: "b \<subseteq> \<V> \<Longrightarrow> finite_incidence_system \<V> (add_block b)"
   using add_block_wf_cond finite_incidence_system_axioms.intro finite_sets
   by (intro_locales) (simp_all)
 
 lemma delete_block_fin_incidence_sys: "finite_incidence_system \<V> (del_block b)"
   using delete_block_wf finite_sets by (unfold_locales) (simp_all add: incidence_system_def)
 
 lemma strong_del_block_fin: "finite_incidence_system (\<V> - b) (str_del_block b)"
   using strong_del_block_wf finite_sets finite_incidence_system_axioms_def by (intro_locales) auto
 
 end
 
 context design
 begin
 lemma add_point_design: "design (add_point p) \<B>"
   using add_point_wf finite_sets blocks_nempty add_point_def
   by (unfold_locales) (auto simp add: incidence_system_def)
 
 lemma delete_point_design: 
   assumes "(\<And> bl . bl \<in># \<B> \<Longrightarrow> p \<in> bl \<Longrightarrow> card bl \<ge> 2)"
   shows "design (del_point p) (del_point_blocks p)"
 proof (cases "p \<in> \<V>")
   case True
   interpret fis: finite_incidence_system "(del_point p)" "(del_point_blocks p)" 
     using delete_point_finite by simp
   show ?thesis 
   proof (unfold_locales)
     show "\<And>bl. bl \<in># (del_point_blocks p) \<Longrightarrow> bl \<noteq> {}" using assms del_point_def 
     proof -
       fix bl 
       assume "bl \<in>#(del_point_blocks p)"
       then obtain bl' where block: "bl' \<in># \<B>" and rem: "bl = bl' - {p}" 
         by (auto simp add: del_point_blocks_def)
       then have eq: "p \<notin> bl' \<Longrightarrow> bl \<noteq> {}" using block blocks_nempty by (simp add: rem) 
       have "p \<in> bl' \<Longrightarrow> card bl \<ge> 1" using rem finite_blocks block assms block by fastforce  
       then show "bl \<noteq> {}" using  eq assms by fastforce 
     qed 
   qed
 next
   case False
   then show ?thesis using del_invalid_point del_invalid_point_blocks
     by (simp add: wf_design) 
 qed
 
 lemma strong_del_point_design: "design (del_point p) (str_del_point_blocks p)"
 proof -
   interpret fin: finite_incidence_system "(del_point p)" "(str_del_point_blocks p)"
     using strong_del_point_finite by simp
   show ?thesis using wf_design wf_design_iff del_point_def str_del_point_blocks_def 
     by (unfold_locales) (auto)
 qed
 
 lemma add_block_design: 
   assumes "finite bl" 
   assumes "bl \<noteq> {}" 
   shows "design (\<V> \<union> bl) (add_block bl)"
 proof - 
   interpret fin: finite_incidence_system "(\<V> \<union> bl)" "(add_block bl)" 
     using add_block_fin assms by simp
   show ?thesis using blocks_nempty assms add_block_def by (unfold_locales) auto
 qed
 
 lemma add_block_design_cond: 
   assumes "bl \<subseteq> \<V>" and "bl \<noteq> {}"
   shows "design \<V> (add_block bl)"
 proof -
   interpret fin: finite_incidence_system "\<V>" "(add_block bl)" 
     using add_block_fin_cond assms by simp
   show ?thesis using blocks_nempty assms add_block_def by (unfold_locales) auto
 qed
 
 lemma delete_block_design: "design \<V> (del_block bl)"
 proof -
   interpret fin: finite_incidence_system \<V> "(del_block bl)" 
     using delete_block_fin_incidence_sys by simp
   have "\<And> b . b \<in># (del_block bl) \<Longrightarrow> b \<noteq> {}"
     using blocks_nempty delete_block_subset by blast  
   then show ?thesis by (unfold_locales) (simp_all)
 qed
 
 lemma strong_del_block_des: 
   assumes "\<And> bl . bl \<in># \<B> \<Longrightarrow> \<not> (bl \<subset> b)"
   shows "design (\<V> - b) (str_del_block b)"
 proof -
   interpret fin: finite_incidence_system "\<V> - b" "(str_del_block b)"
     using strong_del_block_fin by simp
   show ?thesis using assms str_del_block_def by (unfold_locales) auto
 qed
 
 end
 
 context proper_design
 begin
 lemma delete_point_proper: 
   assumes "\<And>bl. bl \<in># \<B> \<Longrightarrow> p \<in> bl \<Longrightarrow> 2 \<le> card bl"
   shows "proper_design (del_point p) (del_point_blocks p)"
 proof -
   interpret des: design "del_point p" "del_point_blocks p"
     using delete_point_design assms by blast 
   show ?thesis using design_blocks_nempty del_point_def del_point_blocks_def 
     by (unfold_locales) simp
 qed
 
 lemma strong_delete_point_proper: 
   assumes "\<And>bl. bl \<in># \<B> \<Longrightarrow> p \<in> bl \<Longrightarrow> 2 \<le> card bl"
   assumes "\<B> rep p < \<b>"
   shows "proper_design (del_point p) (str_del_point_blocks p)"
 proof -
   interpret des: design "del_point p" "str_del_point_blocks p"
     using strong_del_point_design assms by blast 
   show ?thesis using assms design_blocks_nempty point_rep_num_inv_non_empty 
     str_del_point_blocks_def del_point_def by (unfold_locales) simp
 qed
 
 end
 
 subsection \<open>Combining Set Systems\<close>
 text \<open>Similar to multiple, another way to construct a new set system is to combine two existing ones.
 We introduce a new locale enabling us to reason on two different incidence systems\<close>
 locale two_set_systems = sys1: incidence_system \<V> \<B> + sys2: incidence_system \<V>' \<B>'
   for \<V> :: "('a set)" and \<B> and \<V>' :: "('a set)" and \<B>'
 begin 
 
 abbreviation "combine_points \<equiv> \<V> \<union> \<V>'" 
 
 notation combine_points ("\<V>\<^sup>+")
 
 abbreviation "combine_blocks \<equiv> \<B> + \<B>'"
 
 notation combine_blocks ("\<B>\<^sup>+")
 
 sublocale combine_sys: incidence_system "\<V>\<^sup>+" "\<B>\<^sup>+"
   using sys1.wellformed sys2.wellformed by (unfold_locales) auto
 
 lemma combine_points_index: "\<B>\<^sup>+ index ps = \<B> index ps  + \<B>' index ps"
   by (simp add: point_index_distrib)
 
 lemma combine_rep_number: "\<B>\<^sup>+ rep x = \<B> rep x + \<B>' rep x"
   by (simp add: point_replication_number_def)
 
 lemma combine_multiple1: "\<V> = \<V>' \<Longrightarrow> \<B> = \<B>' \<Longrightarrow> \<B>\<^sup>+ = sys1.multiple_blocks 2"
   by auto
 
 lemma combine_multiple2: "\<V> = \<V>' \<Longrightarrow> \<B> = \<B>' \<Longrightarrow> \<B>\<^sup>+ = sys2.multiple_blocks 2"
   by auto
 
 lemma combine_multiplicity: "combine_sys.multiplicity b = sys1.multiplicity b + sys2.multiplicity b"
   by simp
 
 lemma combine_block_sizes: "combine_sys.sys_block_sizes = 
     sys1.sys_block_sizes \<union> sys2.sys_block_sizes"
   using sys1.sys_block_sizes_def sys2.sys_block_sizes_def combine_sys.sys_block_sizes_def by (auto)
 
 end
 
 locale two_fin_set_systems = two_set_systems \<V> \<B> \<V>' \<B>' + sys1: finite_incidence_system \<V> \<B> + 
   sys2: finite_incidence_system \<V>' \<B>' for \<V> \<B> \<V>' \<B>'
 begin
   
 
 sublocale combine_fin_sys: finite_incidence_system "\<V>\<^sup>+" "\<B>\<^sup>+"
   using sys1.finite_sets sys2.finite_sets by (unfold_locales) (simp)
 
 lemma combine_order: "card (\<V>\<^sup>+) \<ge> card \<V>"
   by (meson Un_upper1 card_mono combine_fin_sys.finite_sets)
 
 lemma  combine_order_2: "card (\<V>\<^sup>+) \<ge> card \<V>'"
   by (meson Un_upper2 card_mono combine_fin_sys.finite_sets) 
 
 end
 
 locale two_designs = two_fin_set_systems \<V> \<B> \<V>' \<B>' + des1: design \<V> \<B> + 
   des2: design \<V>' \<B>' for \<V> \<B> \<V>' \<B>'
 begin
 
 sublocale combine_des: design "\<V>\<^sup>+" "\<B>\<^sup>+"
   apply (unfold_locales)
   using des1.blocks_nempty_alt des2.blocks_nempty_alt by fastforce
 
 end
 
 locale two_designs_proper = two_designs + 
   assumes blocks_nempty: "\<B> \<noteq> {#} \<or> \<B>' \<noteq> {#}"
 begin
 
 lemma des1_is_proper: "\<B> \<noteq> {#} \<Longrightarrow> proper_design \<V> \<B>"
   by (unfold_locales) (simp)
 
 lemma des2_is_proper: "\<B>' \<noteq> {#} \<Longrightarrow> proper_design \<V>' \<B>'"
   by (unfold_locales) (simp)
 
 lemma min_one_proper_design: "proper_design \<V> \<B> \<or> proper_design \<V>' \<B>'"
   using blocks_nempty des1_is_proper des2_is_proper by (unfold_locales, blast)
 
 sublocale combine_proper_des: proper_design "\<V>\<^sup>+" "\<B>\<^sup>+"
   apply (unfold_locales)
-  by (metis blocks_nempty of_nat_0_eq_iff size_eq_0_iff_empty subset_mset.zero_eq_add_iff_both_eq_0)
+  by (metis blocks_nempty size_eq_0_iff_empty subset_mset.zero_eq_add_iff_both_eq_0)
 end
 
 end
\ No newline at end of file
diff --git a/thys/Design_Theory/Designs_And_Graphs.thy b/thys/Design_Theory/Designs_And_Graphs.thy
--- a/thys/Design_Theory/Designs_And_Graphs.thy
+++ b/thys/Design_Theory/Designs_And_Graphs.thy
@@ -1,336 +1,336 @@
 (* Title: Designs_And_Graphs.thy
    Author: Chelsea Edmonds 
 *)
 
 section \<open>Graphs and Designs\<close>
 text \<open>There are many links between graphs and design - most fundamentally that graphs are designs\<close>
 
 theory Designs_And_Graphs imports Block_Designs Graph_Theory.Digraph Graph_Theory.Digraph_Component
 begin
 
 subsection \<open>Non-empty digraphs\<close>
 text \<open>First, we define the concept of a non-empty digraph. This mirrors the idea of a "proper design"
 in the design theory library\<close>
 locale non_empty_digraph = wf_digraph + 
   assumes arcs_not_empty: "arcs G \<noteq> {}"
 
 begin 
 
 lemma verts_not_empty: "verts G \<noteq> {}"
   using wf arcs_not_empty head_in_verts by fastforce 
 
 end
 
 subsection \<open>Arcs to Blocks\<close>
 text \<open>A digraph uses a pair of points to define an ordered edge. In the case of simple graphs, 
 both possible orderings will be in the arcs set. Blocks are inherently unordered, and as such 
 a method is required to convert between the two representations\<close>
 context graph
 begin
 
 definition arc_to_block :: "'b \<Rightarrow> 'a set" where
   "arc_to_block e \<equiv> {tail G e, head G e}"
 
 lemma arc_to_block_to_ends: "{fst (arc_to_ends G e), snd (arc_to_ends G e)} = arc_to_block e"
   by (simp add: arc_to_ends_def arc_to_block_def)
 
 lemma arc_to_block_to_ends_swap: "{snd (arc_to_ends G e), fst (arc_to_ends G e)} = arc_to_block e"
   using arc_to_block_to_ends
   by (simp add: arc_to_block_to_ends insert_commute) 
 
 lemma arc_to_ends_to_block: "arc_to_block e = {x, y} \<Longrightarrow> 
   arc_to_ends G e = (x, y) \<or> arc_to_ends G e = (y, x)"
   by (metis arc_to_block_def arc_to_ends_def doubleton_eq_iff)
 
 lemma arc_to_block_sym: "arc_to_ends G e1 = (u, v) \<Longrightarrow> arc_to_ends G e2 = (v, u) \<Longrightarrow> 
   arc_to_block e1 = arc_to_block e2"
   by (simp add: arc_to_block_def arc_to_ends_def insert_commute)
 
 definition arcs_blocks :: "'a set multiset" where
 "arcs_blocks \<equiv> mset_set (arc_to_block ` (arcs G))"
 
 lemma  arcs_blocks_ends: "(x, y) \<in> arcs_ends G \<Longrightarrow> {x, y} \<in># arcs_blocks"
 proof (auto simp add: arcs_ends_def arcs_blocks_def )
   fix xa
   assume assm1: "(x, y) = arc_to_ends G xa" and assm2: "xa \<in> arcs G"
   obtain z where zin: "z \<in> (arc_to_block ` (arcs G))" and "z = arc_to_block xa"
     using assm2 by blast 
   thus "{x, y} \<in> arc_to_block ` (arcs G)" using assm1 arc_to_block_to_ends
     by (metis fst_conv snd_conv) 
 qed
 
 lemma arc_ends_blocks_subset: "E \<subseteq> arcs G \<Longrightarrow> (x, y) \<in> ((arc_to_ends G) ` E) \<Longrightarrow> 
   {x, y} \<in> (arc_to_block ` E)"
   by (auto simp add: arc_to_ends_def arc_to_block_def )
 
 lemma arc_blocks_end_subset: assumes "E \<subseteq> arcs G"  and "{x, y} \<in> (arc_to_block ` E)"
   shows "(x, y) \<in> ((arc_to_ends G) ` E) \<or> (y, x) \<in> ((arc_to_ends G) ` E)"
 proof -
   obtain e where "e \<in> E" and "arc_to_block e = {x,y}" using assms
     by fastforce 
   then have "arc_to_ends G e = (x, y) \<or> arc_to_ends G e = (y, x)" 
     using arc_to_ends_to_block by simp
   thus ?thesis
     by (metis \<open>e \<in> E\<close> image_iff) 
 qed
 
 lemma arcs_ends_blocks: "{x, y} \<in># arcs_blocks \<Longrightarrow> (x, y) \<in> arcs_ends G \<and> (y, x) \<in> arcs_ends G"
 proof (auto simp add: arcs_ends_def arcs_blocks_def )
   fix xa
   assume assm1: "{x, y} = arc_to_block  xa" and assm2: "xa \<in> (arcs G)"
   obtain z where zin: "z \<in> (arc_to_ends G ` (arcs G))" and "z = arc_to_ends G xa"
     using assm2 by blast
   then have "z = (x, y) \<or> z = (y, x)" using arc_to_block_to_ends assm1
     by (metis arc_to_ends_def doubleton_eq_iff fst_conv snd_conv) (* Slow *)
   thus "(x, y) \<in> arc_to_ends G ` (arcs G)" using assm2
     by (metis arcs_ends_def arcs_ends_symmetric sym_arcs zin) 
 next 
   fix xa
   assume assm1: "{x, y} = arc_to_block  xa" and assm2: "xa \<in> (arcs G)"
   thus "(y, x) \<in> arc_to_ends G ` arcs G" using arcs_ends_def
     by (metis dual_order.refl graph.arc_blocks_end_subset graph_axioms graph_symmetric imageI)
 qed
 
 lemma arcs_blocks_iff: "{x, y} \<in># arcs_blocks \<longleftrightarrow> (x, y) \<in> arcs_ends G \<and> (y, x) \<in> arcs_ends G"
   using arcs_ends_blocks arcs_blocks_ends by blast 
 
 lemma arcs_ends_wf: "(x, y) \<in> arcs_ends G \<Longrightarrow> x \<in> verts G \<and> y \<in> verts G"
   by auto
 
 lemma arcs_blocks_elem: "bl \<in># arcs_blocks \<Longrightarrow> \<exists> x y . bl = {x, y}"
   apply (auto simp add: arcs_blocks_def)
   by (meson arc_to_block_def)
 
 lemma arcs_ends_blocks_wf: 
   assumes "bl \<in># arcs_blocks" 
   shows "bl \<subseteq> verts G"
 proof - 
   obtain x y where blpair: "bl = {x, y}" using arcs_blocks_elem assms
     by fastforce 
   then have "(x, y) \<in> arcs_ends G" using arcs_ends_blocks assms by simp
   thus ?thesis using arcs_ends_wf blpair by auto
 qed
 
 lemma arcs_blocks_simple: "bl \<in># arcs_blocks \<Longrightarrow> count (arcs_blocks) bl = 1"
   by (simp add: arcs_blocks_def)
 
 lemma arcs_blocks_ne: "arcs G \<noteq> {} \<Longrightarrow> arcs_blocks \<noteq> {#}"
   by (simp add: arcs_blocks_iff arcs_blocks_def mset_set_empty_iff)
 
 end
 
 subsection \<open>Graphs are designs\<close>
 
 text \<open>Prove that a graph is a number of different types of designs\<close>
 sublocale graph \<subseteq> design "verts G" "arcs_blocks"
   using arcs_ends_blocks_wf arcs_blocks_elem by (unfold_locales) (auto)
 
 sublocale graph \<subseteq> simple_design "verts G" "arcs_blocks"
   using arcs_ends_blocks_wf arcs_blocks_elem arcs_blocks_simple by (unfold_locales) (auto)
 
 locale non_empty_graph = graph + non_empty_digraph
 
 sublocale non_empty_graph \<subseteq> proper_design "verts G" "arcs_blocks"
   using arcs_blocks_ne arcs_not_empty by (unfold_locales) simp
 
 lemma (in graph) graph_block_size: assumes "bl \<in># arcs_blocks" shows "card bl = 2"
 proof -
   obtain x y where blrep: "bl = {x, y}" using assms arcs_blocks_elem
     by fastforce 
   then have "(x, y) \<in> arcs_ends G" using arcs_ends_blocks assms by simp
   then have "x \<noteq> y" using no_loops using adj_not_same by blast
   thus ?thesis using blrep by simp 
 qed
 
 sublocale non_empty_graph \<subseteq> block_design "verts G" "arcs_blocks" 2
   using arcs_not_empty graph_block_size arcs_blocks_ne by (unfold_locales) simp_all
 
 subsection \<open>R-regular graphs\<close>
 text \<open>To reason on r-regular graphs and their link to designs, we require a number of extensions to 
 lemmas reasoning around the degrees of vertices\<close>
 context sym_digraph
 begin
 
 lemma in_out_arcs_reflexive: "v \<in> verts G \<Longrightarrow> (e \<in> (in_arcs G v) \<Longrightarrow> 
     \<exists> e' . (e' \<in> (out_arcs G v) \<and> head G e' = tail G e))"
   using symmetric_conv sym_arcs by fastforce 
 
 lemma out_in_arcs_reflexive: "v \<in> verts G \<Longrightarrow> (e \<in> (out_arcs G v) \<Longrightarrow> 
     \<exists> e' . (e' \<in> (in_arcs G v) \<and> tail G e' = head G e))"
   using symmetric_conv sym_arcs by fastforce 
 
 end
 
 context nomulti_digraph
 begin
 
 lemma in_arcs_single_per_vert: 
   assumes "v \<in> verts G" and "u \<in> verts G"
   assumes "e1 \<in> in_arcs G v" and " e2 \<in> in_arcs G v" 
   assumes "tail G e1 = u" and "tail G e2 = u"
   shows "e1 = e2"
 proof -
   have in_arcs1: "e1 \<in> arcs G" and in_arcs2: "e2 \<in> arcs G" using assms by auto
   have "arc_to_ends G e1 = arc_to_ends G e2" using assms arc_to_ends_def
     by (metis in_in_arcs_conv) 
   thus ?thesis using in_arcs1 in_arcs2 no_multi_arcs by simp
 qed
 
 lemma out_arcs_single_per_vert: 
   assumes "v \<in> verts G" and "u \<in> verts G"
   assumes "e1 \<in> out_arcs G v" and " e2 \<in> out_arcs G v" 
   assumes "head G e1 = u" and "head G e2 = u"
   shows "e1 = e2"
 proof -
   have in_arcs1: "e1 \<in> arcs G" and in_arcs2: "e2 \<in> arcs G" using assms by auto
   have "arc_to_ends G e1 = arc_to_ends G e2" using assms arc_to_ends_def
     by (metis in_out_arcs_conv) 
   thus ?thesis using in_arcs1 in_arcs2 no_multi_arcs by simp
 qed
 
 end
 
 text \<open>Some helpers on the transformation arc definition\<close>
 context graph
 begin
 
 lemma arc_to_block_is_inj_in_arcs: "inj_on arc_to_block (in_arcs G v)"
   apply (auto simp add: arc_to_block_def inj_on_def)
   by (metis arc_to_ends_def doubleton_eq_iff no_multi_arcs)
 
 lemma arc_to_block_is_inj_out_arcs: "inj_on arc_to_block (out_arcs G v)"
   apply (auto simp add: arc_to_block_def inj_on_def)
   by (metis arc_to_ends_def doubleton_eq_iff no_multi_arcs)
 
 lemma in_out_arcs_reflexive_uniq: "v \<in> verts G \<Longrightarrow> (e \<in> (in_arcs G v) \<Longrightarrow> 
     \<exists>! e' . (e' \<in> (out_arcs G v) \<and> head G e' = tail G e))"
   apply auto
     using symmetric_conv apply fastforce
   using out_arcs_single_per_vert by (metis head_in_verts in_out_arcs_conv) 
 
 lemma out_in_arcs_reflexive_uniq: "v \<in> verts G \<Longrightarrow> e \<in> (out_arcs G v) \<Longrightarrow> 
     \<exists>! e' . (e' \<in> (in_arcs G v) \<and> tail G e' = head G e)"
   apply auto
     using symmetric_conv apply fastforce
   using in_arcs_single_per_vert by (metis tail_in_verts in_in_arcs_conv) 
 
 lemma in_eq_out_arc_ends: "(u, v) \<in> ((arc_to_ends G) ` (in_arcs G v)) \<longleftrightarrow> 
     (v, u) \<in> ((arc_to_ends G) ` (out_arcs G v))"
   using arc_to_ends_def in_in_arcs_conv in_out_arcs_conv
   by (smt (z3) Pair_inject adj_in_verts(1) dominatesI image_iff out_in_arcs_reflexive_uniq)
 
 lemma in_degree_eq_card_arc_ends: "in_degree G v = card ((arc_to_ends G) ` (in_arcs G v))"
   apply (simp add: in_degree_def)
   using  no_multi_arcs by (metis card_image in_arcs_in_arcs inj_onI)
 
 lemma in_degree_eq_card_arc_blocks: "in_degree G v = card (arc_to_block ` (in_arcs G v))"
   apply (simp add: in_degree_def)
   using no_multi_arcs arc_to_block_is_inj_in_arcs by (simp add: card_image)
 
 lemma out_degree_eq_card_arc_blocks: "out_degree G v = card (arc_to_block ` (out_arcs G v))"
   apply (simp add: out_degree_def)
   using no_multi_arcs arc_to_block_is_inj_out_arcs by (simp add: card_image) 
 
 lemma out_degree_eq_card_arc_ends: "out_degree G v = card ((arc_to_ends G) ` (out_arcs G v))"
   apply (simp add: out_degree_def)
   using no_multi_arcs by (metis card_image out_arcs_in_arcs inj_onI)
 
 lemma bij_betw_in_out_arcs: "bij_betw (\<lambda> (u, v) . (v, u)) ((arc_to_ends G) ` (in_arcs G v)) 
     ((arc_to_ends G) ` (out_arcs G v))"
   apply (auto simp add: bij_betw_def)
     apply (simp add: swap_inj_on)
    apply (metis Pair_inject arc_to_ends_def image_eqI in_eq_out_arc_ends in_in_arcs_conv)
   by (metis arc_to_ends_def imageI in_eq_out_arc_ends in_out_arcs_conv pair_imageI)
 
 lemma in_eq_out_degree: "in_degree G v = out_degree G v"
   using bij_betw_in_out_arcs bij_betw_same_card in_degree_eq_card_arc_ends 
     out_degree_eq_card_arc_ends by auto 
 
 lemma in_out_arcs_blocks: "arc_to_block ` (in_arcs G v) = arc_to_block ` (out_arcs G v)" 
 proof (auto)
   fix xa 
   assume a1: "xa \<in> arcs G" and a2: "v = head G xa"
   then have "xa \<in> in_arcs G v" by simp 
   then obtain e where out: "e \<in> out_arcs G v" and "head G e = tail G xa"
     using out_in_arcs_reflexive_uniq by force 
   then have "arc_to_ends G e = (v, tail G xa)"
     by (simp add: arc_to_ends_def)
   then have "arc_to_block xa = arc_to_block e"
     using arc_to_block_sym by (metis a2 arc_to_ends_def) 
   then show "arc_to_block xa \<in> arc_to_block ` out_arcs G (head G xa)"
     using out a2 by blast 
 next
   fix xa 
   assume a1: "xa \<in> arcs G" and a2: "v = tail G xa"
   then have "xa \<in> out_arcs G v" by simp 
   then obtain e where ina: "e \<in> in_arcs G v" and "tail G e = head G xa"
     using out_in_arcs_reflexive_uniq by force 
   then have "arc_to_ends G e = (head G xa, v)"
     by (simp add: arc_to_ends_def)
   then have "arc_to_block xa = arc_to_block e"
     using arc_to_block_sym by (metis a2 arc_to_ends_def) 
   then show "arc_to_block xa \<in> arc_to_block ` in_arcs G (tail G xa)"
     using ina a2 by blast 
 qed
 
 end
 
 text \<open>A regular digraph is defined as one where the in degree equals the out degree which in turn 
 equals some fixed integer $\mathrm{r}$\<close>
 locale regular_digraph = wf_digraph + 
-  fixes \<r> :: int
+  fixes \<r> :: nat
   assumes in_deg_r: "v \<in> verts G \<Longrightarrow> in_degree G v = \<r>"
   assumes out_deg_r: "v \<in> verts G \<Longrightarrow> out_degree G v = \<r>"
 
 locale regular_graph = graph + regular_digraph
 begin
 
 lemma rep_vertices_in_blocks [simp]: 
   assumes "x \<in> verts G"
   shows "size {# e \<in># arcs_blocks . x \<in> e #} = \<r>"
 proof - 
   have "\<And> e . e \<in> (arc_to_block ` (arcs G)) \<Longrightarrow> x \<in> e \<Longrightarrow> e \<in> (arc_to_block ` in_arcs G x)"
     using arc_to_block_def in_in_arcs_conv insert_commute insert_iff singleton_iff sym_arcs 
       symmetric_conv by fastforce
   then have "{ e \<in> (arc_to_block ` (arcs G)) . x \<in> e} =  (arc_to_block ` (in_arcs G x))" 
     using arc_to_block_def by auto
   then have "card { e \<in> (arc_to_block ` (arcs G)) . x \<in> e} = \<r>" 
     using in_deg_r in_degree_eq_card_arc_blocks assms by auto
   thus ?thesis
     using arcs_blocks_def finite_arcs by force 
 qed
 
 end
 
 text \<open>Intro rules for regular graphs\<close>
 lemma graph_in_degree_r_imp_reg[intro]: assumes "graph G"
   assumes "(\<And> v . v \<in> (verts G) \<Longrightarrow> in_degree G v = \<r>)"
   shows "regular_graph G \<r>"
 proof -
   interpret g: graph G using assms by simp
   interpret wf: wf_digraph G by (simp add: g.wf_digraph_axioms)
   show ?thesis 
     using assms(2) g.in_eq_out_degree by (unfold_locales) simp_all
 qed
 
 lemma graph_out_degree_r_imp_reg[intro]: assumes "graph G"
   assumes "(\<And> v . v \<in> (verts G) \<Longrightarrow> out_degree G v = \<r>)"
   shows "regular_graph G \<r>"
 proof -
   interpret g: graph G using assms by simp
   interpret wf: wf_digraph G by (simp add: g.wf_digraph_axioms)
   show ?thesis 
     using assms(2) g.in_eq_out_degree by (unfold_locales) simp_all
 qed
 
 text \<open>Regular graphs (non-empty) can be shown to be a constant rep design\<close>
 locale non_empty_regular_graph = regular_graph + non_empty_digraph
 
 sublocale non_empty_regular_graph \<subseteq> non_empty_graph
   by unfold_locales
 
 sublocale non_empty_regular_graph \<subseteq> constant_rep_design "verts G" "arcs_blocks" \<r>
   using arcs_blocks_ne arcs_not_empty
   by (unfold_locales)(simp_all add: point_replication_number_def)
 
 end
\ No newline at end of file
diff --git a/thys/Design_Theory/Group_Divisible_Designs.thy b/thys/Design_Theory/Group_Divisible_Designs.thy
--- a/thys/Design_Theory/Group_Divisible_Designs.thy
+++ b/thys/Design_Theory/Group_Divisible_Designs.thy
@@ -1,1091 +1,1092 @@
 (* Title: Group_Divisible_Designs.thy
    Author: Chelsea Edmonds
 *)
 
 section \<open>Group Divisible Designs\<close>
 text \<open>Definitions in this section taken from the handbook \cite{colbournHandbookCombinatorialDesigns2007}
 and Stinson \cite{stinsonCombinatorialDesignsConstructions2004}\<close>
 theory Group_Divisible_Designs imports Resolvable_Designs
 begin
 
 subsection \<open>Group design\<close>
 text \<open>We define a group design to have an additional paramater $G$ which is a partition on the point 
 set $V$. This is not defined in the handbook, but is a precursor to GDD's without index constraints\<close>
 
 locale group_design = proper_design + 
   fixes groups :: "'a set set" ("\<G>")
   assumes group_partitions: "partition_on \<V> \<G>"
   assumes groups_size: "card \<G> > 1" 
 begin
 
 lemma groups_not_empty: "\<G> \<noteq> {}"
   using groups_size by auto
 
 lemma num_groups_lt_points: "card \<G> \<le> \<v>"
   by (simp add: partition_on_le_set_elements finite_sets group_partitions) 
 
 lemma groups_disjoint: "disjoint \<G>"
   using group_partitions partition_onD2 by auto
 
 lemma groups_disjoint_pairwise: "G1 \<in> \<G> \<Longrightarrow> G2 \<in> \<G> \<Longrightarrow> G1 \<noteq> G2 \<Longrightarrow> disjnt G1 G2"
   using group_partitions partition_onD2 pairwiseD by fastforce 
 
 lemma point_in_one_group: "x \<in> G1 \<Longrightarrow> G1 \<in> \<G> \<Longrightarrow> G2 \<in> \<G> \<Longrightarrow> G1 \<noteq> G2 \<Longrightarrow> x \<notin> G2"
   using groups_disjoint_pairwise by (simp add: disjnt_iff) 
 
 lemma point_has_unique_group: "x \<in> \<V> \<Longrightarrow> \<exists>!G. x \<in> G \<and> G \<in> \<G>"
   using partition_on_partition_on_unique group_partitions
   by fastforce 
 
 lemma rep_number_point_group_one: 
   assumes "x \<in> \<V>"
   shows  "card {g \<in> \<G> . x \<in> g} = 1" 
 proof -
   obtain g' where "g' \<in> \<G>" and "x \<in> g'"
     using assms point_has_unique_group by blast 
   then have "{g \<in> \<G> . x \<in> g} = {g'}"
     using  group_partitions partition_onD4 by force 
   thus ?thesis
     by simp 
 qed
 
 lemma point_in_group: "G \<in> \<G> \<Longrightarrow> x \<in> G \<Longrightarrow> x \<in> \<V>"
   using group_partitions partition_onD1 by auto 
 
 lemma point_subset_in_group: "G \<in> \<G> \<Longrightarrow> ps \<subseteq> G \<Longrightarrow> ps \<subseteq> \<V>"
   using point_in_group by auto
 
 lemma group_subset_point_subset: "G \<in> \<G> \<Longrightarrow> G' \<subseteq> G \<Longrightarrow> ps \<subseteq> G' \<Longrightarrow> ps \<subseteq> \<V>"
   using point_subset_in_group by auto
 
 lemma groups_finite: "finite \<G>"
   using finite_elements finite_sets group_partitions by auto
 
 lemma group_elements_finite: "G \<in> \<G> \<Longrightarrow> finite G"
   using groups_finite finite_sets group_partitions
   by (meson finite_subset point_in_group subset_iff)
 
 lemma v_equals_sum_group_sizes: "\<v> = (\<Sum>G \<in> \<G>. card G)"
   using group_partitions groups_disjoint partition_onD1 card_Union_disjoint group_elements_finite 
   by fastforce 
 
 lemma gdd_min_v: "\<v> \<ge> 2"
 proof - 
   have assm: "card \<G> \<ge> 2" using groups_size by simp
   then have "\<And> G . G \<in> \<G> \<Longrightarrow> G \<noteq> {}" using partition_onD3 group_partitions by auto
   then have "\<And> G . G \<in> \<G> \<Longrightarrow> card G \<ge> 1"
     using group_elements_finite card_0_eq by fastforce 
   then have " (\<Sum>G \<in> \<G>. card G) \<ge> 2" using assm
     using sum_mono by force 
   thus ?thesis using v_equals_sum_group_sizes
     by linarith 
 qed
 
 lemma min_group_size: "G \<in> \<G> \<Longrightarrow> card G \<ge> 1"
   using partition_onD3 group_partitions
   using group_elements_finite not_le_imp_less by fastforce  
 
 lemma group_size_lt_v: 
   assumes "G \<in> \<G>"
   shows "card G < \<v>"
 proof - 
   have "(\<Sum>G' \<in> \<G>. card G') = \<v>" using gdd_min_v v_equals_sum_group_sizes
     by linarith 
   then have split_sum: "card G + (\<Sum>G' \<in> (\<G> - {G}). card G') = \<v>" using assms sum.remove
     by (metis groups_finite v_equals_sum_group_sizes) 
   have "card (\<G> - {G}) \<ge> 1" using groups_size
     by (simp add: assms groups_finite)
   then obtain G' where gin: "G' \<in> (\<G> - {G})"
     by (meson elem_exists_non_empty_set less_le_trans less_numeral_extra(1)) 
   then have "card G' \<ge> 1" using min_group_size by auto 
   then have "(\<Sum>G' \<in> (\<G> - {G}). card G') \<ge> 1"
     by (metis gin finite_Diff groups_finite leI less_one sum_eq_0_iff) 
   thus ?thesis using split_sum
     by linarith
 qed
 
 subsubsection \<open>Group Type\<close>
 
 text \<open>GDD's have a "type", which is defined by a sequence of group sizes $g_i$, and the number 
 of groups of that size $a_i$: $g_1^{a_1}g2^{a_2}...g_n^{a_n}$\<close>
 definition group_sizes :: "nat set" where
 "group_sizes \<equiv> {card G | G . G \<in> \<G>}"
 
 definition groups_of_size :: "nat \<Rightarrow> nat" where
 "groups_of_size g \<equiv> card { G \<in> \<G> . card G = g }"
 
 definition group_type :: "(nat \<times> nat) set" where
 "group_type \<equiv> {(g, groups_of_size g) | g . g \<in> group_sizes }"
 
 lemma group_sizes_min: "x \<in> group_sizes \<Longrightarrow> x \<ge> 1 " 
   unfolding group_sizes_def using min_group_size group_size_lt_v by auto 
 
 lemma group_sizes_max: "x \<in> group_sizes \<Longrightarrow> x < \<v> " 
   unfolding group_sizes_def using min_group_size group_size_lt_v by auto 
 
 lemma group_size_implies_group_existance: "x \<in> group_sizes \<Longrightarrow> \<exists>G. G \<in> \<G> \<and> card G = x"
   unfolding group_sizes_def by auto
 
 lemma groups_of_size_zero: "groups_of_size 0 = 0"
 proof -
   have empty: "{G \<in> \<G> . card G = 0} = {}" using min_group_size
     by fastforce 
   thus ?thesis unfolding groups_of_size_def
     by (simp add: empty) 
 qed
 
 lemma groups_of_size_max: 
   assumes "g \<ge> \<v>"
   shows "groups_of_size g = 0"
 proof -
   have "{G \<in> \<G> . card G = g} = {}" using group_size_lt_v assms by fastforce 
   thus ?thesis unfolding groups_of_size_def
     by (simp add: \<open>{G \<in> \<G>. card G = g} = {}\<close>) 
 qed
 
 lemma group_type_contained_sizes: "(g, a) \<in> group_type \<Longrightarrow> g \<in> group_sizes" 
   unfolding group_type_def by simp
 
 lemma group_type_contained_count: "(g, a) \<in> group_type \<Longrightarrow> card {G \<in> \<G> . card G = g} = a"
   unfolding group_type_def groups_of_size_def by simp
 
 lemma group_card_in_sizes: "g \<in> \<G> \<Longrightarrow> card g \<in> group_sizes"
   unfolding group_sizes_def by auto
 
 lemma group_card_non_zero_groups_of_size_min: 
   assumes "g \<in> \<G>"
   assumes "card g = a"
   shows "groups_of_size a \<ge> 1"
 proof - 
   have "g \<in> {G \<in> \<G> . card G = a}" using assms by simp
   then have "{G \<in> \<G> . card G = a} \<noteq> {}" by auto
   then have "card {G \<in> \<G> . card G = a} \<noteq> 0"
     by (simp add: groups_finite) 
   thus ?thesis unfolding groups_of_size_def by simp 
 qed
 
 lemma elem_in_group_sizes_min_of_size: 
   assumes "a \<in> group_sizes"
   shows "groups_of_size a \<ge> 1"
   using assms group_card_non_zero_groups_of_size_min group_size_implies_group_existance by blast
 
 lemma group_card_non_zero_groups_of_size_max: 
   shows "groups_of_size a \<le> \<v>"
 proof -
   have "{G \<in> \<G> . card G = a} \<subseteq> \<G>" by simp
   then have "card {G \<in> \<G> . card G = a} \<le> card \<G>"
     by (simp add: card_mono groups_finite)
   thus ?thesis
     using groups_of_size_def num_groups_lt_points by auto 
 qed
 
 lemma group_card_in_type: "g \<in> \<G> \<Longrightarrow> \<exists> x . (card g, x) \<in> group_type \<and> x \<ge> 1"
   unfolding group_type_def using group_card_non_zero_groups_of_size_min
   by (simp add: group_card_in_sizes)
 
 lemma partition_groups_on_size: "partition_on \<G> {{ G \<in> \<G> . card G = g } | g . g \<in> group_sizes}"
 proof (intro partition_onI, auto)
   fix g
   assume a1: "g \<in> group_sizes"
   assume " \<forall>x. x \<in> \<G> \<longrightarrow> card x \<noteq> g"
   then show False using a1 group_size_implies_group_existance by auto 
 next
   fix x
   assume "x \<in> \<G>"
   then show "\<exists>xa. (\<exists>g. xa = {G \<in> \<G>. card G = g} \<and> g \<in> group_sizes) \<and> x \<in> xa"
     using  group_card_in_sizes by auto 
 qed
 
 lemma group_size_partition_covers_points: "\<Union>(\<Union>{{ G \<in> \<G> . card G = g } | g . g \<in> group_sizes}) = \<V>"
   by (metis (no_types, lifting) group_partitions partition_groups_on_size partition_onD1)
 
 lemma groups_of_size_alt_def_count: "groups_of_size g = count {# card G . G \<in># mset_set \<G> #} g" 
 proof -
   have a: "groups_of_size g =  card { G \<in> \<G> . card G = g }" unfolding groups_of_size_def by simp
   then have "groups_of_size g =  size {# G \<in># (mset_set \<G>) . card G = g #}"
     using groups_finite by auto 
   then have size_repr: "groups_of_size g =  size {# x \<in># {# card G . G \<in># mset_set \<G> #} . x = g #}"
     using groups_finite by (simp add: filter_mset_image_mset)
   have "group_sizes = set_mset ({# card G . G \<in># mset_set \<G> #})" 
     using group_sizes_def groups_finite by auto 
   thus ?thesis using size_repr by (simp add: count_size_set_repr) 
 qed
 
 lemma v_sum_type_rep: "\<v> = (\<Sum> g \<in> group_sizes . g * (groups_of_size g))"
 proof -
   have gs: "set_mset {# card G . G \<in># mset_set \<G> #} = group_sizes" 
     unfolding group_sizes_def using groups_finite by auto 
   have "\<v> = card (\<Union>(\<Union>{{ G \<in> \<G> . card G = g } | g . g \<in> group_sizes}))"
     using group_size_partition_covers_points by simp
   have v1: "\<v> = (\<Sum>x \<in># {# card G . G \<in># mset_set \<G> #}. x)"
     by (simp add: sum_unfold_sum_mset v_equals_sum_group_sizes)
   then have "\<v> = (\<Sum>x \<in> set_mset {# card G . G \<in># mset_set \<G> #} . x * (count {# card G . G \<in># mset_set \<G> #} x))" 
     using mset_set_size_card_count by (simp add: v1)
   thus ?thesis using gs groups_of_size_alt_def_count by auto 
 qed
 
 end
 
 subsubsection \<open>Uniform Group designs\<close>
 text \<open>A group design requiring all groups are the same size\<close>
 locale uniform_group_design = group_design + 
   fixes u_group_size :: nat ("\<m>")
   assumes uniform_groups: "G \<in> \<G> \<Longrightarrow> card G = \<m>"
 
 begin
 
 lemma m_positive: "\<m> \<ge> 1"
 proof -
   obtain G where "G \<in> \<G>" using groups_size elem_exists_non_empty_set gr_implies_not_zero by blast 
   thus ?thesis using uniform_groups min_group_size by fastforce
 qed
 
 lemma uniform_groups_alt: " \<forall> G \<in> \<G> . card G = \<m>"
   using uniform_groups by blast 
 
 lemma uniform_groups_group_sizes: "group_sizes = {\<m>}"
   using design_points_nempty group_card_in_sizes group_size_implies_group_existance 
     point_has_unique_group uniform_groups_alt by force
 
 lemma uniform_groups_group_size_singleton: "is_singleton (group_sizes)"
   using uniform_groups_group_sizes by auto
 
 lemma set_filter_eq_P_forall:"\<forall> x \<in> X . P x \<Longrightarrow> Set.filter P X = X"
   by (simp add: Collect_conj_eq Int_absorb2 Set.filter_def subsetI)
 
 lemma uniform_groups_groups_of_size_m: "groups_of_size \<m> = card \<G>"
 proof(simp add: groups_of_size_def)
   have "{G \<in> \<G>. card G = \<m>} = \<G>" using uniform_groups_alt set_filter_eq_P_forall by auto
   thus "card {G \<in> \<G>. card G = \<m>} = card \<G>" by simp
 qed
 
 lemma uniform_groups_of_size_not_m: "x \<noteq> \<m> \<Longrightarrow> groups_of_size x = 0"
   by (simp add: groups_of_size_def card_eq_0_iff uniform_groups)
 
 end
 
 subsection \<open>GDD\<close>
 text \<open>A GDD extends a group design with an additional index parameter.
 Each pair of elements must occur either \Lambda times if in diff groups, or 0 times if in the same 
 group\<close>
 
 locale GDD = group_design + 
   fixes index :: int ("\<Lambda>")
   assumes index_ge_1: "\<Lambda> \<ge> 1"
   assumes index_together: "G \<in> \<G> \<Longrightarrow> x \<in> G \<Longrightarrow> y \<in> G \<Longrightarrow> x \<noteq> y \<Longrightarrow> \<B> index {x, y} = 0"
   assumes index_distinct: "G1 \<in> \<G> \<Longrightarrow> G2 \<in> \<G> \<Longrightarrow> G1 \<noteq> G2 \<Longrightarrow> x \<in> G1 \<Longrightarrow> y \<in> G2 \<Longrightarrow> 
     \<B> index {x, y} = \<Lambda>"
 begin
 
 lemma points_sep_groups_ne: "G1 \<in> \<G> \<Longrightarrow> G2 \<in> \<G> \<Longrightarrow> G1 \<noteq> G2 \<Longrightarrow> x \<in> G1 \<Longrightarrow> y \<in> G2 \<Longrightarrow> x \<noteq> y"
   by (meson point_in_one_group)
 
 lemma index_together_alt_ss: "ps \<subseteq> G \<Longrightarrow> G \<in> \<G> \<Longrightarrow> card ps = 2 \<Longrightarrow> \<B> index ps = 0"
   using index_together by (metis card_2_iff insert_subset) 
 
 lemma index_distinct_alt_ss: "ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> (\<And> G . G \<in> \<G> \<Longrightarrow> \<not> ps \<subseteq> G) \<Longrightarrow> 
     \<B> index ps = \<Lambda>"
   using index_distinct by (metis card_2_iff empty_subsetI insert_subset point_has_unique_group) 
 
 lemma gdd_index_options: "ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> \<B> index ps = 0 \<or> \<B> index ps = \<Lambda>"
   using index_distinct_alt_ss index_together_alt_ss by blast
 
 lemma index_zero_implies_same_group: "ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> \<B> index ps = 0 \<Longrightarrow> 
     \<exists> G \<in> \<G> . ps \<subseteq> G" using index_distinct_alt_ss gr_implies_not_zero
   by (metis index_ge_1 less_one of_nat_0 of_nat_1 of_nat_le_0_iff)
 
 lemma index_zero_implies_same_group_unique: "ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> \<B> index ps = 0 \<Longrightarrow> 
     \<exists>! G \<in> \<G> . ps \<subseteq> G" 
   by (meson GDD.index_zero_implies_same_group GDD_axioms card_2_iff' group_design.point_in_one_group 
       group_design_axioms in_mono)
 
 lemma index_not_zero_impl_diff_group: "ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> \<B> index ps = \<Lambda> \<Longrightarrow>  
     (\<And> G . G \<in> \<G> \<Longrightarrow> \<not> ps \<subseteq> G)"
   using index_ge_1 index_together_alt_ss by auto
 
 lemma index_zero_implies_one_group: 
   assumes "ps \<subseteq> \<V>" 
   and "card ps = 2" 
   and "\<B> index ps = 0" 
   shows "size {#b \<in>#  mset_set \<G> . ps \<subseteq> b#} = 1"
 proof -
   obtain G where ging: "G \<in> \<G>" and psin: "ps \<subseteq> G" 
     using index_zero_implies_same_group groups_size assms by blast
   then have unique: "\<And> G2 . G2 \<in> \<G> \<Longrightarrow> G \<noteq> G2 \<Longrightarrow> \<not> ps \<subseteq> G2" 
     using index_zero_implies_same_group_unique by (metis assms) 
   have "\<And> G'. G' \<in> \<G> \<longleftrightarrow> G' \<in># mset_set \<G>"
     by (simp add: groups_finite) 
   then have eq_mset: "{#b \<in>#  mset_set \<G> . ps \<subseteq> b#} = mset_set {b \<in> \<G> . ps \<subseteq> b}"
     using filter_mset_mset_set groups_finite by blast 
   then have "{b \<in> \<G> . ps \<subseteq> b} = {G}" using unique psin
     by (smt Collect_cong ging singleton_conv)
   thus ?thesis by (simp add: eq_mset) 
 qed
 
 lemma index_distinct_group_num_alt_def: "ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> 
     size {#b \<in>#  mset_set \<G> . ps \<subseteq> b#} = 0 \<Longrightarrow> \<B> index ps = \<Lambda>"
   by (metis gdd_index_options index_zero_implies_one_group numeral_One zero_neq_numeral)
 
 lemma index_non_zero_implies_no_group: 
   assumes "ps \<subseteq> \<V>" 
     and  "card ps = 2" 
     and "\<B> index ps = \<Lambda>" 
   shows "size {#b \<in>#  mset_set \<G> . ps \<subseteq> b#} = 0"
 proof -
   have "\<And> G . G \<in> \<G> \<Longrightarrow>  \<not> ps \<subseteq> G" using index_not_zero_impl_diff_group assms by simp
   then have "{#b \<in>#  mset_set \<G> . ps \<subseteq> b#} = {#}"
     using filter_mset_empty_if_finite_and_filter_set_empty by force
   thus ?thesis by simp
 qed
 
 lemma gdd_index_non_zero_iff: "ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> 
     \<B> index ps = \<Lambda> \<longleftrightarrow> size {#b \<in>#  mset_set \<G> . ps \<subseteq> b#} = 0"
   using index_non_zero_implies_no_group index_distinct_group_num_alt_def by auto
 
 lemma gdd_index_zero_iff: "ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> 
     \<B> index ps = 0 \<longleftrightarrow> size {#b \<in>#  mset_set \<G> . ps \<subseteq> b#} = 1"
   apply (auto simp add: index_zero_implies_one_group)
   by (metis GDD.gdd_index_options GDD_axioms index_non_zero_implies_no_group old.nat.distinct(2))
 
 lemma points_index_upper_bound: "ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> \<B> index ps \<le> \<Lambda>"
   using gdd_index_options index_ge_1
   by (metis int_one_le_iff_zero_less le_refl of_nat_0 of_nat_0_le_iff of_nat_le_iff zero_less_imp_eq_int) 
 
 lemma index_1_imp_mult_1: 
   assumes "\<Lambda> = 1"
   assumes "bl \<in># \<B>"
   assumes "card bl \<ge> 2"
   shows "multiplicity bl = 1"
 proof (rule ccontr)
   assume "\<not> (multiplicity bl = 1)"
   then have "multiplicity bl \<noteq> 1" and "multiplicity bl \<noteq> 0" using assms by simp_all 
   then have m: "multiplicity bl \<ge> 2" by linarith
   obtain ps where ps: "ps \<subseteq> bl \<and> card ps = 2"
     using nat_int_comparison(3) obtain_subset_with_card_n by (metis assms(3))  
   then have "\<B> index ps \<ge> 2"
     using m points_index_count_min ps by blast
   then show False using assms index_distinct ps antisym_conv2 not_numeral_less_zero 
       numeral_le_one_iff points_index_ps_nin semiring_norm(69) zero_neq_numeral
     by (metis gdd_index_options int_int_eq int_ops(2))
 qed
 
 lemma simple_if_block_size_gt_2:
   assumes "\<And> bl . card bl \<ge> 2"
   assumes "\<Lambda> = 1"
   shows "simple_design \<V> \<B>"
   using index_1_imp_mult_1 assms apply (unfold_locales)
   by (metis card.empty not_numeral_le_zero) 
 
 end
 
 subsubsection \<open>Sub types of GDD's\<close>
 
 text \<open>In literature, a GDD is usually defined in a number of different ways, 
 including factors such as block size limitations\<close>
 locale K_\<Lambda>_GDD = K_block_design + GDD
 
 locale k_\<Lambda>_GDD = block_design + GDD
 
 sublocale k_\<Lambda>_GDD \<subseteq> K_\<Lambda>_GDD \<V> \<B> "{\<k>}" \<G> \<Lambda>
   by (unfold_locales)
 
 locale K_GDD = K_\<Lambda>_GDD \<V> \<B> \<K> \<G> 1 
   for point_set ("\<V>") and block_collection ("\<B>") and sizes ("\<K>") and groups ("\<G>")
 
 locale k_GDD = k_\<Lambda>_GDD \<V> \<B> \<k> \<G> 1 
   for point_set ("\<V>") and block_collection ("\<B>") and u_block_size ("\<k>") and groups ("\<G>")
 
 sublocale k_GDD \<subseteq> K_GDD \<V> \<B> "{\<k>}" \<G>
   by (unfold_locales)
 
 lemma (in K_GDD) multiplicity_1:  "bl \<in># \<B> \<Longrightarrow> card bl \<ge> 2 \<Longrightarrow> multiplicity bl = 1"
   using index_1_imp_mult_1 by simp
 
 locale RGDD = GDD + resolvable_design
 
 subsection \<open>GDD and PBD Constructions\<close>
 text \<open>GDD's are commonly studied alongside PBD's (pairwise balanced designs). Many constructions
 have been developed for designs to create a GDD from a PBD and vice versa. In particular, 
 Wilsons Construction is a well known construction, which is formalised in this section. It
 should be noted that many of the more basic constructions in this section are often stated without
 proof/all the necessary assumptions in textbooks/course notes.\<close>
 
 context GDD
 begin
 
 subsubsection \<open>GDD Delete Point construction\<close>
 lemma delete_point_index_zero: 
   assumes "G \<in> {g - {x} |g. g \<in> \<G> \<and> g \<noteq> {x}}"
   and "y \<in> G" and "z \<in> G" and "z\<noteq> y"
 shows "(del_point_blocks x) index {y, z} = 0"
 proof -
   have "y \<noteq> x" using assms(1) assms(2) by blast 
   have "z \<noteq> x" using assms(1) assms(3) by blast 
   obtain G' where ing: "G' \<in> \<G>" and ss: "G \<subseteq> G'"
     using assms(1) by auto
   have "{y, z} \<subseteq> G" by (simp add: assms(2) assms(3)) 
   then have "{y, z} \<subseteq> \<V>"
     by (meson ss ing group_subset_point_subset) 
   then have "{y, z} \<subseteq> (del_point x)"
     using \<open>y \<noteq> x\<close> \<open>z \<noteq> x\<close> del_point_def by fastforce 
   thus ?thesis using delete_point_index_eq index_together
     by (metis assms(2) assms(3) assms(4) in_mono ing ss) 
 qed
 
 lemma delete_point_index: 
   assumes "G1 \<in> {g - {x} |g. g \<in> \<G> \<and> g \<noteq> {x}}"
   assumes "G2 \<in> {g - {x} |g. g \<in> \<G> \<and> g \<noteq> {x}}"
   assumes "G1 \<noteq> G2" and "y \<in> G1" and "z \<in> G2"
   shows "del_point_blocks x index {y, z} = \<Lambda>"
 proof -
   have "y \<noteq> x" using assms by blast 
   have "z \<noteq> x" using assms by blast 
   obtain G1' where ing1: "G1' \<in> \<G>" and t1: "G1 = G1' - {x}"
     using assms(1) by auto
   obtain G2' where ing2: "G2' \<in> \<G>" and t2: "G2 = G2' - {x}"
     using assms(2) by auto
   then have ss1: "G1 \<subseteq> G1'" and ss2: "G2 \<subseteq> G2'" using t1 by auto
   then have "{y, z} \<subseteq> \<V>" using ing1 ing2 ss1 ss2 assms(4) assms(5)
     by (metis empty_subsetI insert_absorb insert_subset point_in_group) 
   then have "{y, z} \<subseteq> del_point x"
     using \<open>y \<noteq> x\<close> \<open>z \<noteq> x\<close> del_point_def by auto 
   then have indx: "del_point_blocks x index {y, z} = \<B> index {y, z}" 
     using delete_point_index_eq by auto
   have "G1' \<noteq> G2'" using assms t1 t2 by fastforce 
   thus ?thesis using index_distinct
     using indx assms(4) assms(5) ing1 ing2 t1 t2 by auto 
 qed
 
 lemma delete_point_group_size: 
   assumes "{x} \<in> \<G> \<Longrightarrow> card \<G> > 2" 
   shows "1 < card {g - {x} |g. g \<in> \<G> \<and> g \<noteq> {x}}"
 proof (cases "{x} \<in> \<G>")
   case True
   then have "\<And> g . g \<in> (\<G> - {{x}}) \<Longrightarrow> x \<notin> g"
     by (meson disjnt_insert1 groups_disjoint pairwise_alt)
   then have simpg: "\<And> g . g \<in> (\<G> - {{x}}) \<Longrightarrow> g - {x} = g"
     by simp 
   have "{g - {x} |g. g \<in> \<G> \<and> g \<noteq> {x}} = {g - {x} |g. (g \<in> \<G> - {{x}})}" using True
     by force 
   then have "{g - {x} |g. g \<in> \<G> \<and> g \<noteq> {x}} = {g |g. (g \<in> \<G> - {{x}})}" using simpg 
     by (smt (verit) Collect_cong)
   then have eq: "{g - {x} |g. g \<in> \<G> \<and> g \<noteq> {x}} =  \<G> - {{x}}" using set_self_img_compr by blast
   have "card (\<G> - {{x}}) = card \<G> - 1" using True
     by (simp add: groups_finite) 
   then show ?thesis using True assms eq diff_is_0_eq' by force 
 next
   case False
   then have "\<And>g' y. {x} \<notin> \<G> \<Longrightarrow> g' \<in> \<G> \<Longrightarrow> y \<in> \<G> \<Longrightarrow> g' - {x} = y - {x} \<Longrightarrow> g' = y" 
     by (metis all_not_in_conv insert_Diff_single insert_absorb insert_iff points_sep_groups_ne)
   then have inj: "inj_on (\<lambda> g . g - {x}) \<G>" by (simp add: inj_onI False) 
   have "{g - {x} |g. g \<in> \<G> \<and> g \<noteq> {x}} = {g - {x} |g. g \<in> \<G>}" using False by auto
   then have "card {g - {x} |g. g \<in> \<G> \<and> g \<noteq> {x}} = card \<G>" using inj groups_finite card_image
     by (auto simp add: card_image setcompr_eq_image) 
   then show ?thesis using groups_size by presburger 
 qed
 
 lemma GDD_by_deleting_point: 
   assumes "\<And>bl. bl \<in># \<B> \<Longrightarrow> x \<in> bl \<Longrightarrow> 2 \<le> card bl"
   assumes "{x} \<in> \<G> \<Longrightarrow> card \<G> > 2"
   shows "GDD (del_point x) (del_point_blocks x) {g - {x} | g . g \<in> \<G> \<and> g \<noteq> {x}} \<Lambda>"
 proof -
   interpret pd: proper_design "del_point x" "del_point_blocks x"
     using delete_point_proper assms by blast
   show ?thesis using delete_point_index_zero delete_point_index assms delete_point_group_size
     by(unfold_locales) (simp_all add: partition_on_remove_pt group_partitions index_ge_1 del_point_def)
 qed
 
 end
 
 context K_GDD begin 
 
 subsubsection \<open>PBD construction from GDD\<close>
 text \<open>Two well known PBD constructions involve taking a GDD and either combining the groups and
 blocks to form a new block collection, or by adjoining a point\<close>
 
 text \<open>First prove that combining the groups and block set results in a constant index\<close>
 lemma kgdd1_points_index_group_block: 
   assumes "ps \<subseteq> \<V>"
   and "card ps = 2"
   shows "(\<B> + mset_set \<G>) index ps = 1"
 proof -
   have index1: "(\<And> G . G \<in> \<G> \<Longrightarrow> \<not> ps \<subseteq> G) \<Longrightarrow> \<B> index ps = 1"
     using index_distinct_alt_ss assms by fastforce 
   have groups1: "\<B> index ps = 0 \<Longrightarrow> size {#b \<in>#  mset_set \<G> . ps \<subseteq> b#} = 1"  
     using index_zero_implies_one_group assms by simp 
   then have "(\<B> + mset_set \<G>) index ps = size (filter_mset ((\<subseteq>) ps) (\<B> + mset_set \<G>))" 
     by (simp add: points_index_def)
   thus ?thesis using index1 groups1 gdd_index_non_zero_iff gdd_index_zero_iff assms 
       gdd_index_options points_index_def filter_union_mset union_commute
     by (smt (z3) empty_neutral(1) less_irrefl_nat nonempty_has_size of_nat_1_eq_iff) 
 qed
 
 text \<open>Combining blocks and the group set forms a PBD\<close>
 lemma combine_block_groups_pairwise: "pairwise_balance \<V> (\<B> + mset_set \<G>) 1"
 proof -
   let ?B = "\<B> + mset_set \<G>"
   have ss: "\<And> G. G \<in> \<G> \<Longrightarrow> G \<subseteq> \<V>"
     by (simp add: point_in_group subsetI)
   have "\<And> G. G \<in> \<G> \<Longrightarrow> G \<noteq> {}" using group_partitions
     using partition_onD3 by auto 
   then interpret inc: design \<V> ?B 
   proof (unfold_locales)
     show "\<And>b. (\<And>G. G \<in> \<G> \<Longrightarrow> G \<noteq> {}) \<Longrightarrow> b \<in># \<B> + mset_set \<G> \<Longrightarrow> b \<subseteq> \<V>"
       by (metis finite_set_mset_mset_set groups_finite ss union_iff wellformed)
     show "(\<And>G. G \<in> \<G> \<Longrightarrow> G \<noteq> {}) \<Longrightarrow> finite \<V>" by (simp add: finite_sets)
     show "\<And>bl. (\<And>G. G \<in> \<G> \<Longrightarrow> G \<noteq> {}) \<Longrightarrow> bl \<in># \<B> + mset_set \<G> \<Longrightarrow> bl \<noteq> {}"
       using blocks_nempty groups_finite by auto
   qed
   show ?thesis proof (unfold_locales)
     show "inc.\<b> \<noteq> 0" using b_positive by auto
-    show "(1 ::int) \<le> 2" by simp
+    show "(1 ::nat) \<le> 2" by simp
     show "2 \<le> inc.\<v>" by (simp add: gdd_min_v)
-    then show "\<And>ps. ps \<subseteq> \<V> \<Longrightarrow> int (card ps) = 2 \<Longrightarrow> int ((\<B> + mset_set \<G>) index ps) = 1" 
+    then show "\<And>ps. ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> (\<B> + mset_set \<G>) index ps = 1" 
       using kgdd1_points_index_group_block by simp
   qed
 qed
 
 lemma combine_block_groups_PBD:
   assumes "\<And> G. G \<in> \<G> \<Longrightarrow> card G \<in> \<K>"
   assumes "\<And> k . k \<in> \<K> \<Longrightarrow> k \<ge> 2"
   shows "PBD \<V> (\<B> + mset_set \<G>) \<K>"
 proof -
   let ?B = "\<B> + mset_set \<G>"
   interpret inc: pairwise_balance \<V> ?B 1 using combine_block_groups_pairwise by simp
   show ?thesis using assms block_sizes groups_finite positive_ints 
     by (unfold_locales) auto
 qed
 
 text \<open>Prove adjoining a point to each group set results in a constant points index\<close>
 lemma kgdd1_index_adjoin_group_block:
   assumes "x \<notin> \<V>"
   assumes "ps \<subseteq> insert x \<V>"
   assumes "card ps = 2"
   shows "(\<B> + mset_set {insert x g |g. g \<in> \<G>}) index ps = 1"
 proof -
   have "inj_on ((insert) x) \<G>"
     by (meson assms(1) inj_onI insert_ident point_in_group) 
   then have eq: "mset_set {insert x g |g. g \<in> \<G>} = {# insert x g . g \<in># mset_set \<G>#}"
     by (simp add: image_mset_mset_set setcompr_eq_image)
   thus ?thesis 
   proof (cases "x \<in> ps")
     case True
     then obtain y where y_ps: "ps = {x, y}" using assms(3)
       by (metis card_2_iff doubleton_eq_iff insertE singletonD)
     then have ynex: "y \<noteq> x" using assms by fastforce 
     have yinv: "y \<in> \<V>"
       using assms(2) y_ps ynex by auto 
     have all_g: "\<And> g. g \<in># (mset_set {insert x g |g. g \<in> \<G>}) \<Longrightarrow> x \<in> g"
       using eq by force
     have iff: "\<And> g . g \<in> \<G> \<Longrightarrow> y \<in> (insert x g) \<longleftrightarrow> y \<in> g" using ynex by simp 
     have b: "\<B> index ps = 0"
       using True assms(1) points_index_ps_nin by fastforce 
     then have "(\<B> + mset_set {insert x g |g. g \<in> \<G>}) index ps = 
         (mset_set {insert x g |g. g \<in> \<G>}) index ps"
       using eq by (simp add: point_index_distrib)
     also have  "... = (mset_set {insert x g |g. g \<in> \<G>}) rep y" using points_index_pair_rep_num
       by (metis (no_types, lifting) all_g y_ps) 
     also have 0: "... = card {b \<in> {insert x g |g. g \<in> \<G>} . y \<in> b}" 
       by (simp add: groups_finite rep_number_on_set_def)
     also have 1: "... = card {insert x g |g. g \<in> \<G> \<and> y \<in> insert x g}"
       by (smt (verit) Collect_cong mem_Collect_eq)
     also have 2: " ... = card {insert x g |g. g \<in> \<G> \<and> y \<in> g}" 
       using iff by metis 
     also have "... = card {g \<in> \<G> . y \<in> g}" using 1 2 0 empty_iff eq groups_finite ynex insert_iff
       by (metis points_index_block_image_add_eq points_index_single_rep_num rep_number_on_set_def)  
     finally have "(\<B> + mset_set {insert x g |g. g \<in> \<G>}) index ps = 1" 
       using rep_number_point_group_one yinv by simp 
     then show ?thesis
       by simp 
   next
     case False
     then have v: "ps \<subseteq> \<V>" using assms(2) by auto 
     then have "(\<B> + mset_set {insert x g |g. g \<in> \<G>}) index ps = (\<B> + mset_set \<G>) index ps"
       using eq by (simp add: points_index_block_image_add_eq False point_index_distrib) 
     then show ?thesis using v assms kgdd1_points_index_group_block by simp
   qed
 qed
 
 lemma pairwise_by_adjoining_point: 
   assumes "x \<notin> \<V>"
   shows "pairwise_balance (add_point x) (\<B> + mset_set { insert x g | g. g \<in> \<G>}) 1"
 proof -
   let ?B = "\<B> + mset_set { insert x g | g. g \<in> \<G>}"
   let ?V = "add_point x"
   have vdef: "?V = \<V> \<union> {x}" using add_point_def by simp
-  show ?thesis unfolding add_point_def using finite_sets b_positive 
+  show ?thesis unfolding add_point_def using finite_sets design_blocks_nempty 
   proof (unfold_locales, simp_all)
     have "\<And> G. G \<in> \<G> \<Longrightarrow> insert x G \<subseteq> ?V"
       by (simp add: point_in_group subsetI vdef)
     then have "\<And> G. G \<in># (mset_set { insert x g | g. g \<in> \<G>}) \<Longrightarrow> G \<subseteq> ?V"
       by (smt (verit, del_insts) elem_mset_set empty_iff infinite_set_mset_mset_set mem_Collect_eq)
     then show "\<And>b. b \<in># \<B> \<or> b \<in># mset_set {insert x g |g. g \<in> \<G>} \<Longrightarrow> b \<subseteq> insert x \<V>" 
       using wellformed add_point_def by fastforce
   next 
     have "\<And> G. G \<in> \<G> \<Longrightarrow> insert x G \<noteq> {}" using group_partitions
       using partition_onD3 by auto 
     then have gnempty: "\<And> G. G \<in># (mset_set { insert x g | g. g \<in> \<G>}) \<Longrightarrow> G \<noteq> {}"
       by (smt (verit, del_insts) elem_mset_set empty_iff infinite_set_mset_mset_set mem_Collect_eq)
     then show "\<And>bl. bl \<in># \<B> \<or> bl \<in># mset_set {insert x g |g. g \<in> \<G>} \<Longrightarrow> bl \<noteq> {}" 
       using blocks_nempty by auto
   next
     have "card \<V> \<ge> 2" using gdd_min_v by simp 
     then have "card (insert x \<V>) \<ge> 2"
       by (meson card_insert_le dual_order.trans finite_sets) 
-    then show "2 \<le> int (card (insert x \<V>))" by auto
+    then show "2 \<le> card (insert x \<V>)" by auto
   next
     show "\<And>ps. ps \<subseteq> insert x \<V> \<Longrightarrow>
           card ps = 2 \<Longrightarrow> (\<B> + mset_set {insert x g |g. g \<in> \<G>}) index ps = Suc 0" 
       using kgdd1_index_adjoin_group_block by (simp add: assms) 
   qed
 qed
 
 lemma PBD_by_adjoining_point: 
   assumes "x \<notin> \<V>"
   assumes "\<And> k . k \<in> \<K> \<Longrightarrow> k \<ge> 2"
   shows "PBD (add_point x) (\<B> + mset_set { insert x g | g. g \<in> \<G>}) (\<K> \<union> {(card g) + 1 | g . g \<in> \<G>})"
 proof -
   let ?B = "\<B> + mset_set { insert x g | g. g \<in> \<G>}"
   let ?V = "(add_point x)"
   interpret inc: pairwise_balance ?V ?B 1 using pairwise_by_adjoining_point assms by auto 
   show ?thesis using  block_sizes positive_ints proof (unfold_locales)
     have xg: "\<And> g. g \<in> \<G> \<Longrightarrow> x \<notin> g"
       using assms point_in_group by auto 
     have "\<And> bl . bl \<in># \<B> \<Longrightarrow> card bl \<in> \<K>" by (simp add: block_sizes) 
     have "\<And> bl . bl \<in># mset_set {insert x g |g. g \<in> \<G>} \<Longrightarrow> bl \<in> {insert x g | g . g \<in> \<G>}"
       by (simp add: groups_finite) 
     then have "\<And> bl . bl \<in># mset_set {insert x g |g. g \<in> \<G>} \<Longrightarrow> 
-      card bl \<in>  {int (card g + 1) |g. g \<in> \<G>}" 
+      card bl \<in>  {card g + 1 |g. g \<in> \<G>}" 
     proof -
       fix bl 
       assume "bl \<in># mset_set {insert x g |g. g \<in> \<G>}"
       then have "bl \<in> {insert x g | g . g \<in> \<G>}" by (simp add: groups_finite)
       then obtain g where gin: "g \<in> \<G>" and i: "bl = insert x g" by auto 
-      thus "card bl \<in>  {int (card g + 1) |g. g \<in> \<G>}"
+      thus "card bl \<in>  {(card g + 1) |g. g \<in> \<G>}"
         using gin group_elements_finite i xg by auto
     qed
     then show "\<And>bl. bl \<in># \<B> + mset_set {insert x g |g. g \<in> \<G>} \<Longrightarrow> 
-        int (card bl) \<in> \<K> \<union> {int (card g + 1) |g. g \<in> \<G>}"
-      using  UnI1 UnI2 block_sizes union_iff by (smt (z3) mem_Collect_eq)
-    show "\<And>x. x \<in> \<K> \<union> {int (card g + 1) |g. g \<in> \<G>} \<Longrightarrow> 0 < x" 
+        (card bl) \<in> \<K> \<union> {(card g + 1) |g. g \<in> \<G>}"
+      using UnI1 UnI2 block_sizes union_iff by (smt (z3) mem_Collect_eq)
+    show "\<And>x. x \<in> \<K> \<union> {card g + 1 |g. g \<in> \<G>} \<Longrightarrow> 0 < x" 
       using min_group_size positive_ints by auto
-    show "\<And>k.  k \<in> \<K> \<union> {int (card g + 1) |g. g \<in> \<G>} \<Longrightarrow> 2 \<le> k" 
+    show "\<And>k.  k \<in> \<K> \<union> {card g + 1 |g. g \<in> \<G>} \<Longrightarrow> 2 \<le> k" 
       using min_group_size positive_ints assms by fastforce
   qed
 qed
 
 subsubsection \<open>Wilson's Construction\<close>
 text \<open>Wilson's construction involves the combination of multiple k-GDD's. This proof was
 based of Stinson \cite{stinsonCombinatorialDesignsConstructions2004}\<close>
 
 lemma wilsons_construction_proper: 
   assumes "card I = w"
   assumes "w > 0"
   assumes "\<And> n. n \<in> \<K>' \<Longrightarrow> n \<ge> 2"
   assumes "\<And> B . B \<in># \<B> \<Longrightarrow> K_GDD (B \<times> I) (f B) \<K>' {{x} \<times> I |x . x \<in> B }"
   shows "proper_design (\<V> \<times> I) (\<Sum>B \<in># \<B>. (f B))" (is "proper_design ?Y ?B")
 proof (unfold_locales, simp_all)
   show "\<And>b. \<exists>x\<in>#\<B>. b \<in># f x \<Longrightarrow> b \<subseteq> \<V> \<times> I"
   proof -
     fix b
     assume "\<exists>x\<in>#\<B>. b \<in># f x"
     then obtain B where "B \<in># \<B>" and "b \<in># (f B)" by auto
     then interpret kgdd: K_GDD "(B \<times> I)" "(f B)" \<K>' "{{x} \<times> I |x . x \<in> B }" using assms by auto
     show "b \<subseteq> \<V> \<times> I" using kgdd.wellformed
       using \<open>B \<in># \<B>\<close> \<open>b \<in># f B\<close> wellformed by fastforce 
   qed
   show "finite (\<V> \<times> I)" using finite_sets assms bot_nat_0.not_eq_extremum card.infinite by blast 
   show "\<And>bl. \<exists>x\<in>#\<B>. bl \<in># f x \<Longrightarrow> bl \<noteq> {}"
   proof -
     fix bl
     assume "\<exists>x\<in>#\<B>. bl \<in># f x"
     then obtain B where "B \<in># \<B>" and "bl \<in># (f B)" by auto
     then interpret kgdd: K_GDD "(B \<times> I)" "(f B)" \<K>' "{{x} \<times> I |x . x \<in> B }" using assms by auto
     show "bl \<noteq> {}" using kgdd.blocks_nempty by (simp add: \<open>bl \<in># f B\<close>) 
   qed
   show "\<exists>i\<in>#\<B>. f i \<noteq> {#}"
   proof -
     obtain B where "B \<in># \<B>"
       using design_blocks_nempty by auto 
     then interpret kgdd: K_GDD "(B \<times> I)" "(f B)" \<K>' "{{x} \<times> I |x . x \<in> B }" using assms by auto
     have "f B \<noteq> {#}" using kgdd.design_blocks_nempty by simp 
     then show "\<exists>i\<in>#\<B>. f i \<noteq> {#}" using \<open>B \<in># \<B>\<close> by auto 
   qed
 qed
 
 lemma pair_construction_block_sizes: 
   assumes "K_GDD (B \<times> I) (f B) \<K>' {{x} \<times> I |x . x \<in> B }"
   assumes "B \<in># \<B>"
   assumes "b \<in># (f B)"
   shows "card b \<in> \<K>'"
 proof -
   interpret bkgdd: K_GDD "(B \<times> I)" "(f B)" \<K>' "{{x} \<times> I |x . x \<in> B }"
     using assms by simp
   show "card b \<in> \<K>'" using bkgdd.block_sizes by (simp add:assms) 
 qed
 
 lemma wilsons_construction_index_0: 
   assumes "\<And> B . B \<in># \<B> \<Longrightarrow> K_GDD (B \<times> I) (f B) \<K>' {{x} \<times> I |x . x \<in> B }"
   assumes "G \<in> {GG \<times> I |GG. GG \<in> \<G>}"
   assumes "X \<in> G" 
   assumes "Y \<in> G" 
   assumes "X \<noteq> Y"
   shows "(\<Sum>\<^sub># (image_mset f \<B>)) index {X, Y} = 0"
 proof -
   obtain G' where gi: "G = G' \<times> I" and ging: "G' \<in> \<G>" using assms by auto
   obtain x y ix iy where xpair: "X = (x, ix)" and ypair: "Y = (y, iy)" using assms by auto
   then have ixin: "ix \<in> I" and xing: "x \<in> G'" using assms gi by auto 
   have iyin: "iy \<in> I" and ying: "y \<in> G'" using assms ypair gi by auto
   have ne_index_0: "x \<noteq> y \<Longrightarrow> \<B> index {x, y} = 0" 
     using ying xing index_together ging by simp
   have "\<And> B. B \<in># \<B> \<Longrightarrow> (f B) index {(x, ix), (y, iy)} = 0" 
   proof -
     fix B
     assume assm: "B \<in># \<B>"
     then interpret kgdd: K_GDD "(B \<times> I)" "(f B)" \<K>' "{{x} \<times> I |x . x \<in> B }" using assms by simp
     have not_ss_0: "\<not> ({(x, ix), (y, iy)} \<subseteq> (B \<times> I)) \<Longrightarrow> (f B) index {(x, ix), (y, iy)} = 0"
       by (metis kgdd.points_index_ps_nin) 
     have "x \<noteq> y \<Longrightarrow> \<not> {x, y} \<subseteq> B" using ne_index_0 assm points_index_0_left_imp by auto 
     then have "x \<noteq> y \<Longrightarrow> \<not> ({(x, ix), (y, iy)} \<subseteq> (B \<times> I))" using assms
       by (meson empty_subsetI insert_subset mem_Sigma_iff)
     then have nexy: "x \<noteq> y \<Longrightarrow> (f B) index {(x, ix), (y, iy)} = 0" using not_ss_0 by simp
     have "x = y \<Longrightarrow> ({(x, ix), (y, iy)} \<subseteq> (B \<times> I)) \<Longrightarrow> (f B) index {(x, ix), (y, iy)} = 0"
     proof -
       assume eq: "x = y"
       assume "({(x, ix), (y, iy)} \<subseteq> (B \<times> I))"
       then obtain g where "g \<in> {{x} \<times> I |x . x \<in> B }" and "(x, ix) \<in> g" and "(y, ix) \<in> g"
         using eq  by auto 
       then show ?thesis using kgdd.index_together
         by (smt (verit, best) SigmaD1 SigmaD2 SigmaI assms(4) assms(5) gi mem_Collect_eq xpair ypair)
     qed
     then show "(f B) index {(x, ix), (y, iy)} = 0" using not_ss_0 nexy by auto
   qed
   then have "\<And> B. B \<in># (image_mset f \<B>) \<Longrightarrow> B index {(x, ix), (y, iy)} = 0" by auto
   then show "(\<Sum>\<^sub># (image_mset f \<B>)) index {X, Y} = 0" 
     by (simp add: points_index_sum xpair ypair)
 qed
 
 lemma wilsons_construction_index_1: 
   assumes "\<And> B . B \<in># \<B> \<Longrightarrow> K_GDD (B \<times> I) (f B) \<K>' {{x} \<times> I |x . x \<in> B }"
   assumes "G1 \<in> {G \<times> I |G. G \<in> \<G>}"
   assumes "G2 \<in> {G \<times> I |G. G \<in> \<G>}"
   assumes "G1 \<noteq> G2"
   and "(x, ix) \<in> G1" and "(y, iy) \<in> G2" 
   shows "(\<Sum>\<^sub># (image_mset f \<B>)) index {(x, ix), (y, iy)} = (1 ::int)"
 proof -
   obtain G1' where gi1: "G1 = G1' \<times> I" and ging1: "G1' \<in> \<G>" using assms by auto
   obtain G2' where gi2: "G2 = G2' \<times> I" and ging2: "G2' \<in> \<G>" using assms by auto
   have xing: "x \<in> G1'" using assms gi1 by simp
   have ying: "y \<in> G2'" using assms gi2 by simp
   have gne: "G1' \<noteq> G2'" using assms gi1 gi2 by auto
   then have xyne: "x \<noteq> y" using xing ying ging1 ging2 point_in_one_group by blast
   have "\<exists>! bl . bl \<in># \<B> \<and> {x, y} \<subseteq> bl" using index_distinct points_index_one_unique_block
     by (metis ging1 ging2 gne of_nat_1_eq_iff xing ying) 
   then obtain bl where blinb:"bl \<in># \<B>" and xyblss: "{x, y} \<subseteq> bl" by auto 
   then have "\<And> b . b \<in># \<B> - {#bl#} \<Longrightarrow> \<not> {x, y} \<subseteq> b" using points_index_one_not_unique_block
     by (metis ging1 ging2 gne index_distinct int_ops(2) nat_int_comparison(1) xing ying) 
   then have not_ss: "\<And> b . b \<in># \<B> - {#bl#} \<Longrightarrow> \<not> ({(x, ix), (y, iy)} \<subseteq> (b \<times> I))" using assms
     by (meson SigmaD1 empty_subsetI insert_subset)
   then have pi0: "\<And> b . b \<in># \<B> - {#bl#} \<Longrightarrow> (f b) index {(x, ix), (y, iy)}  = 0"
   proof -
     fix b
     assume assm: "b \<in># \<B> - {#bl#}"
     then have "b \<in># \<B>" by (meson in_diffD) 
     then interpret kgdd: K_GDD "(b \<times> I)" "(f b)" \<K>' "{{x} \<times> I |x . x \<in> b }" using assms by simp
     show "(f b) index {(x, ix), (y, iy)} = 0"
       using assm not_ss by (metis kgdd.points_index_ps_nin) 
   qed
   let ?G = "{{x} \<times> I |x . x \<in> bl }"
   interpret bkgdd: K_GDD "(bl \<times> I)" "(f bl)" \<K>' ?G using assms blinb by simp
   obtain g1 g2 where xing1: "(x, ix) \<in> g1" and ying2: "(y, iy) \<in> g2" and g1g: "g1 \<in> ?G" 
       and g2g: "g2 \<in> ?G" using assms(5) assms(6) gi1 gi2
     by (metis (no_types, lifting) bkgdd.point_has_unique_group insert_subset mem_Sigma_iff xyblss) 
   then have "g1 \<noteq> g2" using xyne by blast 
   then have pi1: "(f bl) index {(x, ix), (y, iy)} = 1" 
     using bkgdd.index_distinct xing1 ying2 g1g g2g by simp
   have "(\<Sum>\<^sub># (image_mset f \<B>)) index {(x, ix), (y, iy)} = 
       (\<Sum>B \<in># \<B>. (f B) index {(x, ix), (y, iy)} )" 
     by (simp add: points_index_sum)
   then have "(\<Sum>\<^sub># (image_mset f \<B>)) index {(x, ix), (y, iy)} = 
       (\<Sum>B \<in># (\<B> - {#bl#}). (f B) index {(x, ix), (y, iy)}) + (f bl) index {(x, ix), (y, iy)}"
     by (metis (no_types, lifting) add.commute blinb insert_DiffM sum_mset.insert) 
   thus ?thesis using pi0 pi1 by simp
 qed
 
 theorem Wilsons_Construction:
   assumes "card I = w"
   assumes "w > 0"
   assumes "\<And> n. n \<in> \<K>' \<Longrightarrow> n \<ge> 2"
   assumes "\<And> B . B \<in># \<B> \<Longrightarrow> K_GDD (B \<times> I) (f B) \<K>' {{x} \<times> I |x . x \<in> B }"
   shows "K_GDD (\<V> \<times> I) (\<Sum>B \<in># \<B>. (f B)) \<K>' {G \<times> I | G . G \<in> \<G>}"
 proof -
   let ?Y = "\<V> \<times> I" and ?H = "{G \<times> I | G . G \<in> \<G>}" and ?B = "\<Sum>B \<in># \<B>. (f B)"
   interpret pd: proper_design ?Y ?B using wilsons_construction_proper assms by auto
   have "\<And> bl . bl \<in># (\<Sum>B \<in># \<B>. (f B)) \<Longrightarrow> card bl \<in> \<K>'"  
     using assms pair_construction_block_sizes by blast 
   then interpret kdes: K_block_design ?Y ?B \<K>' 
     using assms(3) by (unfold_locales) (simp_all,fastforce)
   interpret gdd: GDD ?Y ?B ?H "1:: int" 
   proof (unfold_locales)
     show "partition_on (\<V> \<times> I) {G \<times> I |G. G \<in> \<G>}" 
       using assms groups_not_empty design_points_nempty group_partitions
       by (simp add: partition_on_cart_prod) 
     have "inj_on (\<lambda> G. G \<times> I) \<G>"
       using inj_on_def pd.design_points_nempty by auto 
     then have "card {G \<times> I |G. G \<in> \<G>} = card \<G>" using card_image by (simp add: Setcompr_eq_image) 
     then show "1 < card {G \<times> I |G. G \<in> \<G>}" using groups_size by linarith 
     show "(1::int) \<le> 1" by simp
     have gdd_fact: "\<And> B . B \<in># \<B> \<Longrightarrow> K_GDD (B \<times> I) (f B) \<K>' {{x} \<times> I |x . x \<in> B }" 
       using assms by simp
     show "\<And>G X Y. G \<in> {GG \<times> I |GG. GG \<in> \<G>} \<Longrightarrow> X \<in> G \<Longrightarrow> Y \<in> G \<Longrightarrow> X \<noteq> Y 
         \<Longrightarrow> (\<Sum>\<^sub># (image_mset f \<B>)) index {X, Y} = 0"
       using wilsons_construction_index_0[OF assms(4)] by auto
     show "\<And>G1 G2 X Y. G1 \<in> {G \<times> I |G. G \<in> \<G>} \<Longrightarrow> G2 \<in> {G \<times> I |G. G \<in> \<G>} 
       \<Longrightarrow> G1 \<noteq> G2 \<Longrightarrow> X \<in> G1 \<Longrightarrow> Y \<in> G2 \<Longrightarrow> ((\<Sum>\<^sub># (image_mset f \<B>)) index {X, Y}) = (1 ::int)"
       using wilsons_construction_index_1[OF assms(4)] by blast 
   qed
   show ?thesis by (unfold_locales)
 qed
 
 end
 
 context pairwise_balance
 begin
 
 lemma PBD_by_deleting_point: 
   assumes "\<v> > 2"
   assumes "\<And> bl . bl \<in># \<B> \<Longrightarrow> card bl \<ge> 2"
   shows "pairwise_balance (del_point x) (del_point_blocks x) \<Lambda>"
 proof (cases "x \<in> \<V>")
   case True
   interpret des: design "del_point x" "del_point_blocks x"
     using delete_point_design assms by blast 
   show ?thesis using assms design_blocks_nempty del_point_def del_point_blocks_def
   proof (unfold_locales, simp_all)
-    show "2 < \<v> \<Longrightarrow> (\<And>bl. bl \<in># \<B> \<Longrightarrow> 2 \<le> card bl) \<Longrightarrow> 2 \<le> int (card (\<V> - {x}))"
+    show "2 < \<v> \<Longrightarrow> (\<And>bl. bl \<in># \<B> \<Longrightarrow> 2 \<le> card bl) \<Longrightarrow> 2 \<le> (card (\<V> - {x}))"
       using card_Diff_singleton_if diff_diff_cancel diff_le_mono2 finite_sets less_one
-      by (metis int_ops(3) less_nat_zero_code nat_le_linear verit_comp_simplify1(3) zle_int)
+      by (metis diff_is_0_eq neq0_conv t_lt_order zero_less_diff) 
     have "\<And> ps . ps  \<subseteq> \<V> - {x} \<Longrightarrow> ps \<subseteq> \<V>" by auto
     then show "\<And>ps. ps \<subseteq> \<V> - {x} \<Longrightarrow> card ps = 2  \<Longrightarrow> {#bl - {x}. bl \<in># \<B>#} index ps = \<Lambda>"
       using delete_point_index_eq del_point_def del_point_blocks_def by simp
   qed
 next
   case False
   then show ?thesis
     by (simp add: del_invalid_point del_invalid_point_blocks pairwise_balance_axioms)
 qed
 end
 
 context k_GDD
 begin
 
 lemma bibd_from_kGDD:
   assumes "\<k> > 1"
   assumes "\<And> g. g \<in> \<G> \<Longrightarrow> card g = \<k> - 1"
   assumes " x \<notin> \<V>"
   shows "bibd (add_point x) (\<B> + mset_set { insert x g | g. g \<in> \<G>}) (\<k>) 1"
 proof - 
-  have "({\<k>} \<union> {(card g) + 1 | g . g \<in> \<G>}) = {\<k>}"
-    using assms(2) by fastforce 
+  have "\<And> k . k\<in> {\<k>} \<Longrightarrow> k = \<k>" by blast 
+  then have kge: "\<And> k . k\<in> {\<k>} \<Longrightarrow> k \<ge> 2" using assms(1) by simp
+  have "\<And> g . g \<in> \<G> \<Longrightarrow> card g + 1 = \<k>" using assms k_non_zero by auto 
+  then have s: "({\<k>} \<union> {(card g) + 1 | g . g \<in> \<G>}) = {\<k>}" by auto
   then interpret pbd: PBD "(add_point x)" "\<B> + mset_set { insert x g | g. g \<in> \<G>}" "{\<k>}"
-    using PBD_by_adjoining_point assms sys_block_sizes_obtain_bl add_point_def
-    by (smt (verit, best) Collect_cong sys_block_sizes_uniform uniform_alt_def_all) 
+    using PBD_by_adjoining_point[of "x"] kge assms by (smt (z3) Collect_cong)
   show ?thesis using assms pbd.block_sizes block_size_lt_v finite_sets add_point_def
     by (unfold_locales) (simp_all)
 qed
 
 end
 
 context PBD 
 begin
 
 lemma pbd_points_index1: "ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> \<B> index ps = 1"
-  using balanced by (metis int_eq_iff_numeral of_nat_1_eq_iff) 
+  using balanced by simp 
 
 lemma pbd_index1_points_imply_unique_block: 
   assumes "b1 \<in># \<B>" and "b2 \<in># \<B>" and "b1 \<noteq> b2"
   assumes "x \<noteq> y" and "{x, y} \<subseteq> b1" and "x \<in> b2" 
   shows "y \<notin> b2"
 proof (rule ccontr)
   let ?ps = "{# b \<in># \<B> . {x, y} \<subseteq> b#}"
   assume "\<not> y \<notin> b2"
   then have a: "y \<in> b2" by linarith
   then have "{x, y} \<subseteq> b2"
     by (simp add: assms(6)) 
   then have "b1 \<in># ?ps" and "b2 \<in># ?ps" using assms by auto
   then have ss: "{#b1, b2#} \<subseteq># ?ps" using assms
     by (metis insert_noteq_member mset_add mset_subset_eq_add_mset_cancel single_subset_iff) 
   have "size {#b1, b2#} = 2" using assms by auto
   then have ge2: "size ?ps \<ge> 2" using assms ss by (metis size_mset_mono) 
   have pair: "card {x, y} = 2" using assms by auto
   have "{x, y} \<subseteq> \<V>" using assms wellformed by auto
   then have "\<B> index {x, y} = 1" using pbd_points_index1 pair by simp
   then show False using points_index_def ge2
     by (metis numeral_le_one_iff semiring_norm(69)) 
 qed
 
 lemma strong_delete_point_groups_index_zero: 
   assumes "G \<in> {b - {x} |b. b \<in># \<B> \<and> x \<in> b}"
   assumes "xa \<in> G" and "y \<in> G" and "xa \<noteq> y"
   shows "(str_del_point_blocks x) index {xa, y} = 0"
 proof (auto simp add: points_index_0_iff str_del_point_blocks_def)
   fix b
   assume a1: "b \<in># \<B>" and a2: "x \<notin> b" and a3: "xa \<in> b" and a4: "y \<in> b"
   obtain b' where "G = b' - {x}" and "b' \<in># \<B>" and  "x \<in> b'" using assms by blast
   then show False using a1 a2 a3 a4 assms pbd_index1_points_imply_unique_block
     by fastforce 
 qed
 
 lemma strong_delete_point_groups_index_one: 
   assumes "G1 \<in> {b - {x} |b. b \<in># \<B> \<and> x \<in> b}"
   assumes "G2 \<in> {b - {x} |b. b \<in># \<B> \<and> x \<in> b}"
   assumes "G1 \<noteq> G2" and "xa \<in> G1" and "y \<in> G2"
   shows  "(str_del_point_blocks x) index {xa, y} = 1"
 proof -
   obtain b1 where gb1: "G1 = b1 - {x}" and b1in: "b1 \<in># \<B>" and xin1: "x \<in> b1" using assms by blast
   obtain b2 where gb2: "G2 = b2 - {x}" and b2in: "b2 \<in># \<B>" and xin2:"x \<in> b2" using assms by blast
   have bneq: "b1 \<noteq> b2 " using assms(3) gb1 gb2 by auto
   have "xa \<noteq> y" using gb1 b1in xin1 gb2 b2in xin2 assms(3) assms(4) assms(5) insert_subset
     by (smt (verit, best) Diff_eq_empty_iff Diff_iff empty_Diff insertCI pbd_index1_points_imply_unique_block) 
   then have pair: "card {xa, y} = 2" by simp 
   have inv: "{xa, y} \<subseteq> \<V>" using gb1 b1in gb2 b2in assms(4) assms(5)
     by (metis Diff_cancel Diff_subset insert_Diff insert_subset wellformed) 
   have "{# bl \<in># \<B> . x \<in> bl#} index {xa, y} = 0"
   proof (auto simp add: points_index_0_iff)
     fix b assume a1: "b \<in># \<B>" and a2: "x \<in> b" and a3: "xa \<in> b" and a4: "y \<in> b"
     then have yxss: "{y, x} \<subseteq> b2"
       using assms(5) gb2 xin2 by blast 
     have "{xa, x} \<subseteq> b1"
       using assms(4) gb1 xin1 by auto 
     then have "xa \<notin> b2" using pbd_index1_points_imply_unique_block
       by (metis DiffE assms(4) b1in b2in bneq gb1 singletonI xin2) 
     then have "b2 \<noteq> b" using a3 by auto 
     then show False using pbd_index1_points_imply_unique_block
       by (metis DiffD2 yxss a1 a2 a4 assms(5) b2in gb2 insertI1) 
   qed
   then have "(str_del_point_blocks x) index {xa, y} = \<B> index {xa, y}" 
     by (metis multiset_partition plus_nat.add_0 point_index_distrib str_del_point_blocks_def) 
   thus ?thesis using pbd_points_index1 pair inv by fastforce
 qed
 
 lemma blocks_with_x_partition: 
   assumes "x \<in> \<V>"
   shows "partition_on (\<V> - {x}) {b - {x} |b. b \<in># \<B> \<and> x \<in> b}"
 proof (intro partition_onI )
   have gtt: "\<And> bl. bl \<in># \<B> \<Longrightarrow> card bl \<ge> 2" using block_size_gt_t
     by (simp add: block_sizes nat_int_comparison(3)) 
   show "\<And>p. p \<in> {b - {x} |b. b \<in># \<B> \<and> x \<in> b} \<Longrightarrow> p \<noteq> {}"
   proof -
     fix p assume "p \<in> {b - {x} |b. b \<in># \<B> \<and> x \<in> b}"
     then obtain b where ptx: "p = b - {x}" and "b \<in># \<B>" and xinb: "x \<in> b" by blast
     then have ge2: "card b \<ge> 2" using gtt by (simp add: nat_int_comparison(3)) 
     then have "finite b" by (metis card.infinite not_numeral_le_zero) 
     then have "card p = card b - 1" using xinb ptx by simp
     then have "card p \<ge> 1" using ge2 by linarith
     thus "p \<noteq> {}" by auto
   qed
   show "\<Union> {b - {x} |b. b \<in># \<B> \<and> x \<in> b} = \<V> - {x}"
   proof (intro subset_antisym subsetI)
     fix xa
     assume "xa \<in> \<Union> {b - {x} |b. b \<in># \<B> \<and> x \<in> b}" 
     then obtain b where "xa \<in> b" and "b \<in># \<B>" and "x \<in> b" and "xa \<noteq> x" by auto
     then show "xa \<in> \<V> - {x}" using wf_invalid_point by blast 
   next 
     fix xa
     assume a: "xa \<in> \<V> - {x}"
     then have nex: "xa \<noteq> x" by simp
     then have pair: "card {xa, x} = 2" by simp 
     have "{xa, x} \<subseteq> \<V>" using a assms by auto 
     then have "card {b \<in> design_support . {xa, x} \<subseteq> b} = 1" 
       using balanced points_index_simple_def pbd_points_index1 assms by (metis pair) 
     then obtain b where des: "b \<in> design_support" and ss: "{xa, x} \<subseteq> b"
       by (metis (no_types, lifting) card_1_singletonE mem_Collect_eq singletonI)
     then show "xa \<in> \<Union> {b - {x} |b. b \<in># \<B> \<and> x \<in> b}"
       using des ss nex design_support_def by auto
   qed
   show "\<And>p p'. p \<in> {b - {x} |b. b \<in># \<B> \<and> x \<in> b} \<Longrightarrow> p' \<in> {b - {x} |b. b \<in># \<B> \<and> x \<in> b} \<Longrightarrow> 
     p \<noteq> p' \<Longrightarrow> p \<inter> p' = {}" 
   proof -
     fix p p'
     assume p1: "p \<in> {b - {x} |b. b \<in># \<B> \<and> x \<in> b}" and p2: "p' \<in> {b - {x} |b. b \<in># \<B> \<and> x \<in> b}" 
       and pne: "p \<noteq> p'"
     then obtain b where b1: "p = b - {x}" and b1in:"b \<in># \<B>" and xinb1:"x \<in> b" by blast 
     then obtain b' where b2: "p' = b' - {x}" and b2in: "b' \<in># \<B>" and xinb2: "x \<in> b'"
       using p2 by blast
     then have "b \<noteq> b'" using pne b1 by auto
     then have "\<And> y. y \<in> b \<Longrightarrow> y \<noteq> x \<Longrightarrow> y \<notin> b'" 
       using b1in b2in xinb1 xinb2 pbd_index1_points_imply_unique_block
       by (meson empty_subsetI insert_subset) 
     then have "\<And> y. y \<in> p \<Longrightarrow> y \<notin> p'"
       by (metis Diff_iff b1 b2 insertI1) 
     then show "p \<inter> p' = {}" using disjoint_iff by auto
   qed
 qed
 
 lemma KGDD_by_deleting_point:
   assumes "x \<in> \<V>"
   assumes "\<B> rep x < \<b>"
   assumes "\<B> rep x > 1" 
   shows "K_GDD (del_point x) (str_del_point_blocks x) \<K> { b - {x} | b . b \<in># \<B> \<and> x \<in> b}"
 proof -
   have "\<And> bl. bl \<in># \<B> \<Longrightarrow> card bl \<ge> 2" using block_size_gt_t 
     by (simp add: block_sizes nat_int_comparison(3))
   then interpret des: proper_design "(del_point x)" "(str_del_point_blocks x)" 
     using strong_delete_point_proper assms by blast
   show ?thesis using blocks_with_x_partition strong_delete_point_groups_index_zero 
       strong_delete_point_groups_index_one str_del_point_blocks_def del_point_def
   proof (unfold_locales, simp_all add: block_sizes positive_ints assms) 
     have ge1: "card {b . b \<in># \<B> \<and> x \<in> b} > 1" 
       using assms(3) replication_num_simple_def design_support_def by auto
     have fin: "finite {b . b \<in># \<B> \<and> x \<in> b}" by simp 
     have inj: "inj_on (\<lambda> b . b - {x}) {b . b \<in># \<B> \<and> x \<in> b}" 
       using assms(2) inj_on_def mem_Collect_eq by auto 
     then have "card {b - {x} |b. b \<in># \<B> \<and> x \<in> b} = card {b . b \<in># \<B> \<and> x \<in> b}" 
       using card_image fin by (simp add: inj card_image setcompr_eq_image)
     then show "Suc 0 < card {b - {x} |b. b \<in># \<B> \<and> x \<in> b}" using ge1
       by presburger 
   qed
 qed
 
 lemma card_singletons_eq: "card {{a} | a . a \<in> A} = card A"
   by (simp add: card_image Setcompr_eq_image)
 
 lemma KGDD_from_PBD: "K_GDD \<V> \<B> \<K> {{x} | x . x \<in> \<V>}"
 proof (unfold_locales,auto simp add: Setcompr_eq_image partition_on_singletons)
   have "card ((\<lambda>x. {x}) ` \<V>) \<ge> 2" using t_lt_order card_singletons_eq
-    by (metis Collect_mem_eq nat_leq_as_int of_nat_numeral setcompr_eq_image) 
+    by (metis Collect_mem_eq setcompr_eq_image) 
   then show "Suc 0 < card ((\<lambda>x. {x}) ` \<V>)" by linarith
   show "\<And>xa xb. xa \<in> \<V> \<Longrightarrow> xb \<in> \<V> \<Longrightarrow> \<B> index {xa, xb} \<noteq> Suc 0 \<Longrightarrow> xa = xb"
   proof (rule ccontr)
     fix xa xb
     assume ain: "xa \<in> \<V>" and bin: "xb \<in> \<V>" and ne1: "\<B> index {xa, xb} \<noteq> Suc 0"
     assume "xa \<noteq> xb"
     then have "card {xa, xb} = 2" by auto
     then have "\<B> index {xa, xb} = 1"
-      by (simp add: ain bin pbd_points_index1) 
+      by (simp add: ain bin) 
     thus False using ne1 by linarith
   qed 
 qed
 
 end
 
 context bibd
 begin
 lemma kGDD_from_bibd:
   assumes "\<Lambda> = 1"
   assumes "x \<in> \<V>"
   shows "k_GDD (del_point x) (str_del_point_blocks x) \<k> { b - {x} | b . b \<in># \<B> \<and> x \<in> b}"
 proof -
   interpret pbd: PBD \<V> \<B> "{\<k>}" using assms
     using PBD.intro \<Lambda>_PBD_axioms by auto 
   have lt: "\<B> rep x < \<b>" using block_num_gt_rep
     by (simp add: assms(2)) 
   have "\<B> rep x > 1" using r_ge_two assms by simp
   then interpret kgdd: K_GDD "(del_point x)" "str_del_point_blocks x" 
     "{\<k>}" "{ b - {x} | b . b \<in># \<B> \<and> x \<in> b}"
     using pbd.KGDD_by_deleting_point lt assms by blast 
   show ?thesis using del_point_def str_del_point_blocks_def by (unfold_locales) (simp_all)
 qed
 
 end
 end
\ No newline at end of file
diff --git a/thys/Design_Theory/Multisets_Extras.thy b/thys/Design_Theory/Multisets_Extras.thy
--- a/thys/Design_Theory/Multisets_Extras.thy
+++ b/thys/Design_Theory/Multisets_Extras.thy
@@ -1,796 +1,817 @@
 (* Title: Multisets_Extras
    Author: Chelsea Edmonds
 *)
 
 section \<open>Micellanious Helper Functions on Sets and Multisets\<close>
 
 theory Multisets_Extras imports 
   "HOL-Library.Multiset" 
   Card_Partitions.Set_Partition
   Nested_Multisets_Ordinals.Multiset_More 
   Nested_Multisets_Ordinals.Duplicate_Free_Multiset
   "HOL-Library.Disjoint_Sets"
 begin
 
 subsection \<open>Set Theory Extras\<close>
 
 text \<open>A number of extra helper lemmas for reasoning on sets (finite) required for Design Theory 
 proofs\<close>
 
 lemma card_Pow_filter_one: 
   assumes "finite A" 
   shows "card {x \<in> Pow A . card x = 1}  = card (A)"
   using assms 
 proof (induct rule: finite_induct)
   case empty
   then show ?case by auto 
 next
   case (insert x F)
   have "Pow (insert x F) = Pow F \<union> insert x ` Pow F"
     by (simp add: Pow_insert) 
   then have split: "{y \<in> Pow (insert x F) . card y = 1} = 
       {y \<in> (Pow F) . card y = 1} \<union> {y \<in> (insert x ` Pow F) . card y = 1}"
     by blast 
   have "\<And> y . y \<in> (insert x ` Pow F) \<Longrightarrow> finite y"
     using finite_subset insert.hyps(1) by fastforce 
   then have single: "\<And> y . y \<in> (insert x ` Pow F) \<Longrightarrow> card y = 1 \<Longrightarrow> y = {x}"
     by (metis card_1_singletonE empty_iff image_iff insertCI insertE) 
   then have "card {y \<in> (insert x ` Pow F) . card y = 1} = 1"
     using empty_iff imageI is_singletonI is_singletonI' is_singleton_altdef (* LONG *)
     by (metis (full_types, lifting) Collect_empty_eq_bot Pow_bottom bot_empty_eq  mem_Collect_eq)  
   then have " {y \<in> (insert x ` Pow F) . card y = 1} = {{x}}"
     using single card_1_singletonE card_eq_0_iff
     by (smt empty_Collect_eq mem_Collect_eq singletonD zero_neq_one) 
   then have split2:"{y \<in> Pow (insert x F) . card y = 1} = {y \<in> (Pow F) . card y = 1} \<union> {{x}}" 
     using split by simp
   then show ?case 
   proof (cases "x \<in> F")
     case True
     then show ?thesis using insert.hyps(2) by auto
   next
     case False
     then have "{y \<in> (Pow F) . card y = 1} \<inter> {{x}} = {}" by blast
     then have fact:"card {y \<in> Pow (insert x F) . card y = 1} = 
         card {y \<in> (Pow F) . card y = 1} + card {{x}}" 
       using split2 card_Un_disjoint insert.hyps(1) by auto 
     have "card (insert x F) = card F + 1" 
       using False card_insert_disjoint by (metis Suc_eq_plus1 insert.hyps(1)) 
     then show ?thesis using fact insert.hyps(3) by auto
   qed
 qed
 
 lemma elem_exists_non_empty_set:
   assumes "card A > 0"
   obtains x where "x \<in> A"
   using assms card_gt_0_iff by fastforce
 
 lemma set_self_img_compr: "{a | a . a \<in> A} = A"
   by blast 
 
 lemma card_subset_not_gt_card: "finite A \<Longrightarrow> card ps > card A \<Longrightarrow> \<not> (ps \<subseteq> A)"
   using card_mono leD by auto
 
 lemma card_inter_lt_single: "finite A \<Longrightarrow> finite B \<Longrightarrow> card (A \<inter> B) \<le> card A"
   by (simp add: card_mono)
 
 lemma set_diff_non_empty_not_subset: 
   assumes "A \<subseteq> (B - C)"
   assumes "C \<noteq> {}"
   assumes "A \<noteq> {}" 
   assumes "B \<noteq> {}"
   shows " \<not> (A \<subseteq> C)"
 proof (rule ccontr)
   assume " \<not> \<not> (A \<subseteq> C)"
   then have a: "\<And> x . x \<in> A \<Longrightarrow> x \<in> C" by blast
   thus False using a assms by blast 
 qed
 
 lemma set_card_diff_ge_zero: "finite A \<Longrightarrow> finite B \<Longrightarrow> A \<noteq> B \<Longrightarrow> card A = card B \<Longrightarrow> 
     card (A - B) > 0"
   by (meson Diff_eq_empty_iff card_0_eq card_subset_eq finite_Diff neq0_conv)
 
 lemma set_filter_diff: "{a \<in> A . P a } - {x} = {a \<in> (A - {x}) . (P a )}"
   by (auto)
 
 lemma set_filter_diff_card: "card ({a \<in> A . P a } - {x}) = card {a \<in> (A - {x}) . (P a )}"
   by (simp add: set_filter_diff)
 
 lemma obtain_subset_with_card_int_n:
   assumes "(n ::int) \<le> of_nat (card S)"
   assumes "(n ::int) \<ge> 0"
   obtains T where "T \<subseteq> S" "of_nat (card T) = (n ::int)" "finite T"
   using obtain_subset_with_card_n assms
   by (metis nonneg_int_cases of_nat_le_iff)
 
 lemma transform_filter_img_empty_rm: 
   assumes "\<And> g . g \<in> G \<Longrightarrow> g \<noteq> {}"
   shows "{g - {x} | g. g \<in> G \<and> g \<noteq> {x}} = {g - {x} | g. g \<in> G } - {{}}"
 proof -
   let ?f = "\<lambda> g . g - {x}"
   have "\<And> g . g \<in> G \<Longrightarrow> g \<noteq> {x} \<longleftrightarrow> ?f g \<noteq> {}" using assms
     by (metis Diff_cancel Diff_empty Diff_insert0 insert_Diff) 
   thus ?thesis by auto
 qed
 
 lemma bij_betw_inter_subsets: "bij_betw f A B \<Longrightarrow> a1 \<subseteq> A \<Longrightarrow> a2 \<subseteq> A 
     \<Longrightarrow> f ` (a1 \<inter> a2) = (f ` a1) \<inter> (f ` a2)"
   by (meson bij_betw_imp_inj_on inj_on_image_Int)
 
 text\<open>Partition related set theory lemmas\<close>
 
 lemma partition_on_remove_pt: 
   assumes "partition_on A G"
   shows "partition_on (A - {x}) {g - {x} | g. g \<in> G \<and> g \<noteq> {x}}"
 proof (intro partition_onI) 
   show "\<And>p. p \<in> {g - {x} |g. g \<in> G \<and> g \<noteq> {x}} \<Longrightarrow> p \<noteq> {}"
     using assms partition_onD3 subset_singletonD by force
   let ?f =  "(\<lambda> g . g - {x})"
   have un_img: "\<Union>({?f g | g. g \<in> G }) = ?f (\<Union> G)" by blast
   have empty: "\<Union> {g - {x} |g. g \<in> G \<and> g \<noteq> {x}} = \<Union>({g - {x} | g. g \<in> G } - {{}})"
     by blast 
   then have "\<Union>({g - {x} | g. g \<in> G } - {{}}) = \<Union>({g - {x} | g. g \<in> G })" by blast
   then show " \<Union> {g - {x} |g. g \<in> G \<and> g \<noteq> {x}} = A - {x}" using partition_onD1 assms un_img
     by (metis empty) 
   then show "\<And>p p'.
        p \<in> {g - {x} |g. g \<in> G \<and> g \<noteq> {x}} \<Longrightarrow>
        p' \<in> {g - {x} |g. g \<in> G \<and> g \<noteq> {x}} \<Longrightarrow> p \<noteq> p' \<Longrightarrow> p \<inter> p' = {}"
   proof -
     fix p1 p2
     assume p1: "p1 \<in> {g - {x} |g. g \<in> G \<and> g \<noteq> {x}}" 
        and p2: "p2 \<in> {g - {x} |g. g \<in> G \<and> g \<noteq> {x}}"
        and ne: "p1 \<noteq> p2"
     obtain p1' p2' where orig1: "p1 = p1' - {x}" and orig2: "p2 = p2' - {x}" 
        and origne: "p1' \<noteq> p2'" and ne1: "p1' \<noteq> {x}" and ne2:"p2' \<noteq> {x}" and ing1: "p1' \<in> G" 
        and ing2: "p2' \<in> G"
       using p1 p2 using mem_Collect_eq ne by blast 
     then have "p1' \<inter> p2' = {}" using assms partition_onD2 ing1 ing2 origne disjointD by blast
     thus "p1 \<inter> p2 = {}" using orig1 orig2 by blast
   qed
 qed
 
 lemma partition_on_cart_prod:
   assumes "card I > 0"
   assumes "A \<noteq> {}"
   assumes "G \<noteq> {}"
   assumes "partition_on A G"
   shows "partition_on (A \<times> I) {g \<times> I |g. g \<in> G}"
 proof (intro partition_onI)
   show "\<And>p. p \<in> {g \<times> I |g. g \<in> G} \<Longrightarrow> p \<noteq> {}"
     using assms(1) assms(4) partition_onD3 by fastforce
   show "\<Union> {g \<times> I |g. g \<in> G} = A \<times> I"
     by (metis Setcompr_eq_image Sigma_Union assms(4) partition_onD1)
   show "\<And>p p'. p \<in> {g \<times> I |g. g \<in> G} \<Longrightarrow> p' \<in> {g \<times> I |g. g \<in> G} \<Longrightarrow> p \<noteq> p' \<Longrightarrow> p \<inter> p' = {}"
     by (smt (verit, best) Sigma_Int_distrib1 Sigma_empty1 assms(4) mem_Collect_eq partition_onE)
 qed
 
 subsection \<open>Multiset Helpers\<close>
 
 text \<open>Generic Size, count and card helpers\<close>
 
 lemma count_size_set_repr: "size {# x \<in># A . x = g#} = count A g"
   by (simp add: filter_eq_replicate_mset) 
 
 lemma mset_nempty_set_nempty: "A \<noteq> {#} \<longleftrightarrow> (set_mset A) \<noteq> {}"
   by simp
 
 lemma mset_size_ne0_set_card: "size A > 0 \<Longrightarrow> card (set_mset A) > 0"
   using mset_nempty_set_nempty by fastforce 
 
 lemma set_count_size_min: "count A a \<ge> n \<Longrightarrow> size A \<ge> n"
   by (metis (full_types) count_le_replicate_mset_subset_eq size_mset_mono size_replicate_mset)
 
 lemma card_size_filter_eq: "finite A \<Longrightarrow>  card {a \<in> A . P a} = size {#a \<in># mset_set A . P a#}"
   by simp
 
+lemma size_multiset_set_mset_const_count:
+  assumes "card (set_mset A) = ca"
+  assumes "\<And>p. p \<in># A \<Longrightarrow> count A p = ca2"
+  shows "size A =  (ca * ca2)"
+proof -
+  have "size A = (\<Sum> p \<in> (set_mset A) . count A p)" using size_multiset_overloaded_eq by auto
+  then have "size A = (\<Sum> p \<in> (set_mset A) . ca2)" using assms by simp
+  thus ?thesis using assms(1) by auto 
+qed
+
 lemma size_multiset_int_count:
   assumes "of_nat (card (set_mset A)) = (ca :: int)"
   assumes "\<And>p. p \<in># A \<Longrightarrow> of_nat (count A p) = (ca2 :: int)"
   shows "of_nat (size A) =  ((ca :: int) * ca2)"
 proof -
   have "size A = (\<Sum> p \<in> (set_mset A) . count A p)" using size_multiset_overloaded_eq by auto
   then have "of_nat (size A) = (\<Sum> p \<in> (set_mset A) . ca2)" using assms by simp
   thus ?thesis using assms(1) by auto 
 qed
 
 lemma mset_union_size: "size (A \<union># B) = size (A) + size (B - A)"
   by (simp add: union_mset_def)
 
 lemma mset_union_size_inter: "size (A \<union># B) = size (A) + size B - size (A \<inter># B)"
   by (metis diff_add_inverse2 size_Un_Int) 
 
 text \<open>Lemmas for repeat\_mset\<close>
 
 lemma repeat_mset_size [simp]: "size (repeat_mset n A) = n * size A"
   by (induction n) auto
 
 lemma repeat_mset_subset_in:
   assumes "\<And> a . a \<in># A \<Longrightarrow> a \<subseteq> B"
   assumes "X \<in># repeat_mset n A"
   assumes "x \<in> X"
   shows " x \<in> B"
   using assms by (induction n) auto
 
 lemma repeat_mset_not_empty: "n > 0 \<Longrightarrow> A \<noteq> {#} \<Longrightarrow> repeat_mset n A \<noteq> {#}"
   by (induction n) auto
 
 lemma elem_in_repeat_in_original: "a \<in># repeat_mset n A \<Longrightarrow> a \<in># A"
   by (metis count_inI count_repeat_mset in_countE mult.commute mult_zero_left nat.distinct(1))
 
 lemma elem_in_original_in_repeat: "n > 0 \<Longrightarrow> a \<in># A \<Longrightarrow> a \<in># repeat_mset n A"
   by (metis count_greater_zero_iff count_repeat_mset nat_0_less_mult_iff)
 
 text \<open>Lemmas on image and filter for multisets\<close>
 
 lemma multiset_add_filter_size: "size {# a \<in># (A1 + A2) . P a #} = size {# a \<in># A1 . P a #} + 
     size {# a \<in># A2 . P a #}" 
   by simp
 
 lemma size_filter_neg: "size {#a \<in># A . P a #} = size A - size {# a \<in># A . \<not> P a #}"
   using size_filter_mset_lesseq size_union union_filter_mset_complement
   by (metis ordered_cancel_comm_monoid_diff_class.le_imp_diff_is_add) 
 
 lemma filter_filter_mset_cond_simp: 
   assumes "\<And> a . P a \<Longrightarrow> Q a"
   shows "filter_mset P A = filter_mset P (filter_mset Q A)"
 proof -
   have "filter_mset P (filter_mset Q A) = filter_mset (\<lambda> a. Q a \<and> P a) A" 
     by (simp add: filter_filter_mset)
   thus ?thesis using assms
     by (metis (mono_tags, lifting) filter_mset_cong)
 qed
 
 lemma filter_filter_mset_ss_member: "filter_mset (\<lambda> a . {x, y} \<subseteq> a) A = 
   filter_mset (\<lambda> a . {x, y} \<subseteq> a) (filter_mset (\<lambda> a . x \<in> a) A)"
 proof - 
   have filter: "filter_mset (\<lambda> a . {x, y} \<subseteq> a) (filter_mset (\<lambda> a . x \<in> a) A) = 
     filter_mset (\<lambda> a . x \<in> a \<and> {x, y} \<subseteq> a) A" by (simp add: filter_filter_mset)
   have "\<And> a. {x, y} \<subseteq> a \<Longrightarrow> x \<in> a" by simp
   thus ?thesis using filter by auto
 qed
 
 lemma multiset_image_do_nothing: "(\<And> x .x \<in># A \<Longrightarrow> f x = x) \<Longrightarrow> image_mset f A = A"
   by (induct A) auto
 
 lemma set_mset_filter: "set_mset {# f a . a \<in># A #} = {f a | a. a \<in># A}"
   by (simp add: Setcompr_eq_image)  
 
 lemma mset_exists_imply: "x \<in># {# f a . a \<in># A #} \<Longrightarrow> \<exists> y \<in># A . x = f y"
   by auto
 
 lemma filter_mset_image_mset:
   "filter_mset P (image_mset f A) = image_mset f (filter_mset (\<lambda>x. P (f x)) A)"
   by (induction A) auto
 
 lemma mset_bunion_filter: "{# a \<in># A . P a \<or> Q a #} = {# a \<in># A . P a #} \<union># {# a \<in># A . Q a #}" 
   by (rule multiset_eqI) simp
 
 lemma mset_inter_filter: "{# a \<in># A . P a \<and> Q a #} = {# a \<in># A . P a #} \<inter># {# a \<in># A . Q a #}" 
   by (rule multiset_eqI) simp
 
 lemma image_image_mset: "image_mset (\<lambda> x . f x) (image_mset (\<lambda> y . g y) A) = 
     image_mset (\<lambda> x. f (g x)) A"
   by simp
 
 text \<open>Big Union over multiset helpers\<close>
 
 lemma mset_big_union_obtain: 
   assumes "x \<in># \<Sum>\<^sub># A"
   obtains a where "a \<in># A" and "x \<in># a"
   using assms by blast
 
 lemma size_big_union_sum: "size (\<Sum>\<^sub># (M :: 'a multiset multiset)) = (\<Sum>x \<in>#M . size x)"
   by (induct M) auto
 
 text \<open>Cartesian Product on Multisets\<close>
 
 lemma size_cartesian_product_singleton [simp]: "size ({#a#} \<times># B) = size B" 
   by (simp add: Times_mset_single_left)  
 
 lemma size_cartesian_product_singleton_right [simp]: "size (A \<times># {#b#}) = size A"
   by (simp add: Times_mset_single_right)
 
 lemma size_cartesian_product_empty [simp]: "size (A \<times># {#}) = 0"
   by simp
 
 lemma size_add_elem_step_eq: 
   assumes "size (A \<times># B) = size A * size B" 
   shows "size (add_mset x A \<times># B) = size (add_mset x A) * size B"
 proof -
   have "(add_mset x A \<times># B) = A \<times># B + {#x#} \<times># B"
     by (metis Sigma_mset_plus_distrib1 add_mset_add_single) 
   then have "size (add_mset x A \<times># B) = size (A \<times># B) + size B" by auto
   also have "... = size A * size B + size B"
     by (simp add: assms)
   finally have "size (add_mset x A \<times># B) = (size A + 1) * size B"
     by auto
   thus ?thesis by simp
 qed
 
 lemma size_cartesian_product: "size (A \<times># B) = size A * size B"
   by (induct A) (simp_all add: size_add_elem_step_eq)
  
 lemma cart_prod_distinct_mset:
   assumes assm1: "distinct_mset A"
   assumes assm2: "distinct_mset B"
   shows "distinct_mset (A \<times># B)"
   unfolding distinct_mset_count_less_1
 proof (rule allI)
   fix x
   have count_mult: "count (A \<times># B) x = count A (fst x) * count B (snd x)" 
     using count_Sigma_mset by (metis prod.exhaust_sel) 
   then have "count A (fst x) * count B (snd x) \<le> 1" using assm1 assm2 
     unfolding distinct_mset_count_less_1 using mult_le_one by blast 
   thus "count (A \<times># B) x \<le> 1" using count_mult by simp
 qed
 
 lemma cart_product_single_intersect: "x1 \<noteq> x2 \<Longrightarrow> ({#x1#} \<times># A) \<inter># ({#x2#} \<times># B) = {#}"
   using multiset_inter_single by fastforce
 
 lemma size_union_distinct_cart_prod: "x1 \<noteq> x2 \<Longrightarrow> size (({#x1#} \<times># A) \<union># ({#x2#} \<times># B)) = 
     size ({#x1#} \<times># A) + size ({#x2#} \<times># B)"
   by (simp add: cart_product_single_intersect size_Un_disjoint) 
 
 lemma size_Union_distinct_cart_prod: "distinct_mset M \<Longrightarrow> 
     size (\<Sum>p\<in>#M. ({#p#} \<times># B)) = size (M) * size (B)"
   by (induction M) auto
 
 lemma size_Union_distinct_cart_prod_filter: "distinct_mset M \<Longrightarrow> 
     (\<And> p . p \<in># M \<Longrightarrow> size ({# b \<in># B . P p b #}) = c) \<Longrightarrow> 
     size (\<Sum>p\<in>#M. ({#p#} \<times># {# b \<in># B . P p b #})) = size (M) * c"
   by (induction M) auto
 
 lemma size_Union_distinct_cart_prod_filter2: "distinct_mset V \<Longrightarrow> 
     (\<And> b . b \<in># B \<Longrightarrow> size ({# v \<in># V . P v b #}) = c) \<Longrightarrow> 
     size (\<Sum>b\<in>#B. ( {# v \<in># V . P v b #} \<times># {#b#})) = size (B) * c"
   by (induction B) auto
 
 lemma cart_product_add_1: "(add_mset a A) \<times># B = ({#a#} \<times># B) + (A \<times># B)"
   by (metis Sigma_mset_plus_distrib1 add_mset_add_single union_commute)
 
 lemma cart_product_add_1_filter: "{#m \<in># ((add_mset a M) \<times># N) . P m #} = 
     {#m \<in># (M \<times># N) . P m #} + {#m \<in># ({#a#} \<times>#  N) . P m #}"
   unfolding add_mset_add_single [of a M] Sigma_mset_plus_distrib1
   by (simp add: Times_mset_single_left)
 
 lemma cart_product_add_1_filter2: "{#m \<in># (M \<times># (add_mset b N)) . P m #} = 
     {#m \<in># (M \<times># N) . P m #} + {#m \<in># (M \<times>#  {#b#}) . P m #}"
   unfolding add_mset_add_single [of b N] Sigma_mset_plus_distrib1
   by (metis Times_insert_left Times_mset_single_right add_mset_add_single filter_union_mset)
 
 lemma cart_prod_singleton_right_gen: 
   assumes "\<And> x . x \<in># (A \<times># {#b#}) \<Longrightarrow> P x \<longleftrightarrow> Q (fst x)"
   shows "{#x \<in># (A \<times># {#b#}). P x#} = {# a \<in># A . Q a#} \<times># {#b#}"
   using assms
 proof (induction A)
   case empty
   then show ?case by simp
 next
   case (add x A)
   have "add_mset x A \<times># {#b#} = add_mset (x, b) (A \<times># {#b#})"
     by (simp add: Times_mset_single_right) 
   then have lhs: "filter_mset P (add_mset x A \<times># {#b#}) = filter_mset P (A \<times># {#b#}) + 
     filter_mset P {#(x, b)#}" by simp
   have rhs: "filter_mset Q (add_mset x A) \<times># {#b#} = filter_mset Q A \<times># {#b#} + 
     filter_mset Q {#x#} \<times># {#b#}"
     by (metis Sigma_mset_plus_distrib1 add_mset_add_single filter_union_mset)
   have "filter_mset P {#(x, b)#} = filter_mset Q {#x#} \<times># {#b#}"
     using add.prems by fastforce
   then show ?case using lhs rhs add.IH add.prems by force 
 qed
 
 lemma cart_prod_singleton_left_gen: 
   assumes "\<And> x . x \<in># ({#a#} \<times># B) \<Longrightarrow> P x \<longleftrightarrow> Q (snd x)"
   shows "{#x \<in># ({#a#} \<times># B). P x#} = {#a#} \<times># {#b \<in># B . Q b#}"
   using assms
 proof (induction B)
   case empty
   then show ?case by simp
 next
   case (add x B)
   have lhs: "filter_mset P ({#a#} \<times># add_mset x B) = filter_mset P ({#a#} \<times># B) + 
     filter_mset P {#(a, x)#}"
     by (simp add: cart_product_add_1_filter2) 
   have rhs: "{#a#} \<times># filter_mset Q (add_mset x B) = {#a#} \<times># filter_mset Q B + 
     {#a#} \<times># filter_mset Q {#x#}"
     using add_mset_add_single filter_union_mset by (metis Times_mset_single_left image_mset_union) 
   have "filter_mset P {#(a, x)#} = {#a#} \<times># filter_mset Q {#x#}"
     using add.prems by fastforce
   then show ?case using lhs rhs add.IH add.prems by force 
 qed
 
 lemma cart_product_singleton_left: "{#m \<in># ({#a#} \<times>#  N) . fst m \<in> snd m #} = 
   ({#a#} \<times># {# n \<in># N . a \<in> n #})" (is "?A = ?B")
 proof -
   have stmt: "\<And>m. m \<in># ({#a#} \<times># N) \<Longrightarrow> fst m \<in> snd m \<longleftrightarrow> a \<in> snd m"
     by (simp add: mem_Times_mset_iff)
   thus ?thesis by (metis (no_types, lifting) Sigma_mset_cong stmt cart_prod_singleton_left_gen)
 qed
 
 lemma cart_product_singleton_right: "{#m \<in># (N \<times># {#b#}) . fst m \<in> snd m #} = 
   ({# n \<in># N . n \<in> b #} \<times># {# b #})" (is "?A = ?B")
 proof - 
   have stmt: "\<And>m. m \<in># (N \<times># {#b#}) \<Longrightarrow> fst m \<in> snd m \<longleftrightarrow> fst m \<in>b"
     by (simp add: mem_Times_mset_iff)
   thus ?thesis by (metis (no_types, lifting) Sigma_mset_cong stmt cart_prod_singleton_right_gen)
 qed
 
 lemma cart_product_add_1_filter_eq: "{#m \<in># ((add_mset a M) \<times># N) . (fst m \<in> snd m) #} = 
     {#m \<in># (M \<times># N) . (fst m \<in> snd m) #} + ({#a#} \<times># {# n \<in># N . a \<in> n #})"
   unfolding add_mset_add_single [of a M] Sigma_mset_plus_distrib1
   using cart_product_singleton_left cart_product_add_1_filter by fastforce 
 
 lemma cart_product_add_1_filter_eq_mirror: "{#m \<in># M \<times># (add_mset b N) . (fst m \<in> snd m) #} = 
     {#m \<in># (M \<times># N) . (fst m \<in> snd m) #} + ({# n \<in># M . n \<in> b #} \<times># {#b#})"
   unfolding add_mset_add_single [of b N] Sigma_mset_plus_distrib1 (* longish *)
   by (metis (no_types) add_mset_add_single cart_product_add_1_filter2 cart_product_singleton_right) 
 
 lemma set_break_down_left:
   shows "{# m \<in># (M \<times># N) . (fst m) \<in> (snd m)  #} = (\<Sum>m\<in>#M. ({#m#} \<times># {#n \<in># N. m \<in> n#}))"
   by (induction M) (auto simp add: cart_product_add_1_filter_eq)
 
 lemma set_break_down_right:
   shows "{# x \<in># M \<times># N . (fst x) \<in> (snd x)  #} = (\<Sum>n\<in>#N. ({#m \<in># M. m \<in> n#} \<times># {#n#}))"
   by (induction N) (auto simp add: cart_product_add_1_filter_eq_mirror)
 
 text \<open>Reasoning on sums of elements over multisets\<close>
 
 lemma sum_over_fun_eq: 
   assumes "\<And> x . x \<in># A \<Longrightarrow> f x = g x" 
   shows "(\<Sum>x \<in># A . f(x)) = (\<Sum> x \<in># A . g (x))"
   using assms by auto
 
+lemma sum_mset_add_diff_nat: 
+  fixes x:: 'a and  f g :: "'a \<Rightarrow> nat"
+  assumes "\<And>x . x \<in># A \<Longrightarrow> f x \<ge> g x"
+  shows "(\<Sum> x \<in># A. f x - g x) = (\<Sum> x \<in># A . f x) -  (\<Sum> x \<in># A . g x)"
+  using assms by (induction A) (simp_all add: sum_mset_mono)
+
+lemma sum_mset_add_diff_int: 
+  fixes x:: 'a and  f g :: "'a \<Rightarrow> int"
+  shows "(\<Sum> x \<in># A. f x - g x) = (\<Sum> x \<in># A . f x) -  (\<Sum> x \<in># A . g x)"
+  by (induction A) (simp_all add: sum_mset_mono)
+
 context ring_1
 begin
 
 lemma sum_mset_add_diff: "(\<Sum> x \<in># A. f x - g x) = (\<Sum> x \<in># A . f x) -  (\<Sum> x \<in># A . g x)"
   by (induction A) (auto simp add: algebra_simps)
 
 end
 
-context ordered_ring
+context ordered_semiring
 begin
 
 lemma sum_mset_ge0:"(\<And> x . f x \<ge> 0) \<Longrightarrow> (\<Sum> x \<in># A. f x ) \<ge> 0"
 proof (induction A)
   case empty
   then show ?case by simp
 next
   case (add x A)
   then have hyp2: "0 \<le> sum_mset (image_mset f A)" by blast
   then have " sum_mset (image_mset f (add_mset x A)) =  sum_mset (image_mset f  A) + f x"
     by (simp add: add_commute) 
   then show ?case
     by (simp add: add.IH add.prems)
 qed
 
 lemma sum_order_add_mset: "(\<And> x . f x \<ge> 0) \<Longrightarrow> (\<Sum> x \<in># A. f x ) \<le> (\<Sum> x \<in># add_mset a A. f x )"
-  by simp
+  by (simp add: local.add_increasing)
 
 lemma sum_mset_0_left: "(\<And> x . f x \<ge> 0) \<Longrightarrow> (\<Sum> x \<in># A. f x ) = 0 \<Longrightarrow> (\<forall> x \<in># A .f x = 0)"
   apply (induction A)
    apply auto
     using local.add_nonneg_eq_0_iff sum_mset_ge0 apply blast
     using local.add_nonneg_eq_0_iff sum_mset_ge0 by blast
 
 lemma sum_mset_0_iff_ge_0:
   assumes "(\<And> x . f x \<ge> 0)"
   shows "(\<Sum> x \<in># A. f x ) = 0 \<longleftrightarrow> (\<forall> x \<in> set_mset A .f x = 0)"
   using sum_mset_0_left assms by auto 
 
 end
 
 lemma mset_set_size_card_count: "(\<Sum>x \<in># A. x) = (\<Sum>x \<in> set_mset A . x * (count A x))"
 proof (induction A)
   case empty
   then show ?case by simp
 next
   case (add y A)
   have lhs: "(\<Sum>x\<in>#add_mset y A. x) = (\<Sum>x\<in># A. x) + y" by simp
   have rhs: "(\<Sum>x\<in>set_mset (add_mset y A). x * count (add_mset y A) x) = 
       (\<Sum>x\<in>(insert y (set_mset A)) . x * count (add_mset y A) x)"
     by simp 
   then show ?case 
   proof (cases "y \<in># A")
     case True
     have x_val: "\<And> x . x \<in> (insert y (set_mset A)) \<Longrightarrow> x \<noteq> y \<Longrightarrow> 
         x* count (add_mset y A) x = x * (count A x)" 
       by auto 
     have y_count: "count (add_mset y A) y = 1 + count A y" 
       using True count_inI by fastforce
     then have "(\<Sum>x\<in>set_mset (add_mset y A). x * count (add_mset y A) x) = 
         (y * (count (add_mset y A) y)) + (\<Sum>x\<in>(set_mset A) - {y}. x * count A x)" 
       using x_val finite_set_mset sum.cong sum.insert rhs
       by (smt DiffD1 Diff_insert_absorb insert_absorb mk_disjoint_insert sum.insert_remove) 
     then have s1: "(\<Sum>x\<in>set_mset (add_mset y A). x * count (add_mset y A) x) = 
         y + y * (count A y) + (\<Sum>x\<in>(set_mset A) - {y}. x * count A x)" 
       using y_count by simp
     then have "(\<Sum>x\<in>set_mset (add_mset y A). x * count (add_mset y A) x) = 
         y + (\<Sum>x\<in>insert y ((set_mset A) - {y} ) . x * count A x)" 
       by (simp add: sum.insert_remove) 
     then have "(\<Sum>x\<in>set_mset (add_mset y A). x * count (add_mset y A) x) = 
         y + (\<Sum>x\<in>(set_mset A) . x * count A x)"
       by (simp add:  True insert_absorb)
     then show ?thesis using lhs add.IH
       by linarith 
   next
     case False
     have x_val: "\<And> x . x \<in> set_mset A \<Longrightarrow> x* count (add_mset y A) x = x * (count A x)" 
       using False by auto 
     have y_count: "count (add_mset y A) y = 1" using False count_inI by fastforce
     have lhs: "(\<Sum>x\<in>#add_mset y A. x) = (\<Sum>x\<in># A. x) + y" by simp
     have "(\<Sum>x\<in>set_mset (add_mset y A). x * count (add_mset y A) x) = 
         (y * count (add_mset y A) y) + (\<Sum>x\<in>set_mset A. x * count A x)" 
       using x_val rhs by (metis (no_types, lifting) False finite_set_mset sum.cong sum.insert) 
     then have "(\<Sum>x\<in>set_mset (add_mset y A). x * count (add_mset y A) x) = 
         y + (\<Sum>x\<in>set_mset A. x * count A x)" 
       using y_count by simp 
     then show ?thesis using lhs add.IH by linarith 
   qed
 qed
 
 subsection \<open>Partitions on Multisets\<close>
 
 text \<open>A partition on a multiset A is a multiset of multisets, where the sum over P equals A and the 
 empty multiset is not in the partition. Based off set partition definition. 
 We note that unlike set partitions, there is no requirement for elements in the multisets to be 
 distinct due to the definition of union on multisets \cite{benderPartitionsMultisets1974}\<close>
 
 lemma mset_size_partition_dep: "size {# a \<in># A . P a \<or> Q a #} = 
     size {# a \<in># A . P a #} +  size {# a \<in># A . Q a #} -  size {# a \<in># A . P a \<and> Q a #}"
   by (simp add: mset_bunion_filter mset_inter_filter mset_union_size_inter) 
 
 definition partition_on_mset :: "'a multiset \<Rightarrow> 'a multiset multiset \<Rightarrow> bool" where
 "partition_on_mset A P \<longleftrightarrow> \<Sum>\<^sub>#P = A \<and> {#} \<notin># P"
 
 lemma partition_on_msetI [intro]: "\<Sum>\<^sub>#P = A \<Longrightarrow> {#} \<notin># P \<Longrightarrow> partition_on_mset A P"
   by (simp add: partition_on_mset_def)
 
 lemma partition_on_msetD1: "partition_on_mset A P \<Longrightarrow> \<Sum>\<^sub>#P = A"
   by (simp add: partition_on_mset_def)
 
 lemma partition_on_msetD2: "partition_on_mset A P \<Longrightarrow> {#} \<notin>#  P"
   by (simp add: partition_on_mset_def)
 
 lemma partition_on_mset_empty: "partition_on_mset {#} P \<longleftrightarrow> P = {#}"
   unfolding partition_on_mset_def
   using multiset_nonemptyE by fastforce
 
 lemma partition_on_mset_all: "A \<noteq> {#} \<Longrightarrow> partition_on_mset A {#A #}"
   by (simp add: partition_on_mset_def)
 
 lemma partition_on_mset_singletons: "partition_on_mset A (image_mset (\<lambda> x . {#x#}) A)"
   by (auto simp: partition_on_mset_def)
 
 lemma partition_on_mset_not_empty: "A \<noteq> {#} \<Longrightarrow> partition_on_mset A P \<Longrightarrow> P \<noteq> {#}"
   by (auto simp: partition_on_mset_def)
 
 lemma partition_on_msetI2: "\<Sum>\<^sub>#P = A \<Longrightarrow> (\<And> p . p \<in># P \<Longrightarrow> p \<noteq> {#}) \<Longrightarrow> partition_on_mset A P"
   by (auto simp: partition_on_mset_def)
 
 lemma partition_on_mset_elems: "partition_on_mset A P \<Longrightarrow> p1 \<in># P \<Longrightarrow> x \<in># p1 \<Longrightarrow> x \<in># A"
   by (auto simp: partition_on_mset_def)
 
 lemma partition_on_mset_sum_size_eq: "partition_on_mset A P \<Longrightarrow> (\<Sum>x \<in># P. size x) = size A"
   by (metis partition_on_msetD1 size_big_union_sum)
 
 lemma partition_on_mset_card: assumes "partition_on_mset A P" shows " size P \<le> size A"
 proof (rule ccontr)
   assume "\<not> size P \<le> size A"
   then have a: "size P > size A" by simp
   have "\<And> x . x \<in># P \<Longrightarrow> size x > 0" using partition_on_msetD2
     using assms nonempty_has_size by auto 
   then have " (\<Sum>x \<in># P. size x) \<ge> size P"
     by (metis leI less_one not_less_zero size_eq_sum_mset sum_mset_mono) 
   thus False using a partition_on_mset_sum_size_eq
     using assms by fastforce 
 qed
 
 lemma partition_on_mset_count_eq: "partition_on_mset A P \<Longrightarrow> a \<in># A \<Longrightarrow> 
     (\<Sum>x \<in># P. count x a) = count A a"
   by (metis count_sum_mset partition_on_msetD1)
 
 lemma partition_on_mset_subsets: "partition_on_mset A P \<Longrightarrow> x \<in># P \<Longrightarrow> x \<subseteq># A"
   by (auto simp add: partition_on_mset_def)
 
 lemma partition_on_mset_distinct: 
   assumes "partition_on_mset A P"
   assumes "distinct_mset A"
   shows "distinct_mset P"
 proof (rule ccontr)
   assume "\<not> distinct_mset P"
   then obtain p1 where count: "count P p1 \<ge> 2"
     by (metis Suc_1 distinct_mset_count_less_1 less_Suc_eq_le not_less_eq) 
   then have cge: "\<And> x . x \<in># p1 \<Longrightarrow> (\<Sum>p \<in># P. count p x ) \<ge> 2"
     by (smt count_greater_eq_one_iff count_sum_mset_if_1_0 dual_order.trans sum_mset_mono zero_le)
   have elem_in: "\<And> x . x \<in># p1 \<Longrightarrow> x \<in># A" using partition_on_mset_elems
     by (metis count assms(1) count_eq_zero_iff not_numeral_le_zero) 
   have "\<And> x . x \<in># A \<Longrightarrow> count A x = 1" using assms
     by (simp add: distinct_mset_def) 
   thus False 
     using assms partition_on_mset_count_eq cge elem_in count_inI local.count multiset_nonemptyE
     by (metis (mono_tags) not_numeral_le_zero numeral_One numeral_le_iff partition_on_mset_def semiring_norm(69)) 
 qed
 
 lemma partition_on_mset_distinct_disjoint: 
   assumes "partition_on_mset A P"
   assumes "distinct_mset A"
   assumes "p1 \<in># P"
   assumes "p2 \<in># P - {#p1#}"
   shows "p1 \<inter># p2 = {#}"
   using Diff_eq_empty_iff_mset assms diff_add_zero distinct_mset_add multiset_inter_assoc sum_mset.remove
   by (smt partition_on_msetD1 subset_mset.inf.absorb_iff2 subset_mset.le_add_same_cancel1 subset_mset.le_iff_inf)
 
 lemma partition_on_mset_diff: 
   assumes "partition_on_mset A P"
   assumes "Q \<subseteq>#P"
   shows "partition_on_mset (A - \<Sum>\<^sub>#Q) (P - Q)"
   using assms partition_on_mset_def
   by (smt diff_union_cancelL subset_mset.add_diff_inverse sum_mset.union union_iff)
 
 lemma sigma_over_set_partition_count: 
   assumes "finite A"
   assumes "partition_on A P"
   assumes "x \<in># \<Sum>\<^sub># (mset_set (mset_set ` P))"
   shows "count (\<Sum>\<^sub># (mset_set (mset_set ` P))) x = 1" 
 proof - 
   have disj: "disjoint P" using assms partition_onD2 by auto 
   then obtain p where  pin: "p \<in># mset_set (mset_set ` P)" and xin: "x \<in># p"
     using assms by blast 
   then have "count (mset_set (mset_set ` P)) p = 1"
     by (meson count_eq_zero_iff count_mset_set') 
   then have filter: "\<And> p' . p' \<in># ((mset_set (mset_set` P)) - {#p#}) \<Longrightarrow> p \<noteq> p'"
     using count_eq_zero_iff count_single by fastforce  
   have zero: "\<And> p'. p' \<in># mset_set (mset_set ` P) \<Longrightarrow> p' \<noteq> p \<Longrightarrow> count p' x = 0"
   proof (rule ccontr)
     fix p' 
     assume assm: "p' \<in># mset_set (mset_set ` P)" and ne: "p' \<noteq> p"  and n0: "count p' x \<noteq> 0"
     then have xin2: "x \<in># p'"  by auto 
     obtain p1 p2 where p1in: "p1 \<in> P" and p2in: "p2 \<in> P" and  p1eq: "mset_set p1 = p" 
         and p2eq: "mset_set p2 = p'" using assm assms(1) assms(2) pin 
       by (metis (no_types, lifting) elem_mset_set finite_elements finite_imageI image_iff)
     have origne: "p1 \<noteq> p2" using ne p1eq p2eq by auto 
     have "p1 = p2" using partition_onD4 xin xin2
       by (metis assms(2) count_eq_zero_iff count_mset_set' p1eq p1in p2eq p2in) 
     then show False using origne by simp
   qed
   have one: "count p x = 1" using pin xin assms count_eq_zero_iff count_greater_eq_one_iff
     by (metis count_mset_set(3) count_mset_set_le_one image_iff le_antisym) 
   then have "count (\<Sum>\<^sub># (mset_set (mset_set ` P))) x = 
       (\<Sum>p' \<in># (mset_set (mset_set ` P)) . count p' x)" 
     using count_sum_mset by auto
   also have "... = (count p x) + (\<Sum>p' \<in># ((mset_set (mset_set ` P)) - {#p#}) . count p' x)"
     by (metis (mono_tags, lifting) insert_DiffM pin sum_mset.insert)  
   also have "... = 1 + (\<Sum>p' \<in># ((mset_set (mset_set ` P)) - {#p#}) . count p' x)"
     using one by presburger 
   finally have "count (\<Sum>\<^sub># (mset_set (mset_set ` P))) x = 
       1 + (\<Sum>p' \<in># ((mset_set (mset_set ` P)) - {#p#}) . 0)" 
     using zero filter by (metis (mono_tags, lifting) in_diffD sum_over_fun_eq) 
   then show "count (\<Sum>\<^sub># (mset_set (mset_set ` P))) x = 1" by simp
 qed
 
 lemma partition_on_mset_set: 
   assumes "finite A"
   assumes "partition_on A P"
   shows "partition_on_mset (mset_set A) (mset_set (image (\<lambda> x. mset_set x) P))"
 proof (intro partition_on_msetI)
   have partd1: "\<Union>P = A" using assms partition_onD1 by auto 
   have imp: "\<And>x. x \<in># \<Sum>\<^sub># (mset_set (mset_set ` P)) \<Longrightarrow> x \<in># mset_set A"
   proof -
     fix x
     assume "x \<in># \<Sum>\<^sub># (mset_set (mset_set ` P))"
     then obtain p where "p \<in> (mset_set ` P)" and xin: "x \<in># p"
       by (metis elem_mset_set equals0D infinite_set_mset_mset_set mset_big_union_obtain) 
     then have "set_mset p \<in> P"
       by (metis empty_iff finite_set_mset_mset_set image_iff infinite_set_mset_mset_set) 
     then show "x \<in># mset_set A"
       using partd1 xin assms(1) by auto  
   qed
   have imp2: "\<And>x . x \<in># mset_set A \<Longrightarrow> x \<in># \<Sum>\<^sub># (mset_set (mset_set ` P))" 
   proof -
     fix x
     assume "x \<in># mset_set A"
     then have "x \<in> A" by (simp add: assms(1)) 
     then obtain p where "p \<in> P" and "x \<in> p" using assms(2) using partd1 by blast
     then obtain p' where "p' \<in> (mset_set ` P)" and "p' = mset_set p" by blast 
     thus "x \<in># \<Sum>\<^sub># (mset_set (mset_set ` P))" using assms \<open>p \<in> P\<close> \<open>x \<in> p\<close> finite_elements partd1
       by (metis Sup_upper finite_imageI finite_set_mset_mset_set in_Union_mset_iff rev_finite_subset) 
   qed
   have a1: "\<And> x . x \<in># mset_set A \<Longrightarrow> count (mset_set A) x = 1"
     using assms(1) by fastforce 
   then show "\<Sum>\<^sub># (mset_set (mset_set ` P)) = mset_set A"  using imp imp2 a1 
     by (metis assms(1) assms(2) count_eq_zero_iff multiset_eqI sigma_over_set_partition_count)
   have "\<And> p. p \<in> P \<Longrightarrow>  p \<noteq> {} " using assms partition_onD3 by auto 
   then have "\<And> p. p \<in> P \<Longrightarrow>  mset_set p \<noteq> {#}" using mset_set_empty_iff
     by (metis Union_upper assms(1) partd1 rev_finite_subset) 
   then show "{#} \<notin># mset_set (mset_set ` P)"
     by (metis elem_mset_set equals0D image_iff infinite_set_mset_mset_set) 
 qed
 
 lemma partition_on_mset_distinct_inter: 
   assumes "partition_on_mset A P"
   assumes "distinct_mset A"
   assumes "p1 \<in># P" and "p2 \<in># P" and "p1 \<noteq> p2"
   shows "p1 \<inter># p2 = {#}"
   by (metis assms in_remove1_mset_neq partition_on_mset_distinct_disjoint)
 
 lemma partition_on_set_mset_distinct: 
   assumes "partition_on_mset A P"
   assumes "distinct_mset A"
   assumes "p \<in># image_mset set_mset P" 
   assumes "p' \<in># image_mset set_mset P"
   assumes "p \<noteq> p'"
   shows "p \<inter> p' = {}"
 proof -
   obtain p1 where p1in: "p1 \<in># P" and p1eq: "set_mset p1 = p" using assms(3)
     by blast 
   obtain p2 where p2in: "p2 \<in># P" and p2eq: "set_mset p2 = p'" using assms(4) by blast
   have "distinct_mset P" using assms partition_on_mset_distinct by blast 
   then have "p1 \<noteq> p2" using assms using p1eq p2eq by fastforce 
   then have "p1 \<inter># p2 = {#}" using partition_on_mset_distinct_inter
     using assms(1) assms(2) p1in p2in by auto 
   thus ?thesis using p1eq p2eq
     by (metis set_mset_empty set_mset_inter) 
 qed
 
 lemma partition_on_set_mset:
   assumes "partition_on_mset A P"
   assumes "distinct_mset A"
   shows "partition_on (set_mset A) (set_mset (image_mset set_mset P))"
 proof (intro partition_onI)
   show "\<And>p. p \<in># image_mset set_mset P \<Longrightarrow> p \<noteq> {}"
     using assms(1) partition_on_msetD2 by fastforce 
 next
   have "\<And> x . x \<in> set_mset A \<Longrightarrow> x \<in> \<Union> (set_mset (image_mset set_mset P))"
     by (metis Union_iff assms(1) image_eqI mset_big_union_obtain partition_on_msetD1 set_image_mset) 
   then show "\<Union> (set_mset (image_mset set_mset P)) = set_mset A" 
     using set_eqI' partition_on_mset_elems assms by auto
   show "\<And>p p'. p \<in># image_mset set_mset P \<Longrightarrow> p' \<in># image_mset set_mset P \<Longrightarrow> 
       p \<noteq> p' \<Longrightarrow> p \<inter> p' = {}"
     using partition_on_set_mset_distinct assms by blast
 qed
 
 lemma partition_on_mset_eq_imp_eq_carrier:
   assumes "partition_on_mset A P"
   assumes "partition_on_mset B P"
   shows "A = B"
   using assms partition_on_msetD1 by auto 
 
 lemma partition_on_mset_add_single:
   assumes "partition_on_mset A P"
   shows "partition_on_mset (add_mset a A) (add_mset {#a#} P)"
   using assms by (auto simp: partition_on_mset_def)
 
 lemma partition_on_mset_add_part:
   assumes "partition_on_mset A P"
   assumes "X \<noteq> {#}"
   assumes "A + X = A'"
   shows "partition_on_mset A' (add_mset X P)"
   using assms by (auto simp: partition_on_mset_def)
 
 lemma partition_on_mset_add:
   assumes "partition_on_mset A P"
   assumes "X \<in># P"
   assumes "add_mset a X = X'"
   shows "partition_on_mset (add_mset a A) (add_mset X' (P - {#X#}))"
   using add_mset_add_single assms empty_not_add_mset mset_subset_eq_single partition_on_mset_all
   by (smt partition_on_mset_def subset_mset.add_diff_inverse sum_mset.add_mset sum_mset.remove union_iff union_mset_add_mset_left)
 
 lemma partition_on_mset_elem_exists_part:
   assumes "partition_on_mset A P"
   assumes "x \<in># A" 
   obtains p where "p \<in># P" and "x \<in># p"
   using assms in_Union_mset_iff partition_on_msetD2 partition_on_msetI
   by (metis partition_on_mset_eq_imp_eq_carrier)
 
 lemma partition_on_mset_combine: 
   assumes "partition_on_mset A P"
   assumes "partition_on_mset B Q"
   shows "partition_on_mset (A + B) (P + Q)"
   unfolding partition_on_mset_def
   using assms partition_on_msetD1 partition_on_msetD2 by auto
 
 lemma partition_on_mset_split: 
   assumes "partition_on_mset A (P + Q)"
   shows "partition_on_mset (\<Sum>\<^sub>#P) P"
   using  partition_on_mset_def partition_on_msetD2 assms by fastforce 
 end
\ No newline at end of file
diff --git a/thys/Design_Theory/Resolvable_Designs.thy b/thys/Design_Theory/Resolvable_Designs.thy
--- a/thys/Design_Theory/Resolvable_Designs.thy
+++ b/thys/Design_Theory/Resolvable_Designs.thy
@@ -1,204 +1,220 @@
 (* Title: Resolvable_Designs.thy
    Author: Chelsea Edmonds
 *)
 
 section \<open>Resolvable Designs\<close>
 text \<open>Resolvable designs have further structure, and can be "resolved" into a set of resolution 
 classes. A resolution class is a subset of blocks which exactly partitions the point set. 
 Definitions based off the handbook \cite{colbournHandbookCombinatorialDesigns2007}
  and Stinson \cite{stinsonCombinatorialDesignsConstructions2004}.
 This theory includes a proof of an alternate statement of Bose's theorem\<close>
 
 theory Resolvable_Designs imports BIBD
 begin
 
 subsection \<open>Resolutions and Resolution Classes\<close>
 text \<open>A resolution class is a partition of the point set using a set of blocks from the design 
 A resolution is a group of resolution classes partitioning the block collection\<close>
 
 context incidence_system
 begin 
 
 definition resolution_class :: "'a set set \<Rightarrow> bool" where
 "resolution_class S \<longleftrightarrow> partition_on \<V> S \<and> (\<forall> bl \<in> S . bl \<in># \<B>)"
 
 lemma resolution_classI [intro]: "partition_on \<V>  S \<Longrightarrow> (\<And> bl . bl \<in> S \<Longrightarrow> bl \<in># \<B>) 
     \<Longrightarrow> resolution_class S"
   by (simp add: resolution_class_def)
 
 lemma resolution_classD1: "resolution_class S \<Longrightarrow> partition_on \<V> S"
   by (simp add: resolution_class_def)
 
 lemma resolution_classD2: "resolution_class S \<Longrightarrow>  bl \<in> S \<Longrightarrow> bl \<in># \<B>"
   by (simp add: resolution_class_def)
 
 lemma resolution_class_empty_iff: "resolution_class {} \<longleftrightarrow> \<V>  = {}"
   by (auto simp add: resolution_class_def partition_on_def)
 
 lemma resolution_class_complete: "\<V>  \<noteq> {} \<Longrightarrow> \<V>  \<in># \<B> \<Longrightarrow> resolution_class {\<V>}"
   by (auto simp add: resolution_class_def partition_on_space)
 
 lemma resolution_class_union: "resolution_class S \<Longrightarrow> \<Union>S = \<V> "
   by (simp add: resolution_class_def partition_on_def)
 
 lemma (in finite_incidence_system) resolution_class_finite: "resolution_class S \<Longrightarrow> finite S"
   using finite_elements finite_sets by (auto simp add: resolution_class_def)
 
 lemma (in design) resolution_class_sum_card: "resolution_class S \<Longrightarrow> (\<Sum>bl \<in> S . card bl) = \<v>"
   using resolution_class_union finite_blocks
   by (auto simp add: resolution_class_def partition_on_def card_Union_disjoint)
 
 definition resolution:: "'a set multiset multiset \<Rightarrow> bool" where
 "resolution P \<longleftrightarrow> partition_on_mset \<B> P \<and> (\<forall> S \<in># P . distinct_mset S \<and> resolution_class (set_mset S))"
 
 lemma resolutionI : "partition_on_mset \<B> P \<Longrightarrow> (\<And> S . S \<in>#P \<Longrightarrow> distinct_mset S) \<Longrightarrow> 
     (\<And> S . S\<in># P \<Longrightarrow> resolution_class (set_mset S)) \<Longrightarrow> resolution P"
   by (simp add: resolution_def)
 
 lemma (in proper_design) resolution_blocks: "distinct_mset \<B> \<Longrightarrow> disjoint (set_mset \<B>) \<Longrightarrow> 
     \<Union>(set_mset \<B>) = \<V> \<Longrightarrow> resolution {#\<B>#}"
   unfolding resolution_def resolution_class_def partition_on_mset_def partition_on_def
   using design_blocks_nempty blocks_nempty by auto
 
 end
 
 subsection \<open>Resolvable Design Locale\<close>
 text \<open>A resolvable design is one with a resolution P\<close>
 locale resolvable_design = design + 
   fixes partition :: "'a set multiset multiset" ("\<P>")
   assumes resolvable: "resolution \<P>"
 begin
 
 lemma resolutionD1: "partition_on_mset \<B> \<P>"
   using resolvable by (simp add: resolution_def)
 
 lemma resolutionD2: "S \<in>#\<P> \<Longrightarrow> distinct_mset S" 
   using resolvable by (simp  add: resolution_def)
 
 lemma resolutionD3: " S\<in># \<P> \<Longrightarrow> resolution_class (set_mset S)"
   using resolvable by (simp add: resolution_def)
 
 lemma resolution_class_blocks_disjoint: "S \<in># \<P> \<Longrightarrow> disjoint (set_mset S)"
   using resolutionD3 by (simp add: partition_on_def resolution_class_def) 
 
 lemma resolution_not_empty: "\<B> \<noteq> {#} \<Longrightarrow> \<P> \<noteq> {#}"
   using partition_on_mset_not_empty resolutionD1 by auto 
 
 lemma resolution_blocks_subset: "S \<in># \<P> \<Longrightarrow> S \<subseteq># \<B>"
   using partition_on_mset_subsets resolutionD1 by auto
 
 end
 
 lemma (in incidence_system) resolvable_designI [intro]: "resolution \<P> \<Longrightarrow> design \<V> \<B> \<Longrightarrow> 
     resolvable_design \<V> \<B> \<P>"
   by (simp add: resolvable_design.intro resolvable_design_axioms.intro)
 
 subsection \<open>Resolvable Block Designs\<close>
 text \<open>An RBIBD is a resolvable BIBD - a common subclass of interest for block designs\<close>
 locale r_block_design = resolvable_design + block_design
 begin
 lemma resolution_class_blocks_constant_size: "S \<in># \<P> \<Longrightarrow> bl \<in># S \<Longrightarrow> card bl = \<k>"
   by (metis resolutionD3 resolution_classD2 uniform_alt_def_all)
 
 lemma resolution_class_size1: 
   assumes "S \<in># \<P>"
   shows "\<v> = \<k> * size S"
 proof - 
   have "(\<Sum>bl \<in># S . card bl) = (\<Sum>bl \<in> (set_mset S) . card bl)" using resolutionD2 assms
     by (simp add:  sum_unfold_sum_mset)
   then have eqv: "(\<Sum>bl \<in># S . card bl) = \<v>" using resolutionD3 assms resolution_class_sum_card
     by presburger 
   have "(\<Sum>bl \<in># S . card bl) = (\<Sum>bl \<in># S . \<k>)" using resolution_class_blocks_constant_size assms 
     by auto
-  thus ?thesis using eqv by (metis mult.commute sum_mset_constant) 
+  thus ?thesis using eqv by auto
 qed
 
 lemma resolution_class_size2: 
   assumes "S \<in># \<P>"
   shows "size S = \<v> div \<k>"
   using resolution_class_size1 assms
   by (metis nonzero_mult_div_cancel_left not_one_le_zero k_non_zero)
 
 lemma resolvable_necessary_cond_v: "\<k> dvd \<v>"
 proof -
   obtain S where s_in: "S \<in>#\<P>" using resolution_not_empty design_blocks_nempty by blast
   then have "\<k> * size S = \<v>" using resolution_class_size1 by simp 
   thus ?thesis by (metis dvd_triv_left) 
 qed
 
 end
 
 locale rbibd = r_block_design + bibd
  
 begin
 
 lemma resolvable_design_num_res_classes: "size \<P> = \<r>"
 proof - 
   have k_ne0: "\<k> \<noteq> 0" using k_non_zero by auto 
   have f1: "\<b> = (\<Sum>S \<in># \<P> . size S)"
     by (metis partition_on_msetD1 resolutionD1 size_big_union_sum)
   then have "\<b> = (\<Sum>S \<in># \<P> . \<v> div \<k>)" using resolution_class_size2 f1 by auto
   then have f2: "\<b> = (size \<P>) * (\<v> div \<k>)" by simp
   then have "size \<P> = \<b> div (\<v> div \<k>)"
     using b_non_zero by auto 
   then have "size \<P> = (\<b> * \<k>) div \<v>" using f2 resolvable_necessary_cond_v
     by (metis div_div_div_same div_dvd_div dvd_triv_right k_ne0 nonzero_mult_div_cancel_right)
   thus ?thesis using necessary_condition_two
     by (metis nonzero_mult_div_cancel_left not_one_less_zero t_design_min_v) 
 qed
 
 lemma resolvable_necessary_cond_b: "\<r> dvd \<b>"
 proof -
   have f1: "\<b> = (\<Sum>S \<in># \<P> . size S)"
     by (metis partition_on_msetD1 resolutionD1 size_big_union_sum)
   then have "\<b> = (\<Sum>S \<in># \<P> . \<v> div \<k>)" using resolution_class_size2 f1 by auto
   thus ?thesis using resolvable_design_num_res_classes by simp
 qed
 
 subsubsection \<open>Bose's Inequality\<close>
 text \<open>Boses inequality is an important theorem on RBIBD's. This is a proof 
 of an alternate statement of the thm, which does not require a linear algebraic approach, 
 taken directly from Stinson \cite{stinsonCombinatorialDesignsConstructions2004}\<close>
 theorem bose_inequality_alternate: "\<b> \<ge> \<v> + \<r> - 1 \<longleftrightarrow> \<r> \<ge> \<k> + \<Lambda>"
 proof - 
-  have kdvd: "\<k> dvd (\<v> * (\<r> - \<k>))" 
-    using necessary_condition_two by (simp add: right_diff_distrib') 
-  have v_eq: "\<v> = (\<r> * (\<k> - 1) + \<Lambda> ) div \<Lambda>" 
-    using necessary_condition_one index_not_zero by auto
-  have ldvd: " \<And> x. \<Lambda> dvd (x * (\<r> * (\<k> - 1) + \<Lambda>))" 
-    using necessary_condition_one by auto
-  have "(\<b> \<ge> \<v> + \<r> - 1) \<longleftrightarrow> ((\<v> * \<r>) div \<k> \<ge> \<v> + \<r> - 1)"
-    using necessary_condition_two k_non_zero by auto
-  also have  "... \<longleftrightarrow> (((\<v> * \<r>) - (\<v> * \<k>)) div \<k> \<ge> \<r> - 1)"
-    using  k_non_zero div_mult_self3 k_non_zero necessary_condition_two by auto
-  also have f2: " ... \<longleftrightarrow> ((\<v> * ( \<r> - \<k>)) \<ge> \<k> * ( \<r> - 1))" 
-    using k_non_zero kdvd by (auto simp add: int_distrib(3) mult_of_nat_commute) 
-  also have "... \<longleftrightarrow> ((((\<r> * (\<k> - 1) + \<Lambda> ) div \<Lambda>) * (\<r> - \<k>)) \<ge> \<k> * (\<r> - 1))"
+  define k b v l r where intdefs: "k \<equiv> (int \<k>)" "b \<equiv> int \<b>" "v = int \<v>" "l \<equiv> int \<Lambda>" "r \<equiv> int \<r>"
+  have kdvd: "k dvd (v * (r - k))"
+    using intdefs
+    by (simp add: resolvable_necessary_cond_v)
+  have necess1_alt: "l * v - l = r * (k - 1)" using necessary_condition_one intdefs 
+    by (smt (verit) diff_diff_cancel int_ops(2) int_ops(6) k_non_zero nat_mult_1_right of_nat_0_less_iff 
+        of_nat_mult right_diff_distrib' v_non_zero)
+  then have v_eq: "v = (r * (k - 1) + l) div l" 
+    using necessary_condition_one index_not_zero intdefs
+    by (metis diff_add_cancel nonzero_mult_div_cancel_left not_one_le_zero of_nat_mult 
+        unique_euclidean_semiring_with_nat_class.of_nat_div) 
+  have ldvd: " \<And> x. l dvd (x * (r * (k - 1) + l))" 
+    by (metis necess1_alt diff_add_cancel dvd_mult dvd_triv_left) 
+  have "(b \<ge> v + r - 1) \<longleftrightarrow> ((\<v> * r) div k \<ge> v + r - 1)"
+    using necessary_condition_two k_non_zero intdefs
+    by (metis (no_types, lifting) nonzero_mult_div_cancel_right not_one_le_zero of_nat_eq_0_iff of_nat_mult)
+  also have  "... \<longleftrightarrow> (((v * r) - (v * k)) div k \<ge> r - 1)"
+    using  k_non_zero div_mult_self3 k_non_zero necessary_condition_two intdefs
+    by (smt (verit, ccfv_SIG) Euclidean_Division.div_eq_0_iff b_non_zero bibd_block_number mult_is_0 of_nat_eq_0_iff)
+  also have f2: " ... \<longleftrightarrow> ((v * ( r - k)) div k \<ge> ( r - 1))"
+    using int_distrib(3) by (simp add: mult.commute)
+  also have f2: " ... \<longleftrightarrow> ((v * ( r - k)) \<ge> k * ( r - 1))" 
+    using k_non_zero kdvd intdefs by auto
+  also have "... \<longleftrightarrow> ((((r * (k - 1) + l ) div l) * (r - k)) \<ge> k * (r - 1))"
     using v_eq by presburger 
-  also have "... \<longleftrightarrow> ( (\<r> - \<k>) * ((\<r> * (\<k> - 1) + \<Lambda> ) div \<Lambda>) \<ge> (\<k> * (\<r> - 1)))" 
+  also have "... \<longleftrightarrow> ( (r - k) * ((r * (k - 1) + l ) div l) \<ge> (k * (r - 1)))" 
     by (simp add: mult.commute)
-  also have " ... \<longleftrightarrow> ( ((\<r> - \<k>) * (\<r> * (\<k> - 1) + \<Lambda> )) div \<Lambda> \<ge> (\<k> * (\<r> - 1)))"
-    by (metis div_mult_swap dvd_add_triv_right_iff dvd_triv_left necessary_condition_one) 
-  also have " ... \<longleftrightarrow> (((\<r> - \<k>) * (\<r> * (\<k> - 1) + \<Lambda> ))  \<ge>  \<Lambda> * (\<k> * (\<r> - 1)))" 
-    using ldvd by (smt dvd_mult_div_cancel index_not_zero mult_strict_left_mono) 
-  also have "... \<longleftrightarrow> (((\<r> - \<k>) * (\<r> * (\<k> - 1))) + ((\<r> - \<k>) * \<Lambda> )  \<ge>  \<Lambda> * (\<k> * (\<r> - 1)))" 
+  also have " ... \<longleftrightarrow> ( ((r - k) * (r * (k - 1) + l )) div l \<ge> (k * (r - 1)))"
+    using div_mult_swap necessary_condition_one intdefs
+    by (metis diff_add_cancel dvd_triv_left necess1_alt) 
+  also have " ... \<longleftrightarrow> (((r - k) * (r * (k - 1) + l ))  \<ge>  l * (k * (r - 1)))" 
+    using ldvd[of "(r - k)"] dvd_mult_div_cancel index_not_zero mult_strict_left_mono intdefs
+    by (smt (verit) b_non_zero bibd_block_number bot_nat_0.extremum_strict div_0 less_eq_nat.simps(1) 
+mult_eq_0_iff mult_left_le_imp_le mult_left_mono of_nat_0 of_nat_le_0_iff of_nat_le_iff of_nat_less_iff)
+  also have 1: "... \<longleftrightarrow> (((r - k) * (r * (k - 1))) + ((r - k) * l )  \<ge>  l * (k * (r - 1)))" 
     by (simp add: distrib_left) 
-  also have "... \<longleftrightarrow> (((\<r> - \<k>) * \<r> * (\<k> - 1)) \<ge> \<Lambda> * \<k> * (\<r> - 1) - ((\<r> - \<k>) * \<Lambda> ))" 
+  also have "... \<longleftrightarrow> (((r - k) * r * (k - 1)) \<ge> l * k * (r - 1) - ((r - k) * l ))" 
     using mult.assoc by linarith 
-  also have "... \<longleftrightarrow> (((\<r> - \<k>) * \<r> * (\<k> - 1)) \<ge> (\<Lambda> * \<k> * \<r>) - (\<Lambda> * \<k>) - ((\<r> * \<Lambda>) -(\<k> * \<Lambda> )))" 
+  also have "... \<longleftrightarrow> (((r - k) * r * (k - 1)) \<ge> (l * k * r) - (l * k) - ((r * l) -(k * l )))" 
     using distrib_right by (simp add: distrib_left right_diff_distrib' left_diff_distrib') 
-  also have "... \<longleftrightarrow> (((\<r> - \<k>) * \<r> * (\<k> - 1)) \<ge> (\<Lambda> * \<k> * \<r>)  - ( \<Lambda> * \<r>))" 
+  also have "... \<longleftrightarrow> (((r - k) * r * (k - 1)) \<ge> (l * k * r)  - ( l * r))" 
     by (simp add: mult.commute) 
-  also have "... \<longleftrightarrow> (((\<r> - \<k>) * \<r> * (\<k> - 1)) \<ge> (\<Lambda>  * (\<k> * \<r>))  - ( \<Lambda> * \<r>))" 
+  also have "... \<longleftrightarrow> (((r - k) * r * (k - 1)) \<ge> (l  * (k * r))  - ( l * r))" 
     by linarith  
-  also have "... \<longleftrightarrow> (((\<r> - \<k>) * \<r> * (\<k> - 1)) \<ge> (\<Lambda>  * (\<r> * \<k>))  - ( \<Lambda> * \<r>))" 
+  also have "... \<longleftrightarrow> (((r - k) * r * (k - 1)) \<ge> (l  * (r * k))  - ( l * r))" 
     by (simp add: mult.commute)
-  also have "... \<longleftrightarrow> (((\<r> - \<k>) * \<r> * (\<k> - 1)) \<ge> \<Lambda> * \<r> * ( \<k> - 1))"
+  also have "... \<longleftrightarrow> (((r - k) * r * (k - 1)) \<ge> l * r * (k - 1))"
     by (simp add:  mult.assoc int_distrib(4)) 
-  finally have "(\<b> \<ge> \<v> + \<r> - 1) \<longleftrightarrow> (\<r> \<ge> \<k> + \<Lambda>)"
-    using index_lt_replication mult_right_le_imp_le r_gzero
-    by (smt mult_cancel_right k_non_zero) 
+  finally have "(b \<ge> v + r - 1) \<longleftrightarrow> (r \<ge> k + l)"
+    using index_lt_replication mult_right_le_imp_le r_gzero mult_cancel_right k_non_zero intdefs
+    by (smt (z3) of_nat_0_less_iff of_nat_1 of_nat_le_iff of_nat_less_iff)
+  then have "\<b> \<ge> \<v> + \<r> - 1 \<longleftrightarrow> \<r> \<ge> \<k> + \<Lambda>"
+    using k_non_zero le_add_diff_inverse of_nat_1 of_nat_le_iff intdefs by linarith 
   thus ?thesis by simp
 qed
 end
 end
\ No newline at end of file