diff --git a/thys/Fishers_Inequality/Design_Extras.thy b/thys/Fishers_Inequality/Design_Extras.thy
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/Design_Extras.thy
@@ -0,0 +1,620 @@
+(* Title: Design Extras.thy
+   Author: Chelsea Edmonds
+*)
+
+section \<open> Micellaneous Design Extras \<close>
+
+text \<open>Extension's to the author's previous entry on Design Theory \<close>
+
+theory Design_Extras imports Set_Multiset_Extras Design_Theory.BIBD
+begin
+
+subsection \<open>Extensions to existing Locales and Properties \<close>
+
+text \<open>Extend lemmas on intersection number\<close>
+lemma inter_num_max_bound: 
+  assumes "finite b1" "finite b2"
+  shows "b1 |\<inter>| b2 \<le> card b1" "b1 |\<inter>| b2 \<le> card b2"
+  by(simp_all add: assms intersection_number_def card_mono)
+
+lemma inter_eq_blocks_eq_card: "card b1 = card b2 \<Longrightarrow> finite b1 \<Longrightarrow> finite b2 \<Longrightarrow> b1 |\<inter>| b2 = card b1 
+    \<Longrightarrow> b1 = b2"
+  using equal_card_inter_fin_eq_sets intersection_number_def by (metis) 
+
+lemma inter_num_of_eq_blocks: "b1 = b2 \<Longrightarrow> b1 |\<inter>| b2 = card b1"
+  by (simp add: intersection_number_def)
+
+lemma intersect_num_same_eq_size[simp]: "bl |\<inter>| bl = card bl"
+  by (simp add: intersection_number_def)
+
+lemma index_lt_rep_general: "x \<in> ps \<Longrightarrow> B index ps \<le> B rep x"
+  by (simp add: points_index_def point_replication_number_def) 
+    (metis filter_filter_mset_cond_simp size_filter_mset_lesseq subset_iff)
+
+context incidence_system 
+begin
+
+lemma block_size_alt:
+  assumes "bl \<in># \<B>"
+  shows "card bl = card {x \<in> \<V> . x \<in> bl}" 
+proof -
+  have "\<And> x. x \<in> bl \<Longrightarrow> x \<in> \<V>" using wellformed assms by auto
+  thus ?thesis
+    by (metis (no_types, lifting) Collect_cong Collect_mem_eq) 
+qed
+
+lemma complement_image: "\<B>\<^sup>C = image_mset block_complement \<B>"
+  by (simp add: complement_blocks_def)
+
+lemma point_in_block_rep_min_iff:
+  assumes "x \<in> \<V>" 
+  shows "\<exists> bl . bl \<in># \<B> \<and> x \<in> bl \<longleftrightarrow> (\<B> rep x > 0)"
+  using rep_number_g0_exists
+  by (metis block_complement_elem_iff block_complement_inv wellformed)
+
+lemma points_inter_num_rep: 
+  assumes "b1 \<in># \<B>" and "b2 \<in># \<B> - {#b1#}"
+  shows "card {v \<in> \<V> . v \<in> b1 \<and> v \<in> b2} = b1 |\<inter>| b2"
+proof -
+  have "\<And> x. x \<in> b1 \<inter> b2 \<Longrightarrow> x \<in> \<V>" using wellformed assms by auto
+  then have "{v \<in> \<V> . v \<in> (b1 \<inter> b2)} = (b1 \<inter> b2)"
+    by blast 
+  then have "card {v \<in> \<V> . v \<in> b1 \<and> v \<in> b2} = card (b1 \<inter> b2)"
+    by simp 
+  thus ?thesis using assms intersection_number_def by metis 
+qed
+
+text \<open>Extensions on design operation lemmas \<close>
+lemma del_block_b: 
+  "bl \<in># \<B> \<Longrightarrow> size (del_block bl) = \<b> - 1"
+  "bl \<notin># \<B> \<Longrightarrow> size (del_block bl) = \<b>"
+  by (simp_all add: del_block_def size_Diff_singleton)
+
+lemma del_block_points_index: 
+  assumes "ps \<subseteq> \<V>"
+  assumes "card ps = 2"
+  assumes "bl \<in># \<B>"
+  shows "ps \<subseteq> bl \<Longrightarrow> points_index (del_block bl) ps = points_index \<B> ps - 1"
+        "\<not> (ps \<subseteq> bl) \<Longrightarrow> points_index (del_block bl) ps = points_index \<B> ps"
+proof -
+  assume "ps \<subseteq> bl"
+  then show "points_index (del_block bl) ps = points_index \<B> ps - 1"
+    using point_index_diff del_block_def
+    by (metis assms(3) insert_DiffM2 points_index_singleton) 
+next
+  assume "\<not> ps \<subseteq> bl"
+  then show "del_block bl index ps = \<B> index ps"
+    using point_index_diff del_block_def
+    by (metis add_block_def add_block_index_not_in assms(3) insert_DiffM2) 
+qed
+
+end
+
+text \<open>Extensions to properties of design sub types \<close>
+
+context finite_incidence_system
+begin
+
+lemma complete_block_size_eq_points: "bl \<in># \<B> \<Longrightarrow> card bl = \<v> \<Longrightarrow> bl = \<V>"
+  using wellformed by (simp add:  card_subset_eq finite_sets) 
+
+lemma complete_block_all_subsets: "bl \<in># \<B> \<Longrightarrow> card bl = \<v> \<Longrightarrow> ps \<subseteq> \<V> \<Longrightarrow> ps \<subseteq> bl"
+  using complete_block_size_eq_points by auto
+
+lemma del_block_complete_points_index: "ps \<subseteq> \<V> \<Longrightarrow> card ps = 2 \<Longrightarrow> bl \<in># \<B> \<Longrightarrow> card bl = \<v> \<Longrightarrow> 
+  points_index (del_block bl) ps = points_index \<B> ps - 1"
+  using complete_block_size_eq_points del_block_points_index(1) by blast
+
+end
+
+context design
+begin
+
+lemma block_num_rep_bound: "\<b> \<le> (\<Sum> x \<in> \<V>. \<B> rep x)"
+proof -
+  have exists: "\<And> bl. bl \<in># \<B> \<Longrightarrow> (\<exists> x \<in> \<V> . bl \<in># {#b \<in># \<B>. x \<in> b#})" using wellformed
+    using blocks_nempty by fastforce 
+  then have bss: "\<B> \<subseteq># \<Sum>\<^sub># (image_mset (\<lambda> v. {#b \<in># \<B>. v \<in> b#}) (mset_set \<V>))"
+  proof (intro  mset_subset_eqI)
+    fix bl
+    show "count \<B> bl \<le> count (\<Sum>v\<in>#mset_set \<V>. filter_mset ((\<in>) v) \<B>) bl"
+    proof (cases "bl \<in># \<B>")
+      case True
+      then obtain x where xin: "x \<in> \<V>" and blin: "bl \<in># filter_mset ((\<in>) x) \<B>" using exists by auto
+      then have eq: "count \<B> bl = count (filter_mset ((\<in>) x) \<B>) bl" by simp 
+      have "(\<Sum>v\<in>#mset_set \<V>. filter_mset ((\<in>) v) \<B>) = (filter_mset ((\<in>) x) \<B>) + 
+        (\<Sum>v\<in>#(mset_set \<V>) - {#x#}. filter_mset ((\<in>) v) \<B>)"
+        using xin by (simp add: finite_sets mset_set.remove) 
+      then have "count (\<Sum>v\<in>#mset_set \<V>. filter_mset ((\<in>) v) \<B>) bl = count (filter_mset ((\<in>) x) \<B>) bl 
+        +  count (\<Sum>v\<in>#(mset_set \<V>) - {#x#}. filter_mset ((\<in>) v) \<B>) bl"
+        by simp
+      then show ?thesis using eq by linarith 
+    next
+      case False
+      then show ?thesis by (metis count_eq_zero_iff le0)
+    qed
+  qed
+  have "(\<Sum> x \<in> \<V>. \<B> rep x) = (\<Sum> x \<in> \<V>. size ({#b \<in># \<B>. x \<in> b#}))" 
+    by (simp add: point_replication_number_def)
+  also have "... = (\<Sum> x \<in># (mset_set \<V>). size ({#b \<in># \<B>. x \<in> b#}))"
+    by (simp add: sum_unfold_sum_mset) 
+  also have "... = (\<Sum> x \<in># (image_mset (\<lambda> v. {#b \<in># \<B>. v \<in> b#}) (mset_set \<V>)) . size x)"
+    by auto  
+  finally have "(\<Sum> x \<in> \<V>. \<B> rep x) = size (\<Sum>\<^sub># (image_mset (\<lambda> v. {#b \<in># \<B>. v \<in> b#}) (mset_set \<V>)))" 
+    using size_big_union_sum by metis 
+  then show ?thesis using bss
+    by (simp add: size_mset_mono)
+qed
+
+end
+
+context proper_design
+begin
+
+lemma del_block_proper: 
+  assumes "\<b> > 1"
+  shows "proper_design \<V> (del_block bl)"
+proof -
+  interpret d: design \<V> "(del_block bl)"
+    using delete_block_design by simp
+  have "d.\<b> > 0" using del_block_b assms
+    by (metis b_positive zero_less_diff) 
+  then show ?thesis by(unfold_locales) (auto)
+qed
+
+end
+
+context simple_design 
+begin
+
+lemma inter_num_lt_block_size_strict: 
+  assumes "bl1 \<in># \<B>"
+  assumes "bl2 \<in># \<B>"
+  assumes "bl1 \<noteq> bl2"
+  assumes "card bl1 = card bl2"
+  shows "bl1 |\<inter>| bl2 < card bl1" "bl1 |\<inter>| bl2 < card bl2"
+proof -
+  have lt: "bl1 |\<inter>| bl2 \<le> card bl1" using finite_blocks
+    by (simp add: \<open>bl1 \<in># \<B>\<close> \<open>bl2 \<in># \<B>\<close> inter_num_max_bound(1)) 
+  have ne: "bl1 |\<inter>| bl2 \<noteq> card bl1" 
+  proof (rule ccontr, simp)
+    assume "bl1 |\<inter>| bl2 = card bl1"
+    then have "bl1 = bl2" using assms(4) inter_eq_blocks_eq_card assms(1) assms(2) finite_blocks 
+      by blast 
+    then show False using assms(3) by simp
+  qed
+  then show "bl1 |\<inter>| bl2 < card bl1" using lt by simp
+  have "bl1 |\<inter>| bl2 \<noteq> card bl2" using ne by (simp add: assms(4)) 
+  then show "bl1 |\<inter>| bl2 < card bl2" using lt assms(4) by simp
+qed
+
+lemma block_mset_distinct: "distinct_mset \<B>" using simple
+  by (simp add: distinct_mset_def) 
+
+end
+
+context constant_rep_design 
+begin
+
+lemma index_lt_const_rep: 
+  assumes "ps \<subseteq> \<V>"
+  assumes "ps \<noteq> {}"
+  shows "\<B> index ps \<le> \<r>"
+proof -
+  obtain x where xin: "x \<in> ps" using assms by auto
+  then have "\<B> rep x = \<r>"
+    by (meson assms(1) in_mono rep_number_alt_def_all) 
+  thus ?thesis using index_lt_rep_general xin by auto
+qed
+
+end
+
+context t_wise_balance
+begin
+
+lemma  obtain_t_subset_with_point: 
+  assumes "x \<in> \<V>"
+  obtains ps where "ps \<subseteq> \<V>" and "card ps = \<t>" and "x \<in> ps"
+proof (cases "\<t> = 1")
+  case True
+  have "{x} \<subseteq> \<V>" "card {x} = 1" "x \<in> {x}"
+    using assms by simp_all
+  then show ?thesis
+    using True that by blast 
+next
+  case False
+  have "\<t> - 1 \<le> card (\<V> - {x})"
+    by (simp add: assms diff_le_mono finite_sets t_lt_order) 
+  then obtain ps' where psss: "ps' \<subseteq> (\<V> - {x})" and psc: "card ps' = \<t> - 1" 
+    by (meson obtain_subset_with_card_n)
+  then have xs: "(insert x ps') \<subseteq> \<V>"
+    using assms by blast 
+  have xnotin: "x \<notin> ps'" using psss
+    by blast 
+  then have "card (insert x ps') = Suc (card ps')"
+    by (meson \<open>insert x ps' \<subseteq> \<V>\<close> finite_insert card_insert_disjoint finite_sets finite_subset) 
+  then have "card (insert x ps') = card ps' + 1"
+    by presburger 
+  then have xc: "card (insert x ps') = \<t>" using psc
+    using add.commute add_diff_inverse t_non_zero by linarith 
+  have "x \<in> (insert x ps')" by simp
+  then show ?thesis using xs xc that by blast 
+qed
+
+lemma const_index_lt_rep: 
+  assumes "x \<in> \<V>"
+  shows "\<Lambda>\<^sub>t \<le> \<B> rep x"
+proof -
+  obtain ps where psin: "ps \<subseteq> \<V>" and "card ps = \<t>" and xin: "x \<in> ps" 
+    using assms t_lt_order obtain_t_subset_with_point by auto
+  then have "\<B> index ps = \<Lambda>\<^sub>t " using balanced by simp
+  thus ?thesis using index_lt_rep_general xin 
+    by (meson) 
+qed
+
+end
+
+context pairwise_balance
+begin
+
+lemma index_zero_iff: "\<Lambda> = 0 \<longleftrightarrow> (\<forall> bl \<in># \<B> . card bl = 1)"
+proof (auto)
+  fix bl assume l0: "\<Lambda> = 0" assume blin: "bl \<in># \<B>"
+  have "card bl = 1"
+  proof (rule ccontr)
+    assume "card bl \<noteq> 1"
+    then have "card bl \<ge> 2" using block_size_gt_0
+      by (metis Suc_1 Suc_leI blin less_one nat_neq_iff) 
+    then obtain ps where psss: "ps \<subseteq> bl" and pscard: "card ps = 2"
+      by (meson obtain_subset_with_card_n)
+    then have psin: "\<B> index ps \<ge> 1"
+      using blin points_index_count_min by auto
+    have "ps \<subseteq> \<V>" using wellformed psss blin by auto
+    then show False using balanced l0 psin pscard by auto
+  qed
+  thus "card bl = (Suc 0)" by simp
+next
+  assume a: "\<forall>bl\<in>#\<B>. card bl = Suc 0"
+  obtain ps where psss: "ps \<subseteq> \<V>" and ps2: "card ps = 2"
+    by (meson obtain_t_subset_points) 
+  then have "\<And> bl. bl \<in># \<B> \<Longrightarrow> (card ps > card bl)" using a
+    by simp 
+  then have cond: "\<And> bl. bl \<in># \<B> \<Longrightarrow> \<not>( ps \<subseteq>  bl)"
+    by (metis card_mono finite_blocks le_antisym less_imp_le_nat less_not_refl3) 
+  have "\<B> index ps = size {# bl \<in># \<B> . ps \<subseteq> bl #}" by (simp add:points_index_def)
+  then have "\<B> index ps = size {#}" using cond
+    by (metis points_index_0_iff size_empty) 
+  thus "\<Lambda> = 0" using psss ps2 balanced by simp
+qed
+
+lemma count_complete_lt_balance: "count \<B> \<V> \<le> \<Lambda>"
+proof (rule ccontr)
+  assume a: "\<not> count \<B> \<V> \<le> \<Lambda>"
+  then have assm: "count \<B> \<V> > \<Lambda>"
+    by simp
+  then have gt: "size {# bl \<in># \<B> . bl = \<V>#} > \<Lambda>"
+    by (simp add: count_size_set_repr) 
+  obtain ps where psss: "ps \<subseteq> \<V>" and pscard: "card ps = 2" using t_lt_order
+    by (meson obtain_t_subset_points) 
+  then have "{# bl \<in># \<B> . bl = \<V>#} \<subseteq># {# bl \<in># \<B> . ps \<subseteq> bl #}"
+    by (metis a balanced le_refl points_index_count_min) 
+  then have "size {# bl \<in># \<B> . bl = \<V>#} \<le> \<B> index ps " 
+    using points_index_def[of \<B> ps] size_mset_mono by simp
+  thus False using pscard psss balanced gt by auto
+qed
+
+lemma eq_index_rep_imp_complete: 
+  assumes "\<Lambda> = \<B> rep x"
+  assumes "x \<in> \<V>"
+  assumes "bl \<in># \<B>"
+  assumes "x \<in> bl"
+  shows "card bl = \<v>"
+proof -
+  have "\<And> y. y \<in> \<V> \<Longrightarrow> y \<noteq> x \<Longrightarrow> card {x, y} = 2 \<and> {x, y} \<subseteq> \<V>" using assms by simp
+  then have size_eq: "\<And> y. y \<in> \<V> \<Longrightarrow> y \<noteq> x \<Longrightarrow> size {# b \<in># \<B> . {x, y} \<subseteq> b#} = size {# b \<in># \<B> . x \<in> b#}"
+    using point_replication_number_def balanced points_index_def assms by metis 
+  have "\<And> y b. y \<in> \<V> \<Longrightarrow> y \<noteq> x \<Longrightarrow> b \<in># \<B> \<Longrightarrow> {x, y} \<subseteq> b \<longrightarrow> x \<in> b" by simp
+  then have "\<And> y. y \<in> \<V> \<Longrightarrow> y \<noteq> x \<Longrightarrow> {# b \<in># \<B> . {x, y} \<subseteq> b#} \<subseteq># {# b \<in># \<B> . x \<in> b#}" 
+    using multiset_filter_mono2 assms by auto
+  then have eq_sets: "\<And> y. y \<in> \<V> \<Longrightarrow> y \<noteq> x \<Longrightarrow> {# b \<in># \<B> . {x, y} \<subseteq> b#} = {# b \<in># \<B> . x \<in> b#}" 
+    using size_eq by (smt (z3) Diff_eq_empty_iff_mset cancel_comm_monoid_add_class.diff_cancel 
+        size_Diff_submset size_empty size_eq_0_iff_empty subset_mset.antisym) 
+  have "bl \<in># {# b \<in># \<B> . x \<in> b#}" using assms by simp
+  then have "\<And> y. y \<in> \<V> \<Longrightarrow> y \<noteq> x \<Longrightarrow> {x, y} \<subseteq> bl" using eq_sets
+    by (metis (no_types, lifting) Multiset.set_mset_filter mem_Collect_eq) 
+  then have "\<And> y. y \<in> \<V> \<Longrightarrow> y \<in> bl" using assms by blast 
+  then have "bl = \<V>" using wellformed assms(3) by blast 
+  thus ?thesis by simp
+qed
+
+lemma incomplete_index_strict_lt_rep:
+  assumes "\<And> bl. bl \<in># \<B> \<Longrightarrow> incomplete_block bl" 
+  assumes "x \<in> \<V>"
+  assumes "\<Lambda> > 0"
+  shows "\<Lambda> < \<B> rep x"
+proof (rule ccontr)
+  assume "\<not> (\<Lambda> < \<B> rep x)"
+  then have a: "\<Lambda> \<ge> \<B> rep x"
+    by simp
+  then have "\<Lambda> = \<B> rep x" using const_index_lt_rep
+    using assms(2) le_antisym by blast 
+  then obtain bl where xin: "x \<in> bl" and blin: "bl \<in># \<B>"
+    by (metis assms(3) rep_number_g0_exists) 
+  thus False using assms eq_index_rep_imp_complete incomplete_alt_size
+    using \<open>\<Lambda> = \<B> rep x\<close> nat_less_le by blast  
+qed
+
+text \<open>Construct new PBD's from existing PBD's \<close>
+
+lemma remove_complete_block_pbd: 
+  assumes "\<b> \<ge> 2"
+  assumes "bl \<in># \<B>"
+  assumes "card bl = \<v>"
+  shows "pairwise_balance \<V> (del_block bl) (\<Lambda> - 1)"
+proof -
+  interpret pd: proper_design \<V> "(del_block bl)" using assms(1) del_block_proper by simp
+  show ?thesis using t_lt_order assms del_block_complete_points_index 
+    by (unfold_locales) (simp_all)
+qed
+
+lemma remove_complete_block_pbd_alt: 
+  assumes "\<b> \<ge> 2"
+  assumes "bl \<in># \<B>"
+  assumes "bl = \<V>"
+  shows "pairwise_balance \<V> (del_block bl) (\<Lambda> - 1)"
+  using remove_complete_block_pbd assms by blast 
+
+lemma b_gt_index:"\<b> \<ge> \<Lambda>"
+proof (rule ccontr)
+  assume blt: "\<not> \<b> \<ge> \<Lambda>"
+  obtain ps where "card ps = 2" and "ps \<subseteq> \<V>" using t_lt_order
+    by (meson obtain_t_subset_points) 
+  then have "size {#bl \<in># \<B>. ps \<subseteq> bl#} = \<Lambda>" using balanced by (simp add: points_index_def)
+  thus False using blt by auto 
+qed
+
+lemma remove_complete_blocks_set_pbd:
+  assumes "x < \<Lambda>"
+  assumes "size A = x"
+  assumes "A \<subset># \<B>"
+  assumes "\<And> a. a \<in># A \<Longrightarrow> a = \<V>"
+  shows "pairwise_balance \<V> (\<B> - A) (\<Lambda> - x)"
+using assms proof (induct "x" arbitrary: A)
+  case 0
+  then have beq: "\<B> - A = \<B>" by simp
+  have "pairwise_balance \<V> \<B> \<Lambda>" by (unfold_locales)
+  then show ?case using beq by simp
+next
+  case (Suc x)
+  then have "size A > 0" by simp
+  let ?A' = "A - {#\<V>#}"
+  have ss: "?A' \<subset># \<B>"
+    using Suc.prems(3) by (metis diff_subset_eq_self subset_mset.le_less_trans)
+  have sx: "size ?A' = x"
+    by (metis Suc.prems(2) Suc.prems(4) Suc_inject size_Suc_Diff1 size_eq_Suc_imp_elem)
+  have xlt: "x < \<Lambda>"
+    by (simp add: Suc.prems(1) Suc_lessD) 
+  have av: "\<And> a. a \<in># ?A' \<Longrightarrow> a = \<V>" using Suc.prems(4)
+    by (meson in_remove1_mset_neq)
+  then interpret pbd: pairwise_balance \<V> "(\<B> - ?A')" "(\<Lambda> - x)" using Suc.hyps sx ss xlt by simp
+  have "Suc x < \<b>" using Suc.prems(3)
+    by (metis Suc.prems(2) mset_subset_size) 
+  then have "\<b> - x \<ge> 2"
+    by linarith 
+  then have bgt: "size (\<B> - ?A') \<ge> 2" using ss size_Diff_submset
+    by (metis subset_msetE sx)
+  have ar: "add_mset \<V> (remove1_mset \<V> A) = A" using Suc.prems(2) Suc.prems(4)
+    by (metis insert_DiffM size_eq_Suc_imp_elem) 
+  then have db: "pbd.del_block \<V> = \<B> - A" by(simp add: pbd.del_block_def)
+  then have "\<B> - ?A' = \<B> - A + {#\<V>#}" using Suc.prems(2) Suc.prems(4)
+    by (metis (no_types, lifting) Suc.prems(3) ar add_diff_cancel_left' add_mset_add_single add_right_cancel 
+        pbd.del_block_def remove_1_mset_id_iff_notin ss subset_mset.lessE trivial_add_mset_remove_iff) 
+  then have "\<V> \<in># (\<B> - ?A')" by simp 
+  then have "pairwise_balance \<V> (\<B> - A) (\<Lambda> - (Suc x))" using db bgt diff_Suc_eq_diff_pred 
+      diff_commute pbd.remove_complete_block_pbd_alt by presburger
+  then show ?case by simp
+qed
+
+lemma remove_all_complete_blocks_pbd:
+  assumes "count \<B> \<V> < \<Lambda>"
+  shows "pairwise_balance \<V> (removeAll_mset \<V> \<B>) (\<Lambda> - (count \<B> \<V>))" (is "pairwise_balance \<V> ?B ?\<Lambda>")
+proof -
+  let ?A = "replicate_mset (count \<B> \<V>) \<V>"
+  let ?x = "size ?A"
+  have blt: "count \<B> \<V> \<noteq> \<b>" using b_gt_index assms
+    by linarith 
+  have xeq: "?x = count \<B> \<V>" by simp
+  have av: "\<And> a. a \<in># ?A \<Longrightarrow> a = \<V>"
+    by (metis in_replicate_mset)
+  have "?A \<subseteq># \<B>"
+    by (meson count_le_replicate_mset_subset_eq le_eq_less_or_eq)
+  then have "?A \<subset># \<B>" using blt
+    by (metis subset_mset.nless_le xeq) 
+  thus ?thesis using assms av xeq remove_complete_blocks_set_pbd
+    by presburger 
+qed
+
+end
+
+context bibd
+begin
+lemma symmetric_bibdIII: "\<r> = \<k> \<Longrightarrow> symmetric_bibd \<V> \<B> \<k> \<Lambda>"
+  using necessary_condition_one symmetric_condition_1 by (unfold_locales) (simp)
+end
+
+subsection \<open> New Design Locales \<close>
+text \<open> We establish a number of new locales and link them to the existing locale hierarchy
+in order to reason in contexts requiring specific combinations of contexts \<close>
+
+text \<open>Regular t-wise balance \<close>
+locale regular_t_wise_balance = t_wise_balance + constant_rep_design
+begin
+
+lemma reg_index_lt_rep: 
+  shows "\<Lambda>\<^sub>t \<le> \<r>"
+proof -
+  obtain ps where psin: "ps \<subseteq> \<V>" and pst: "card ps = \<t>"
+    by (metis obtain_t_subset_points) 
+  then have ne: "ps \<noteq> {}" using t_non_zero by auto
+  then have "\<B> index ps = \<Lambda>\<^sub>t" using balanced pst psin by simp
+  thus ?thesis using index_lt_const_rep
+    using ne psin by auto 
+qed
+
+end
+
+locale regular_pairwise_balance = regular_t_wise_balance \<V> \<B> 2 \<Lambda> \<r> + pairwise_balance \<V> \<B> \<Lambda>
+  for \<V> and \<B> and \<Lambda> and \<r>
+
+text \<open> Const Intersect Design \<close>
+text \<open> This is the dual of a balanced design, and used extensively in the remaining formalisation \<close>
+
+locale const_intersect_design = proper_design + 
+  fixes \<m> :: nat
+  assumes const_intersect: "b1 \<in># \<B> \<Longrightarrow> b2 \<in># (\<B> - {#b1#}) \<Longrightarrow> b1 |\<inter>| b2 = \<m>"
+
+sublocale symmetric_bibd \<subseteq> const_intersect_design \<V> \<B> \<Lambda>
+  by (unfold_locales) (simp)
+
+context const_intersect_design
+begin
+
+lemma inter_num_le_block_size: 
+  assumes "bl \<in># \<B>"
+  assumes "\<b> \<ge> 2"
+  shows "\<m> \<le> card bl"
+proof (rule ccontr)
+  assume a: "\<not> (\<m> \<le> card bl)"
+  obtain bl' where blin: "bl' \<in># \<B> - {#bl#}"
+    using assms by (metis add_mset_add_single diff_add_inverse2 diff_is_0_eq' multiset_nonemptyE 
+        nat_1_add_1 remove1_mset_eqE size_single zero_neq_one)
+  then have const: "bl |\<inter>| bl' = \<m>" using const_intersect assms by auto
+  thus False using inter_num_max_bound(1) finite_blocks 
+    by (metis a blin assms(1) finite_blocks in_diffD) 
+qed
+
+lemma const_inter_multiplicity_one: 
+  assumes "bl \<in># \<B>"
+  assumes "\<m> < card bl"
+  shows "multiplicity bl = 1"
+proof (rule ccontr)
+  assume "multiplicity bl \<noteq> 1"
+  then have "multiplicity bl > 1" using assms
+    by (simp add: le_neq_implies_less)
+  then obtain bl2 where "bl = bl2" and "bl2 \<in># \<B> - {#bl#}"
+    by (metis count_single in_diff_count)
+  then have "bl |\<inter>| bl2 = card bl"
+    using inter_num_of_eq_blocks by blast  
+  thus False using assms const_intersect
+    by (simp add: \<open>bl2 \<in># remove1_mset bl \<B>\<close>) 
+qed
+
+lemma mult_blocks_const_inter: 
+  assumes "bl \<in># \<B>"
+  assumes "multiplicity bl > 1"
+  assumes "\<b> \<ge> 2"
+  shows "\<m> = card bl"
+proof (rule ccontr)
+  assume "\<m> \<noteq> card bl"
+  then have "\<m> < card bl" using inter_num_le_block_size assms
+    using nat_less_le by blast 
+  then have "multiplicity bl = 1" using const_inter_multiplicity_one assms by simp
+  thus False using assms(2) by simp
+qed
+
+lemma simple_const_inter_block_size: "(\<And> bl. bl \<in># \<B> \<Longrightarrow> \<m> < card bl) \<Longrightarrow> simple_design \<V> \<B>"
+  using const_inter_multiplicity_one by (unfold_locales) (simp)
+
+lemma simple_const_inter_iff: 
+  assumes "\<b> \<ge> 2"
+  shows "size {#bl \<in># \<B> . card bl = \<m>  #} \<le> 1 \<longleftrightarrow> simple_design \<V> \<B>"
+proof (intro iffI)
+  assume a: "size {#bl \<in># \<B>. card bl = \<m>#} \<le> 1"
+  show "simple_design \<V> \<B>" 
+  proof (unfold_locales)
+    fix bl assume blin: "bl \<in># \<B>"
+    show "multiplicity bl = 1"
+    proof (cases "card bl = \<m>")
+      case True
+      then have m: "multiplicity bl = size {#b \<in># \<B> . b = bl#}"
+        by (simp add: count_size_set_repr)
+      then have "{#b \<in># \<B> . b = bl#} \<subseteq># {#bl \<in># \<B>. card bl = \<m>#}" using True
+        by (simp add: mset_subset_eqI)
+      then have "size {#b \<in># \<B> . b = bl#} \<le> size {#bl \<in># \<B>. card bl = \<m>#}"
+        by (simp add: size_mset_mono) 
+      then show ?thesis using a blin
+        by (metis count_eq_zero_iff le_neq_implies_less le_trans less_one m) 
+    next
+      case False
+      then have "\<m> < card bl" using assms
+        by (simp add: blin inter_num_le_block_size le_neq_implies_less) 
+      then show ?thesis using const_inter_multiplicity_one
+        by (simp add: blin) 
+    qed
+  qed
+next
+  assume simp: "simple_design \<V> \<B>"
+  then have mult: "\<And> bl. bl \<in># \<B> \<Longrightarrow> multiplicity bl = 1"
+    using simple_design.axioms(2) simple_incidence_system.simple_alt_def_all by blast 
+  show "size {#bl \<in># \<B> . card bl = \<m> #} \<le> 1"
+  proof (rule ccontr)
+    assume "\<not> size {#bl \<in># \<B>. card bl = \<m>#} \<le> 1"
+    then have "size {#bl \<in># \<B> . card bl = \<m> #} > 1" by simp
+    then obtain bl1 bl2 where blin: "bl1 \<in># \<B>" and bl2in: "bl2 \<in># \<B> - {#bl1#}" and 
+        card1: "card bl1 = \<m>" and card2: "card bl2 = \<m>"
+      using obtain_two_items_mset_filter by blast 
+    then have "bl1 |\<inter>| bl2 = \<m>" using const_intersect by simp
+    then have "bl1 = bl2"
+      by (metis blin bl2in card1 card2 finite_blocks in_diffD inter_eq_blocks_eq_card)
+    then have "multiplicity bl1 > 1"
+      using \<open>bl2 \<in># remove1_mset bl1 \<B>\<close> count_eq_zero_iff by force 
+    thus False using mult blin by simp
+  qed
+qed
+
+lemma empty_inter_implies_rep_one: 
+  assumes "\<m> = 0"
+  assumes "x \<in> \<V>"
+  shows "\<B> rep x \<le> 1"
+proof (rule ccontr)
+  assume a: "\<not> \<B> rep x \<le> 1"
+  then have gt1: "\<B> rep x > 1" by simp
+  then obtain bl1 where blin1: "bl1 \<in># \<B>" and xin1: "x \<in> bl1"
+    by (metis gr_implies_not0 linorder_neqE_nat rep_number_g0_exists) 
+  then have "(\<B> - {#bl1#}) rep x > 0" using gt1 point_rep_number_split point_rep_singleton_val
+    by (metis a add_0 eq_imp_le neq0_conv remove1_mset_eqE) 
+  then obtain bl2 where blin2: "bl2 \<in># (\<B> - {#bl1#})" and xin2: "x \<in> bl2" 
+    by (metis rep_number_g0_exists) 
+  then have "x \<in> (bl1 \<inter> bl2)" using xin1 by simp
+  then have "bl1 |\<inter>| bl2 \<noteq> 0"
+    by (metis blin1 empty_iff finite_blocks intersection_number_empty_iff) 
+  thus False using const_intersect assms blin1 blin2 by simp
+qed
+
+lemma empty_inter_implies_b_lt_v: 
+  assumes "\<m> = 0"
+  shows "\<b> \<le> \<v>"
+proof -
+  have le1: "\<And> x. x \<in> \<V> \<Longrightarrow> \<B> rep x \<le> 1" using empty_inter_implies_rep_one assms by simp
+  have disj: "{v \<in> \<V> . \<B> rep v = 0} \<inter> {v \<in> \<V> . \<not> (\<B> rep v = 0)} = {}" by auto
+  have eqv: "\<V> = ({v \<in> \<V> . \<B> rep v = 0} \<union> {v \<in> \<V> . \<not> (\<B> rep v = 0)})" by auto
+  have "\<b> \<le> (\<Sum> x \<in> \<V> . \<B> rep x)" using block_num_rep_bound by simp
+  also have 1: "... \<le> (\<Sum> x \<in> ({v \<in> \<V> . \<B> rep v = 0} \<union> {v \<in> \<V> . \<not> (\<B> rep v = 0)}) . \<B> rep x)" 
+    using eqv by simp
+  also have "... \<le> (\<Sum> x \<in> ({v \<in> \<V> . \<B> rep v = 0}) . \<B> rep x) + (\<Sum> x \<in> ({v \<in> \<V> . \<not> (\<B> rep v = 0)}) . \<B> rep x)"
+    using sum.union_disjoint finite_sets eqv disj
+    by (metis (no_types, lifting) 1 finite_Un) 
+  also have "... \<le> (\<Sum> x \<in> ({v \<in> \<V> . \<not> (\<B> rep v = 0)}) . \<B> rep x)" by simp
+  also have "... \<le> (\<Sum> x \<in> ({v \<in> \<V> . \<not> (\<B> rep v = 0)}) . 1)" using le1
+    by (metis (mono_tags, lifting) mem_Collect_eq sum_mono)
+  also have "... \<le> card {v \<in> \<V> . \<not> (\<B> rep v = 0)}" by simp
+  also have "... \<le> card \<V>" using finite_sets
+    using card_mono eqv by blast 
+  finally show ?thesis by simp
+qed
+
+end
+
+locale simple_const_intersect_design = const_intersect_design + simple_design
+
+end
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/Dual_Systems.thy b/thys/Fishers_Inequality/Dual_Systems.thy
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/Dual_Systems.thy
@@ -0,0 +1,601 @@
+(* Title: Dual_Systems.thy
+   Author: Chelsea Edmonds
+*)
+
+section \<open> Dual Systems \<close>
+text \<open>The concept of a dual incidence system \cite{colbournHandbookCombinatorialDesigns2007}
+ is an important property in design theory. It enables us to reason on the existence of several 
+different types of design constructs through dual properties \cite{stinsonCombinatorialDesignsConstructions2004}\<close>
+
+theory Dual_Systems imports Incidence_Matrices
+begin
+
+subsection \<open>Dual Blocks \<close>
+text \<open>A dual design of $(\mathcal{V}, \mathcal{B})$, is the design where each block in $\mathcal{B}$
+represents a point $x$, and a block in a dual design is a set of blocks which $x$ is in from the original design. 
+It is important to note that if a block repeats in $\mathcal{B}$, each instance of the block is a distinct point. 
+As such the definition below uses each block's list index as its identifier. The list of points would simply be the 
+indices $0..<$length $Bs$ \<close>   
+
+definition dual_blocks :: "'a set \<Rightarrow> 'a set list \<Rightarrow> nat set multiset" where
+"dual_blocks \<V> \<B>s \<equiv> {# {y . y < length \<B>s \<and> x \<in> \<B>s ! y} . x \<in># (mset_set \<V>)#}"
+
+lemma dual_blocks_wf: "b \<in># dual_blocks V Bs \<Longrightarrow> b \<subseteq> {0..<length Bs}"
+  by (auto simp add: dual_blocks_def)
+
+context ordered_incidence_system
+begin
+
+definition dual_blocks_ordered :: "nat set list" ("\<B>s*") where
+"dual_blocks_ordered \<equiv> map (\<lambda> x . {y . y < length \<B>s \<and> x \<in> \<B>s ! y}) \<V>s"
+
+lemma dual_blocks_ordered_eq: "dual_blocks \<V> \<B>s= mset (\<B>s*)"
+  by (auto simp add: distinct dual_blocks_def dual_blocks_ordered_def mset_set_set)
+
+lemma dual_blocks_len: "length \<B>s* = length \<V>s"
+  by (simp add: dual_blocks_ordered_def)
+
+text \<open>A dual system is an incidence system \<close>
+sublocale dual_sys: finite_incidence_system "{0..<length \<B>s}" "dual_blocks \<V> \<B>s"
+  using dual_blocks_wf by(unfold_locales) (auto)
+
+lemma dual_is_ordered_inc_sys: "ordered_incidence_system [0..<length \<B>s] \<B>s*"
+  using inc_sys_orderedI dual_blocks_ordered_eq
+  by (metis atLeastLessThan_upt distinct_upt dual_sys.incidence_system_axioms)
+
+interpretation ordered_dual_sys: ordered_incidence_system "[0..<length \<B>s]" "\<B>s*"
+  using dual_is_ordered_inc_sys by simp 
+
+subsection \<open>Basic Dual Properties\<close>
+lemma ord_dual_blocks_b: "ordered_dual_sys.\<b> = \<v>"
+  using dual_blocks_len by (simp add: points_list_length) 
+
+lemma dual_blocks_b: "dual_sys.\<b> = \<v>"
+  using points_list_length
+  by (simp add: dual_blocks_len dual_blocks_ordered_eq) 
+
+lemma dual_blocks_v: "dual_sys.\<v> = \<b>"
+  by fastforce
+
+lemma ord_dual_blocks_v: "ordered_dual_sys.\<v> = \<b>"
+  by fastforce
+
+lemma dual_point_block: "i < \<v> \<Longrightarrow> \<B>s* ! i = {y. y < length \<B>s \<and> (\<V>s ! i) \<in> \<B>s ! y}"
+  by (simp add: dual_blocks_ordered_def points_list_length)
+
+lemma dual_incidence_iff: "i < \<v> \<Longrightarrow> j < \<b> \<Longrightarrow> \<B>s ! j = bl \<Longrightarrow> \<V>s ! i = x \<Longrightarrow> (x \<in> bl \<longleftrightarrow> j \<in> \<B>s* ! i)"
+  using dual_point_block by (intro iffI)(simp_all)
+
+lemma dual_incidence_iff2: "i < \<v> \<Longrightarrow> j < \<b> \<Longrightarrow> (\<V>s ! i \<in> \<B>s ! j  \<longleftrightarrow> j \<in> \<B>s* ! i)"
+  using dual_incidence_iff by simp
+
+lemma dual_blocks_point_exists: "bl \<in># dual_blocks \<V> \<B>s \<Longrightarrow> 
+    \<exists> x. x \<in> \<V> \<and> bl = {y . y < length \<B>s \<and> x \<in> \<B>s ! y}"
+  by (auto simp add: dual_blocks_def)
+
+lemma dual_blocks_ne_index_ne:  "j1 < length \<B>s* \<Longrightarrow> j2 < length \<B>s* \<Longrightarrow> \<B>s* ! j1 \<noteq> \<B>s* ! j2 \<Longrightarrow> j1 \<noteq> j2"
+  by auto
+
+lemma dual_blocks_list_index_img: "image_mset (\<lambda>x . \<B>s* ! x) (mset_set {0..<length \<B>s*}) = mset \<B>s*"
+  using lessThan_atLeast0 ordered_dual_sys.blocks_list_length ordered_dual_sys.blocks_mset_image 
+  by presburger
+
+lemma dual_blocks_elem_iff:
+  assumes "j < \<v>"
+  shows "x \<in> (\<B>s* ! j) \<longleftrightarrow> \<V>s ! j \<in> \<B>s ! x \<and> x < \<b>"
+proof (intro iffI conjI)
+  show "x \<in> \<B>s* ! j \<Longrightarrow> \<V>s ! j \<in> \<B>s ! x"
+    using assms ordered_incidence_system.dual_point_block ordered_incidence_system_axioms 
+    by fastforce
+  show "x \<in> \<B>s* ! j \<Longrightarrow> x < \<b>"
+    using assms dual_blocks_ordered_def dual_point_block by fastforce
+  show "\<V>s ! j \<in> \<B>s ! x \<and> x < \<b> \<Longrightarrow> x \<in> \<B>s* ! j"
+    by (metis (full_types) assms blocks_list_length dual_incidence_iff)
+qed
+
+text \<open>The incidence matrix of the dual of a design is just the transpose \<close>
+lemma dual_incidence_mat_eq_trans: "ordered_dual_sys.N = N\<^sup>T"
+proof (intro eq_matI)
+  show dimr: "dim_row ordered_dual_sys.N = dim_row N\<^sup>T" using dual_blocks_v by (simp) 
+  show dimc: "dim_col ordered_dual_sys.N = dim_col N\<^sup>T" using ord_dual_blocks_b by (simp)
+  show "\<And>i j. i < dim_row N\<^sup>T \<Longrightarrow> j < dim_col N\<^sup>T \<Longrightarrow> ordered_dual_sys.N $$ (i, j) = N\<^sup>T $$ (i, j)" 
+  proof -
+    fix i j assume ilt: "i < dim_row N\<^sup>T" assume jlt: "j < dim_col N\<^sup>T"
+    then have ilt2: "i < length \<B>s"using dimr
+      using blocks_list_length ord_dual_blocks_v ilt ordered_dual_sys.dim_row_is_v by linarith
+    then have ilt3: "i < \<b>" by simp
+    have jlt2: "j < \<v>" using jlt
+      using dim_row_is_v by fastforce 
+    have "ordered_dual_sys.N $$ (i, j) =  (if ([0..<length \<B>s] ! i) \<in> (\<B>s* ! j) then 1 else 0)"
+      using dimr dual_blocks_len ilt jlt inc_matrix_elems_one_zero
+      by (metis  inc_mat_dim_row inc_matrix_point_in_block_iff index_transpose_mat(3) )
+    then have "ordered_dual_sys.N $$ (i, j) = (if \<V>s ! j \<in> \<B>s ! i then 1 else 0)" 
+      using ilt3 jlt2 dual_incidence_iff2 by simp 
+    thus "ordered_dual_sys.N $$ (i, j) = N\<^sup>T $$ (i, j)" 
+      using ilt3 jlt2 dim_row_is_v dim_col_is_b N_trans_index_val by simp
+  qed
+qed
+
+lemma dual_incidence_mat_eq_trans_rev: "(ordered_dual_sys.N)\<^sup>T = N"
+  using dual_incidence_mat_eq_trans by simp 
+
+subsection \<open>Incidence System Dual Properties\<close>
+text \<open>Many common design properties have a dual in the dual design which enables extensive reasoning
+Using incidence matrices and the transpose property these are easy to prove. We leave examples of 
+counting proofs (commented out), to demonstrate how incidence matrices can significantly simplify 
+reasoning \<close>
+
+lemma dual_blocks_nempty:
+  assumes "(\<And> x . x \<in> \<V> \<Longrightarrow> \<B> rep x > 0)"
+  assumes "bl \<in># dual_blocks \<V> \<B>s"
+  shows "bl \<noteq> {}"
+proof -
+  have "bl \<in># {# {y . y < length \<B>s \<and> x \<in> \<B>s ! y} . x \<in># (mset_set \<V>)#}" 
+    using assms dual_blocks_def by metis 
+  then obtain x where "x \<in># (mset_set \<V>)" and blval: "bl = {y . y < length \<B>s \<and> x \<in> \<B>s ! y}"
+    by blast 
+  then obtain bl' where "bl' \<in># \<B>" and xin: "x \<in> bl'" using assms(1)
+    using point_in_block_rep_min_iff by auto 
+  then obtain y where "y < length \<B>s" and "\<B>s ! y = bl'"
+    using valid_blocks_index_cons by auto 
+  then have "y \<in> bl"
+    by (simp add: xin blval) 
+  thus ?thesis by blast
+qed
+
+lemma dual_blocks_size_is_rep: "j < length \<B>s* \<Longrightarrow> card (\<B>s* ! j) = \<B> rep (\<V>s ! j)"
+  using dual_incidence_mat_eq_trans trans_mat_rep_block_size_sym(2)
+  by (metis dual_blocks_len dual_is_ordered_inc_sys inc_mat_dim_row mat_rep_num_N_row 
+      ordered_incidence_system.mat_block_size_N_col points_list_length size_mset) 
+
+(* Old Counting proof 
+proof -
+  have 1: "card (\<B>s* ! j) = card {y . y < length \<B>s \<and> (\<V>s ! j) \<in> \<B>s ! y}"
+    using assms dual_blocks_len dual_point_block points_list_length by force
+  also have 2: "... = card {y \<in> {0..<length \<B>s} . (\<V>s ! j) \<in> \<B>s ! y}" by simp
+  also have "... = size (mset_set {y \<in> {0..<length \<B>s} . (\<V>s ! j) \<in> \<B>s ! y})" by simp
+  also have "... = size {# y \<in># mset_set {0..< length \<B>s} . (\<V>s ! j) \<in> \<B>s ! y #}" 
+    using filter_mset_mset_set by simp 
+  finally have "card (\<B>s* ! j) = size {# bl \<in># \<B> . (\<V>s ! j) \<in> bl #}"
+    by (metis 1 2 filter_size_blocks_eq_card_indexes lessThan_atLeast0 size_mset) 
+  thus ?thesis by (simp add: point_replication_number_def)
+qed
+*)
+
+lemma dual_blocks_size_is_rep_obtain: 
+  assumes "bl \<in># dual_blocks \<V> \<B>s"
+  obtains x where "x \<in> \<V>" and "card bl = \<B> rep x"
+proof -
+  obtain j where jlt1: "j < length \<B>s*" and bleq: "\<B>s* ! j = bl"
+    by (metis assms dual_blocks_ordered_eq in_mset_conv_nth) 
+  then have jlt: "j < \<v>"
+    by (simp add: dual_blocks_len points_list_length) 
+  let ?x = "\<V>s ! j"
+  have xin: "?x \<in> \<V>" using jlt
+    by (simp add: valid_points_index) 
+  have "card bl = \<B> rep ?x" using dual_blocks_size_is_rep jlt1 bleq by auto
+  thus ?thesis using xin that by auto 
+qed
+
+lemma dual_blocks_rep_is_size:
+  assumes "i < length \<B>s"
+  shows "(mset \<B>s*) rep i = card (\<B>s ! i)"
+proof -
+  have "[0..<length \<B>s] ! i = i" using assms by simp
+  then have "(mset \<B>s*) rep i = mat_rep_num ordered_dual_sys.N i" 
+    using ordered_dual_sys.mat_rep_num_N_row assms length_upt minus_nat.diff_0 
+      ordered_dual_sys.points_list_length by presburger 
+  also have "... = mat_block_size (ordered_dual_sys.N)\<^sup>T i" using dual_incidence_mat_eq_trans 
+    trans_mat_rep_block_size_sym(2) by (metis assms inc_mat_dim_col index_transpose_mat(2))
+  finally show ?thesis using dual_incidence_mat_eq_trans_rev
+    by (metis assms blocks_list_length mat_block_size_N_col)
+qed
+
+(* Counting Proof
+proof -
+  have "(mset \<B>s* ) rep i = size {# bl \<in># (mset \<B>s* ) . i \<in> bl #}" 
+    by (simp add: point_replication_number_def)
+  also have 1: "... = size {# bl \<in># {# {y . y < length \<B>s \<and> x \<in> \<B>s ! y} . x \<in># (mset_set \<V>)#} . i \<in> bl #}" 
+    using dual_blocks_ordered_eq dual_blocks_def by metis 
+  also have "... = size (filter_mset (\<lambda> bl . i \<in> bl) 
+      (image_mset (\<lambda> x . {y . y < length \<B>s \<and> x \<in> \<B>s ! y}) (mset_set \<V>)))" by simp
+  finally have "(mset \<B>s* ) rep i = size (image_mset (\<lambda> x . {y . y < length \<B>s \<and> x \<in> \<B>s ! y}) 
+      (filter_mset (\<lambda> bl . i \<in> {y . y < length \<B>s \<and> bl \<in> \<B>s ! y}) (mset_set \<V>)))"
+    using filter_mset_image_mset by (metis 1 ordered_dual_sys.point_rep_number_alt_def) 
+  then have "(mset \<B>s* ) rep i = size (filter_mset (\<lambda> bl . i \<in> {y . y < length \<B>s \<and> bl \<in> \<B>s ! y}) 
+      (mset_set \<V>))"
+    by fastforce
+  then have "(mset \<B>s* ) rep i = size (filter_mset (\<lambda> bl . bl \<in> \<B>s ! i) (mset_set \<V>))" 
+    using assms by simp
+  then have "(mset \<B>s* ) rep i =  card {x \<in> \<V> . x \<in> (\<B>s ! i)}" by simp
+  thus ?thesis using assms block_size_alt by auto
+qed
+*)
+
+lemma dual_blocks_inter_index: 
+  assumes "j1 < length \<B>s*" "j2 < length \<B>s*"
+  shows "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = points_index \<B> {\<V>s ! j1, \<V>s ! j2}"
+proof -
+  have assms2: "j1 < \<v>" "j2 < \<v>" using assms
+    by (simp_all add: dual_blocks_len points_list_length) 
+  have "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = mat_inter_num (ordered_dual_sys.N) j1 j2"
+    by (simp add: assms(1) assms(2) ordered_dual_sys.mat_inter_num_conv)
+  also have "... = mat_point_index N {j1, j2}" using dual_incidence_mat_eq_trans_rev trans_mat_point_index_inter_sym(2)
+    by (metis assms inc_mat_dim_col)
+  finally show ?thesis using assms2 incidence_mat_two_index
+    by presburger
+qed
+(* Counting Proof 
+  have fin: "finite {0..<length \<B>s}"
+    by auto 
+  have j1lt: "j1 < \<v>" using assms
+    using dual_blocks_len points_list_length by auto 
+  have j2lt: "j2 < \<v>" using assms dual_blocks_len points_list_length by auto
+  have iff: "\<And> x. (x \<in>(\<B>s* ! j1) \<and> x \<in> (\<B>s* ! j2)) \<longleftrightarrow> (\<V>s ! j1 \<in> \<B>s ! x \<and> x < \<b> \<and> \<V>s ! j2 \<in> \<B>s ! x)" 
+    by (auto simp add: dual_blocks_elem_iff j1lt j2lt)
+  have pi: "points_index \<B> {\<V>s ! j1, \<V>s ! j2} = size {# bl \<in># \<B> . \<V>s !j1 \<in> bl \<and> \<V>s ! j2 \<in> bl#}" 
+    by (auto simp add: points_index_def)
+  have "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = card ({x . x <length \<B>s \<and> x \<in> (\<B>s* ! j1) \<and> x \<in> (\<B>s* ! j2)})"
+    apply (auto simp add: intersection_number_def)
+    by (smt (verit) Collect_cong Int_Collect blocks_list_length dual_blocks_elem_iff inf.idem inf_set_def j2lt mem_Collect_eq)
+  then have "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = card ({x . x <length \<B>s \<and> \<V>s ! j1 \<in> \<B>s ! x \<and> \<V>s ! j2 \<in> \<B>s ! x})" using iff
+    size_mset by (smt (verit, best) Collect_cong) 
+  then have "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = size (mset_set {x \<in> {0..<length \<B>s}. \<V>s ! j1 \<in> \<B>s ! x \<and> \<V>s ! j2 \<in> \<B>s ! x})" by simp
+  then have "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = size ({#x \<in># mset_set {0..<length \<B>s}. \<V>s ! j1 \<in> \<B>s ! x \<and> \<V>s ! j2 \<in> \<B>s ! x#})" using fin by simp
+  then have "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = size (filter_mset (\<lambda> x . \<V>s ! j1 \<in> \<B>s ! x \<and> \<V>s ! j2 \<in> \<B>s ! x) (mset_set {0..<length \<B>s}))" by simp
+  then have "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = size (image_mset (\<lambda> i. \<B>s ! i) (filter_mset (\<lambda> x . \<V>s ! j1 \<in> \<B>s ! x \<and> \<V>s ! j2 \<in> \<B>s ! x) (mset_set {0..<length \<B>s})))"
+    by simp
+  then have "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = size (filter_mset (\<lambda> x . \<V>s ! j1 \<in> x \<and> \<V>s ! j2 \<in> x) (image_mset (\<lambda> i. \<B>s ! i) (mset_set {0..<length \<B>s})))"
+    by (simp add: filter_mset_image_mset)
+  then have "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = size {# bl \<in># \<B> . \<V>s !j1 \<in> bl \<and> \<V>s ! j2 \<in> bl#}"
+    by (metis blocks_list_length blocks_mset_image lessThan_atLeast0) 
+  thus ?thesis using pi by simp
+qed
+*)
+
+lemma dual_blocks_points_index_inter: 
+  assumes "i1 < \<b>" "i2 < \<b>"
+  shows "(mset \<B>s*) index {i1, i2} = (\<B>s ! i1) |\<inter>| (\<B>s ! i2)"
+proof -
+  have "(mset \<B>s*) index {i1, i2} = mat_point_index (ordered_dual_sys.N) {i1, i2}"
+    using assms(1) assms(2) blocks_list_length ord_dual_blocks_v ordered_dual_sys.dim_row_is_v 
+      ordered_dual_sys.incidence_mat_two_index ordered_dual_sys.mat_ord_inc_sys_point by presburger 
+  also have "... = mat_inter_num N i1 i2" using dual_incidence_mat_eq_trans trans_mat_point_index_inter_sym(1)
+    by (metis assms(1) assms(2) dual_incidence_mat_eq_trans_rev ord_dual_blocks_v ordered_dual_sys.dim_row_is_v) 
+  finally show ?thesis using mat_inter_num_conv
+    using assms(1) assms(2) by auto 
+qed
+
+(* Counting Proof 
+proof - 
+  have "\<And> j . j \<in># mset_set {0..<length \<B>s*} \<Longrightarrow> j < \<v>"
+    by (metis atLeastLessThan_iff atLeastLessThan_upt dual_blocks_len mset_upt points_list_length set_mset_mset) 
+  then have iff: "\<And> j i. j \<in># mset_set {0..<length \<B>s*} \<Longrightarrow> i < \<b> \<Longrightarrow> i \<in> (\<B>s* ! j) \<longleftrightarrow> (\<V>s ! j) \<in> (\<B>s ! i)" 
+    using assms dual_incidence_iff2 by simp 
+  then have iff2: "\<And> j . j \<in># mset_set {0..<length \<B>s*} \<Longrightarrow> i1 \<in> (\<B>s* ! j) \<and> i2 \<in> (\<B>s* ! j) \<longleftrightarrow> (\<V>s ! j) \<in> (\<B>s ! i1) \<and> (\<V>s ! j) \<in> (\<B>s ! i2)"
+    using assms by auto
+  have ss2: "(\<B>s ! i2) \<subseteq> \<V>" using wellformed assms by auto
+  then have ss: "{x . x \<in> (\<B>s ! i1) \<and> x \<in> (\<B>s ! i2)} \<subseteq> \<V>"
+    by auto 
+  then have inter:  "(\<B>s ! i1) |\<inter>| (\<B>s ! i2) = card {x \<in> \<V>. x \<in> (\<B>s ! i1) \<and> x \<in> (\<B>s ! i2)}"
+    using intersection_number_def by (metis Collect_conj_eq Collect_mem_eq Int_absorb1)
+  have inj: "inj_on (\<lambda> j. \<V>s ! j) {j \<in> {0..<length \<V>s} . (\<V>s ! j) \<in> (\<B>s ! i1) \<and> (\<V>s ! j) \<in> (\<B>s ! i2)}"
+    by (simp add: inj_on_nth distinct) 
+  have init: "(mset \<B>s* ) index {i1, i2} = size {#bl \<in># (mset \<B>s* ) . i1 \<in> bl \<and> i2 \<in> bl#}"
+    by (simp add: points_index_def)
+  then have "size {#bl \<in># (mset \<B>s* ) . i1 \<in> bl \<and> i2 \<in> bl#} = size {#j \<in># mset_set {0..<length \<B>s*} . i1 \<in> (\<B>s* ! j) \<and> i2 \<in> (\<B>s* ! j)#}"
+  proof - 
+    have "size {#j \<in># mset_set {0..<length \<B>s*} . i1 \<in> (\<B>s* ! j) \<and> i2 \<in> (\<B>s* ! j)#} 
+      = size (filter_mset (\<lambda> j. i1 \<in> (\<B>s* ! j) \<and> i2 \<in> (\<B>s* ! j)) (mset_set {0..<length \<B>s*})) " by simp
+    also have s1: "... = size (image_mset (\<lambda>x . \<B>s* ! x) (filter_mset (\<lambda> j. i1 \<in> (\<B>s* ! j) \<and> i2 \<in> (\<B>s* ! j)) (mset_set {0..<length \<B>s*})))" by fastforce
+    also have s2: "... = size (filter_mset (\<lambda> j. i1 \<in> j \<and> i2 \<in> j) (image_mset (\<lambda>x . \<B>s* ! x) (mset_set {0..<length \<B>s*})))"
+      by (simp add: filter_mset_image_mset) 
+    finally have "size {#j \<in># mset_set {0..<length \<B>s*} . i1 \<in> (\<B>s* ! j) \<and> i2 \<in> (\<B>s* ! j)#} = size (filter_mset (\<lambda> j. i1 \<in> j \<and> i2 \<in> j) (mset \<B>s* ))"
+      using dual_blocks_list_index_img s2 s1 by presburger 
+    thus ?thesis by simp
+  qed
+  then have "size {#bl \<in># (mset \<B>s* ) . i1 \<in> bl \<and> i2 \<in> bl#} = size {#j \<in># mset_set {0..<length \<B>s*} . (\<V>s ! j) \<in> (\<B>s ! i1) \<and> (\<V>s ! j) \<in> (\<B>s ! i2)#}" using iff2
+    by (smt (verit, ccfv_SIG) filter_mset_cong) 
+  then have "size {#bl \<in># (mset \<B>s* ) . i1 \<in> bl \<and> i2 \<in> bl#} = 
+    card ({j \<in> {0..<length \<B>s*} . (\<V>s ! j) \<in> (\<B>s ! i1) \<and> (\<V>s ! j) \<in> (\<B>s ! i2)})" by simp
+  then have "size {#bl \<in># (mset \<B>s* ) . i1 \<in> bl \<and> i2 \<in> bl#} = 
+    card ({j \<in> {0..<length \<V>s} . (\<V>s ! j) \<in> (\<B>s ! i1) \<and> (\<V>s ! j) \<in> (\<B>s ! i2)})" using dual_blocks_len by presburger 
+  then have "size {#bl \<in># (mset \<B>s* ) . i1 \<in> bl \<and> i2 \<in> bl#} = 
+    card (image (\<lambda> j. \<V>s ! j) {j \<in> {0..<length \<V>s} . (\<V>s ! j) \<in> (\<B>s ! i1) \<and> (\<V>s ! j) \<in> (\<B>s ! i2)})"  
+    using inj card_image[of "(\<lambda> j. \<V>s ! j)" "{j \<in> {0..<length \<V>s} . (\<V>s ! j) \<in> (\<B>s ! i1) \<and> (\<V>s ! j) \<in> (\<B>s ! i2)}"] by simp
+  then have "size {#bl \<in># (mset \<B>s* ) . i1 \<in> bl \<and> i2 \<in> bl#} = 
+    card {j \<in> image (\<lambda> j. \<V>s ! j) {0..<length \<V>s}. j \<in> (\<B>s ! i1) \<and> j \<in> (\<B>s ! i2)}" 
+    using Compr_image_eq[of "(\<lambda> j. \<V>s ! j)" "{0..<length \<V>s}" "(\<lambda> j . j \<in> (\<B>s ! i1) \<and> j \<in> (\<B>s ! i2))"] by simp
+  then have "size {#bl \<in># (mset \<B>s* ) . i1 \<in> bl \<and> i2 \<in> bl#} = 
+    card {j \<in> \<V>. j \<in> (\<B>s ! i1) \<and> j \<in> (\<B>s ! i2)}"
+    using lessThan_atLeast0 points_list_length points_set_index_img by presburger 
+  thus ?thesis using init inter by simp
+qed*)
+end 
+
+subsection \<open>Dual Properties for Design sub types \<close>
+context ordered_design
+begin
+
+lemma dual_is_design: 
+  assumes "(\<And> x . x \<in> \<V> \<Longrightarrow> \<B> rep x > 0)" \<comment> \<open> Required to ensure no blocks are empty \<close>
+  shows "design {0..<length \<B>s} (dual_blocks \<V> \<B>s)"
+  using dual_blocks_nempty assms by (unfold_locales) (simp) 
+end
+
+context ordered_proper_design
+begin
+
+lemma dual_sys_b_non_zero: "dual_sys.\<b> \<noteq> 0"
+  using v_non_zero dual_blocks_b by auto
+
+lemma dual_is_proper_design: 
+  assumes "(\<And> x . x \<in> \<V> \<Longrightarrow> \<B> rep x > 0)"  \<comment> \<open> Required to ensure no blocks are empty \<close>
+  shows "proper_design {0..<length \<B>s} (dual_blocks \<V> \<B>s)"
+  using dual_blocks_nempty dual_sys_b_non_zero assms by (unfold_locales) (simp_all)
+
+end
+
+context ordered_block_design 
+begin
+
+lemma dual_blocks_const_rep: "i \<in> {0..<length \<B>s} \<Longrightarrow> (mset \<B>s*) rep i = \<k>"
+  using dual_blocks_rep_is_size uniform by (metis atLeastLessThan_iff nth_mem_mset) 
+
+lemma dual_blocks_constant_rep_design:
+  assumes "(\<And> x . x \<in> \<V> \<Longrightarrow> \<B> rep x > 0)"
+  shows "constant_rep_design {0..<length \<B>s} (dual_blocks \<V> \<B>s) \<k>"
+proof -
+  interpret des: proper_design "{0..<length \<B>s}" "(dual_blocks \<V> \<B>s)"
+    using dual_is_proper_design assms by simp
+  show ?thesis using dual_blocks_const_rep dual_blocks_ordered_eq by (unfold_locales) (simp)
+qed
+
+
+end
+
+context ordered_constant_rep
+begin
+
+lemma dual_blocks_const_size:  "j < length \<B>s* \<Longrightarrow> card (\<B>s* ! j) = \<r>"
+  using dual_blocks_rep_is_size dual_blocks_len dual_blocks_size_is_rep by fastforce 
+
+lemma dual_is_block_design: "block_design {0..<length \<B>s} (dual_blocks \<V> \<B>s) \<r>"
+proof -
+  have "\<r> > 0" by (simp add: r_gzero)
+  then have "(\<And> x . x \<in> \<V> \<Longrightarrow> \<B> rep x > 0)" using rep_number by simp
+  then interpret pdes: proper_design "{0..<length \<B>s}" "(dual_blocks \<V> \<B>s)" 
+    using dual_is_proper_design by simp
+  have "\<And> bl. bl \<in># dual_blocks \<V> \<B>s \<Longrightarrow> card bl = \<r>" 
+    using dual_blocks_const_size 
+    by (metis dual_blocks_ordered_eq in_set_conv_nth set_mset_mset)
+  thus ?thesis by (unfold_locales) (simp)
+qed
+
+end
+
+context ordered_pairwise_balance 
+begin
+
+lemma dual_blocks_const_intersect: 
+  assumes "j1 < length \<B>s*" "j2 < length \<B>s*"
+  assumes "j1 \<noteq> j2"
+  shows "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = \<Lambda>"
+proof -
+  have "\<V>s ! j1 \<noteq> \<V>s ! j2" using assms(3)
+    using assms(1) assms(2) distinct dual_blocks_len nth_eq_iff_index_eq by auto 
+  then have c: "card {\<V>s ! j1, \<V>s ! j2} = 2"
+    using card_2_iff by blast 
+  have ss: "{\<V>s ! j1, \<V>s ! j2} \<subseteq> \<V>" using assms points_list_length
+    using dual_blocks_len by auto 
+  have "(\<B>s* ! j1) |\<inter>| (\<B>s* ! j2) = points_index \<B> {\<V>s ! j1, \<V>s ! j2}"
+    using dual_blocks_inter_index assms by simp
+  thus ?thesis using ss c balanced
+    by blast 
+qed
+
+lemma dual_is_const_intersect_des: 
+  assumes "\<Lambda> > 0"
+  shows "const_intersect_design {0..<(length \<B>s)} (dual_blocks \<V> \<B>s) \<Lambda>"
+proof -
+  have "(\<And> x . x \<in> \<V> \<Longrightarrow> \<B> rep x \<ge> \<Lambda>)" using const_index_lt_rep by simp
+  then have "(\<And> x . x \<in> \<V> \<Longrightarrow> \<B> rep x > 0)" using assms
+    by (metis gr_zeroI le_zero_eq) 
+  then interpret pd: proper_design "{0..<(length \<B>s)}" "(dual_blocks \<V> \<B>s)" 
+    using dual_is_proper_design by (simp) 
+  show ?thesis proof (unfold_locales)
+    fix b1 b2
+    assume b1in: "b1 \<in># dual_blocks \<V> \<B>s"
+    assume b2in:  "b2 \<in># remove1_mset b1 (dual_blocks \<V> \<B>s)"
+    obtain j1 where b1eq: "b1 = \<B>s* ! j1" and j1lt: "j1 < length \<B>s*" using b1in
+      by (metis dual_blocks_ordered_eq in_set_conv_nth set_mset_mset) 
+    obtain j2 where b2eq: "b2 = \<B>s* ! j2" and j2lt: "j2 < length \<B>s*" and "j1 \<noteq> j2" 
+      using b2in index_remove1_mset_ne
+      by (metis (mono_tags) b1eq dual_blocks_ordered_eq j1lt nth_mem set_mset_mset) 
+    then show "b1 |\<inter>| b2 = \<Lambda>" 
+      using dual_blocks_const_intersect b1eq b2eq j1lt j2lt by simp 
+  qed
+qed
+
+
+lemma dual_is_simp_const_inter_des: 
+  assumes "\<Lambda> > 0"
+  assumes "\<And> bl. bl \<in># \<B> \<Longrightarrow> incomplete_block bl"  
+  shows "simple_const_intersect_design {0..<(length \<B>s)} (dual_blocks \<V> \<B>s) \<Lambda>"
+proof -
+  interpret d: const_intersect_design "{0..<(length \<B>s)}" "(dual_blocks \<V> \<B>s)"  "\<Lambda>"
+    using assms dual_is_const_intersect_des by simp
+  \<comment> \<open> Show that m < block size for all blocks \<close>
+  have "\<And> x. x \<in> \<V> \<Longrightarrow> \<Lambda> < \<B> rep x" using assms incomplete_index_strict_lt_rep
+    by blast 
+  then have "\<And> bl. bl \<in># (dual_blocks \<V> \<B>s) \<Longrightarrow> \<Lambda> < card bl"
+    by (metis dual_blocks_size_is_rep_obtain) 
+  then interpret s: simple_design "{0..<(length \<B>s)}" "(dual_blocks \<V> \<B>s)" 
+    using d.simple_const_inter_block_size by simp
+  show ?thesis by (unfold_locales)
+qed
+end
+
+context ordered_const_intersect_design
+begin
+
+lemma dual_is_balanced: 
+  assumes "ps \<subseteq> {0..<length \<B>s}"
+  assumes "card ps = 2"
+  shows "(dual_blocks \<V> \<B>s) index ps = \<m>"
+proof -
+  obtain i1 i2 where psin: "ps = {i1, i2}" and neq: "i1 \<noteq> i2" using assms
+    by (meson card_2_iff) 
+  then have lt: "i1 < \<b>" using assms 
+    by (metis atLeastLessThan_iff blocks_list_length insert_subset) 
+  have lt2: "i2 < \<b>" using assms psin
+    by (metis atLeastLessThan_iff blocks_list_length insert_subset) 
+  then have inter: "(dual_blocks \<V> \<B>s) index ps = (\<B>s ! i1) |\<inter>| (\<B>s ! i2)" using dual_blocks_points_index_inter neq lt
+    using dual_blocks_ordered_eq psin by presburger
+  have inb1: "(\<B>s ! i1) \<in># \<B>"
+    using lt by auto 
+  have inb2: "(\<B>s ! i2) \<in># (\<B> - {#(\<B>s ! i1)#})" using lt2 neq blocks_index_ne_belong
+    by (metis blocks_list_length lt) 
+  thus ?thesis using const_intersect inb1 inb2 inter by blast 
+qed
+
+lemma dual_is_pbd: 
+  assumes "(\<And> x . x \<in> \<V> \<Longrightarrow> \<B> rep x > 0)"
+  assumes "\<b> \<ge> 2"
+  shows "pairwise_balance {0..<(length \<B>s)} (dual_blocks \<V> \<B>s) \<m>"
+proof -
+  interpret pd: proper_design "{0..<(length \<B>s)}" "(dual_blocks \<V> \<B>s)" 
+    using dual_is_proper_design
+    by (simp add: assms) 
+  show ?thesis proof (unfold_locales)
+    show "(1 ::nat) \<le> 2" by simp
+    then show "2 \<le> dual_sys.\<v>" using  assms(2)
+      by fastforce 
+    show "\<And>ps. ps \<subseteq> {0..<length \<B>s} \<Longrightarrow> card ps = 2 \<Longrightarrow> dual_blocks \<V> \<B>s index ps = \<m>"
+      using dual_is_balanced by simp
+  qed
+qed
+
+end
+
+context ordered_sym_bibd
+begin
+
+lemma dual_is_balanced: 
+  assumes "ps \<subseteq> {0..<length \<B>s}"
+  assumes "card ps = 2"
+  shows "(dual_blocks \<V> \<B>s) index ps = \<Lambda>"
+proof -
+  obtain i1 i2 where psin: "ps = {i1, i2}" and neq: "i1 \<noteq> i2" 
+    using assms by (meson card_2_iff) 
+  then have lt: "i1 < \<b>" using assms 
+    by (metis atLeastLessThan_iff blocks_list_length insert_subset) 
+  have lt2: "i2 < \<b>" using assms psin
+    by (metis atLeastLessThan_iff blocks_list_length insert_subset) 
+  then have inter: "(dual_blocks \<V> \<B>s) index ps = (\<B>s ! i1) |\<inter>| (\<B>s ! i2)" 
+    using dual_blocks_points_index_inter neq lt dual_blocks_ordered_eq psin by presburger
+  have inb1: "(\<B>s ! i1) \<in># \<B>"
+    using lt by auto 
+  have inb2: "(\<B>s ! i2) \<in># (\<B> - {#(\<B>s ! i1)#})" using lt2 neq blocks_index_simp_unique
+    by (metis blocks_list_length in_remove1_mset_neq lt valid_blocks_index) 
+  thus ?thesis using sym_block_intersections_index inb1 inter by blast
+qed
+
+lemma dual_bibd: "bibd {0..<(length \<B>s)} (dual_blocks \<V> \<B>s) \<r> \<Lambda>"
+proof -
+  interpret block: block_design "{0..<(length \<B>s)}" "(dual_blocks \<V> \<B>s)" \<r> 
+    using dual_is_block_design by simp
+  show ?thesis proof (unfold_locales)
+    show "\<r> < dual_sys.\<v>"
+      using dual_blocks_v incomplete symmetric_condition_1 symmetric_condition_2 by presburger 
+    show "(1 ::nat) \<le> 2" by simp
+    have "\<v> \<ge> 2"
+      by (simp add: t_lt_order) 
+    then have "\<b> \<ge> 2" using local.symmetric by auto 
+    then show "2 \<le> dual_sys.\<v>" by simp
+    show "\<And>ps. ps \<subseteq> {0..<length \<B>s} \<Longrightarrow> card ps = 2 \<Longrightarrow> dual_blocks \<V> \<B>s index ps = \<Lambda>"
+      using dual_is_balanced by simp
+    show "2 \<le> \<r>" using r_ge_two by blast 
+  qed
+qed
+
+text \<open>The dual of a BIBD must by symmetric \<close>
+
+lemma dual_bibd_symmetric: "symmetric_bibd {0..<(length \<B>s)} (dual_blocks \<V> \<B>s) \<r> \<Lambda>"
+proof -
+  interpret bibd: bibd "{0..<(length \<B>s)}" "(dual_blocks \<V> \<B>s)" \<r> \<Lambda>
+    using dual_bibd by simp
+  show ?thesis using dual_blocks_b local.symmetric by (unfold_locales) (simp)
+qed
+
+end
+
+subsection \<open>Generalise Dual Concept \<close>
+text \<open>The above formalisation relies on one translation of a dual design. However, any design 
+with an ordering of points and blocks such that the matrix is the transpose of the original is 
+a dual. The definition below encapsulates this concept. Additionally, we prove an isomorphism
+exists between the generated dual from @{term "dual_blocks"} and any design satisfying the is dual
+definition\<close>
+
+context ordered_incidence_system 
+begin
+
+definition is_dual:: "'b list \<Rightarrow> 'b set list \<Rightarrow> bool" where
+"is_dual Vs' Bs' \<equiv> ordered_incidence_system Vs' Bs' \<and> (inc_mat_of Vs' Bs' = N\<^sup>T)"
+
+lemma is_dualI: 
+  assumes "ordered_incidence_system Vs' Bs'"
+  assumes "(inc_mat_of Vs' Bs' = N\<^sup>T)"
+  shows "is_dual Vs' Bs'"
+  by (auto simp add: is_dual_def assms)
+
+lemma is_dualD1: 
+  assumes "is_dual Vs' Bs'"
+  shows  "(inc_mat_of Vs' Bs' = N\<^sup>T)"
+  using is_dual_def assms
+  by auto 
+
+lemma is_dualD2: 
+  assumes "is_dual Vs' Bs'"
+  shows  "ordered_incidence_system Vs' Bs'"
+  using is_dual_def assms
+  by auto 
+
+lemma generated_is_dual: "is_dual [0..<(length \<B>s)] \<B>s*"
+proof -
+  interpret osys: ordered_incidence_system "[0..<(length \<B>s)]" "\<B>s*" using dual_is_ordered_inc_sys by simp 
+  show ?thesis using is_dual_def
+    by (simp add: is_dual_def dual_incidence_mat_eq_trans osys.ordered_incidence_system_axioms) 
+qed
+
+lemma is_dual_isomorphism_generated: 
+  assumes "is_dual Vs' Bs'"
+  shows "\<exists> \<pi>. incidence_system_isomorphism (set Vs') (mset Bs') ({0..<(length \<B>s)}) (dual_blocks \<V> \<B>s) \<pi>"
+proof -
+  interpret os2: ordered_incidence_system "([0..<(length \<B>s)])" "(\<B>s*)"
+    by (simp add: dual_is_ordered_inc_sys) 
+  interpret os1: ordered_incidence_system Vs' Bs' using assms
+    by (simp add: is_dualD2) 
+  interpret tos: two_ordered_sys Vs' Bs' "([0..<(length \<B>s)])" "(\<B>s*)" 
+     using assms  ordered_incidence_system_axioms two_ordered_sys.intro
+     by (simp add: is_dualD2 two_ordered_sys.intro dual_is_ordered_inc_sys)
+  have os2V: "os2.\<V> = {0..<(length \<B>s)}"
+    by auto 
+  have os2B: "os2.\<B> = dual_blocks \<V> \<B>s"
+    by (simp add: dual_blocks_ordered_eq) 
+  have "os1.N = inc_mat_of Vs' Bs'" by simp
+  then have "os2.N = os1.N"
+    using assms is_dualD1 dual_incidence_mat_eq_trans by fastforce 
+  thus ?thesis using tos.equal_inc_mat_isomorphism_ex os2V os2B by auto
+qed
+
+interpretation ordered_dual_sys: ordered_incidence_system "[0..<length \<B>s]" "\<B>s*"
+  using dual_is_ordered_inc_sys by simp 
+
+text \<open>Original system is dual of the dual \<close>
+lemma is_dual_rev: "ordered_dual_sys.is_dual \<V>s \<B>s"
+  by (simp add: dual_incidence_mat_eq_trans_rev ordered_dual_sys.is_dualI ordered_incidence_system_axioms)
+
+end
+
+end
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/Fishers_Inequality.thy b/thys/Fishers_Inequality/Fishers_Inequality.thy
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/Fishers_Inequality.thy
@@ -0,0 +1,338 @@
+(* Title: Fishers_Inequality.thy
+   Author: Chelsea Edmonds
+*)
+
+section \<open>Fisher's Inequality\<close>
+
+text \<open>This theory presents the proof of Fisher's Inequality \cite{fisherExaminationDifferentPossible1940a}
+ on BIBD's (i.e. uniform Fisher's) and the generalised nonuniform Fisher's Inequality \<close>
+theory Fishers_Inequality imports Rank_Argument_General Linear_Bound_Argument
+begin
+
+subsection \<open> Uniform Fisher's Inequality \<close>
+context ordered_bibd
+begin
+
+text \<open>Row/Column transformation steps \<close>
+
+text\<open>Following design theory lecture notes from MATH3301 at the University of Queensland
+ \cite{HerkeLectureNotes2016}, a simple transformation to produce an upper triangular matrix using elementary
+row operations is to (1) Subtract the first row from each other row, and (2) add all columns to the first column\<close>
+
+lemma transform_N_step1_vals: 
+  defines mdef: "M \<equiv> (N * N\<^sup>T)"
+  assumes "i < dim_row M" 
+  assumes "j < dim_col M"
+  shows "i = 0 \<Longrightarrow> j = 0 \<Longrightarrow> (add_row_to_multiple (-1) [1..<dim_row M] 0 M) $$ (i, j) = (int \<r>)" \<comment> \<open> top left elem \<close>
+  and "i \<noteq> 0 \<Longrightarrow> j = 0 \<Longrightarrow> (add_row_to_multiple (-1) [1..<dim_row M] 0 M) $$ (i, j) = (int \<Lambda>) - (int \<r>)" \<comment> \<open> first column ex. 1 \<close>
+  and "i = 0 \<Longrightarrow> j \<noteq> 0 \<Longrightarrow> (add_row_to_multiple (-1) [1..<dim_row M] 0 M) $$ (i, j) = (int \<Lambda>)" \<comment> \<open> first row ex. 1 \<close>
+  and "i \<noteq> 0 \<Longrightarrow> j \<noteq> 0 \<Longrightarrow> i = j \<Longrightarrow> (add_row_to_multiple (-1) [1..<dim_row M] 0 M) $$ (i, j) = (int \<r>) - (int \<Lambda>)" \<comment> \<open> diagonal ex. 1 \<close>
+  and "i \<noteq> 0 \<Longrightarrow> j \<noteq> 0 \<Longrightarrow> i \<noteq> j \<Longrightarrow> (add_row_to_multiple (-1) [1..<dim_row M] 0 M) $$ (i, j) = 0" \<comment> \<open> everything else \<close>
+  using transpose_N_mult_diag v_non_zero assms
+proof (simp) 
+  show "i = 0 \<Longrightarrow> j \<noteq> 0 \<Longrightarrow> (add_row_to_multiple (-1) [1..<dim_row M] 0 M) $$ (i, j) = (int \<Lambda>)" 
+    using transpose_N_mult_off_diag v_non_zero assms transpose_N_mult_dim(2) by force
+next
+  assume a: "j = 0" "i\<noteq>0"
+  then have ail: "((-1) * M $$(0, j)) = -(int \<r>)"
+    using transpose_N_mult_diag v_non_zero mdef by auto 
+  then have ijne: "j \<noteq> i" using a by simp
+  then have aij: "M $$ (i, j) = (int \<Lambda>)" using assms(2) mdef transpose_N_mult_off_diag a v_non_zero
+    by (metis transpose_N_mult_dim(1)) 
+  then have "add_row_to_multiple (-1) [1..<dim_row M] 0 M $$ (i, j) = (-1)*(int \<r>) + (int \<Lambda>)" 
+    using ail add_first_row_to_multiple_index(2) assms(2) assms(3) a by (metis mult_minus1) 
+  then show "(add_row_to_multiple (-1) [1..<dim_row M] 0 M) $$ (i, j) = (int \<Lambda>) - (int \<r>)"
+    by linarith 
+next 
+  assume a: "i \<noteq> 0" "j \<noteq> 0" 
+  have ail: "((-1) * M $$(0, j)) = -(int \<Lambda>)" 
+    using assms transpose_N_mult_off_diag a v_non_zero transpose_N_mult_dim(1) by auto  
+  then have  "i = j \<Longrightarrow> M $$ (i, j) = (int \<r>)" 
+    using assms transpose_N_mult_diag a v_non_zero by (metis transpose_N_mult_dim(1)) 
+  then show "i = j \<Longrightarrow> (add_row_to_multiple (-1) [1..<dim_row M] 0 M) $$ (i, j) = (int \<r>) - (int \<Lambda>)"
+    using ail add_first_row_to_multiple_index(2) assms a by (metis uminus_add_conv_diff) 
+  then have "i \<noteq> j \<Longrightarrow> M $$ (i, j) = (int \<Lambda>)" using assms transpose_N_mult_off_diag a v_non_zero
+    by (metis transpose_N_mult_dim(1) transpose_N_mult_dim(2)) 
+  then show "i \<noteq> j \<Longrightarrow> (add_row_to_multiple (-1) [1..<dim_row M] 0 M) $$ (i, j) = 0" 
+    using ail add_first_row_to_multiple_index(2) assms a by (metis add.commute add.right_inverse)
+qed
+
+lemma transform_N_step2_vals: 
+  defines mdef: "M \<equiv> (add_row_to_multiple (-1) [1..<dim_row (N * N\<^sup>T)] 0 (N * N\<^sup>T))"
+  assumes "i < dim_row (M)"
+  assumes "j < dim_col (M)"
+  shows "i = 0 \<Longrightarrow> j = 0 \<Longrightarrow> add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j) = 
+    (int \<r>) + (int \<Lambda>) * (\<v> - 1)" \<comment> \<open> top left element \<close>
+  and "i = 0 \<Longrightarrow> j \<noteq> 0 \<Longrightarrow> add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j)  = (int \<Lambda>)" \<comment> \<open> top row \<close>
+  and "i \<noteq> 0 \<Longrightarrow> i = j \<Longrightarrow> add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j) = (int \<r>) - (int \<Lambda>)" \<comment> \<open> Diagonal \<close>
+  and "i \<noteq> 0 \<Longrightarrow> i \<noteq> j \<Longrightarrow>  add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j) = 0" \<comment> \<open>Everything else\<close>
+proof -
+  show "i = 0 \<Longrightarrow> j \<noteq> 0 \<Longrightarrow> add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j)  = (int \<Lambda>)"
+    using add_all_cols_to_first assms transform_N_step1_vals(3) by simp
+  show "i \<noteq> 0 \<Longrightarrow> i = j \<Longrightarrow> add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j) = (int \<r>) - (int \<Lambda>)"
+    using add_all_cols_to_first assms transform_N_step1_vals(4) by simp
+next
+  assume a: "i = 0" "j =0"
+  then have size: "card {1..<dim_col M} = \<v> - 1" using assms by simp 
+  have val: "\<And> l . l \<in> {1..<dim_col M} \<Longrightarrow> M $$ (i, l) = (int \<Lambda>)" 
+    using mdef transform_N_step1_vals(3) by (simp add: a(1))
+  have "add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j) = (\<Sum>l\<in>{1..<dim_col M}.  M $$(i,l)) + M$$(i,0)" 
+    using a assms add_all_cols_to_first by blast 
+  also have "... = (\<Sum>l\<in>{1..<dim_col M}.  (int \<Lambda>)) + M$$(i,0)" using val by simp
+  also have "... = (\<v> - 1) * (int \<Lambda>) + M$$(i,0)" using size by (metis sum_constant) 
+  finally show "add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j) = (int \<r>) + (int \<Lambda>) * (\<v> - 1)" 
+    using transform_N_step1_vals(1) a(1) a(2) assms(1) assms(2) by simp 
+next
+  assume a: "i \<noteq> 0"  "i \<noteq> j"
+  then show "add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j) = 0" 
+  proof (cases "j \<noteq> 0")
+    case True
+    then show ?thesis using add_all_cols_to_first assms a transform_N_step1_vals(5) by simp
+  next 
+    case False
+    then have iin: "i \<in> {1..<dim_col M}" using a(1) assms by simp
+    have cond: "\<And> l . l \<in> {1..<dim_col M} \<Longrightarrow> l <dim_col (N * N\<^sup>T) \<and> l \<noteq> 0" using assms by simp 
+    then have val: "\<And> l . l \<in> {1..<dim_col M } - {i} \<Longrightarrow> M $$ (i, l) = 0" 
+      using assms(3) transform_N_step1_vals(5) a False assms(1)
+      by (metis DiffE iin index_mult_mat(2) index_mult_mat(3) index_transpose_mat(3) insertI1) 
+    have val2: "M $$ (i, i) = (int \<r>) - (int \<Lambda>)" using mdef transform_N_step1_vals(4) a False
+       assms(1) transpose_N_mult_dim(1) transpose_N_mult_dim(2)
+      by (metis cond iin) 
+    have val3: "M$$ (i, 0) = (int \<Lambda>) - (int \<r>)" 
+      using assms(3) transform_N_step1_vals(2) a False assms(1) assms(2)
+      by (metis add_row_to_multiple_dim(1) transpose_N_mult_dim(2) v_non_zero)
+    have "add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j) = (\<Sum>l\<in>{1..<dim_col M}.  M $$(i,l)) + M$$(i,0)" 
+      using assms add_all_cols_to_first False by blast
+    also have "... = M $$ (i, i)  + (\<Sum>l\<in>{1..<dim_col M} - {i}.  M $$(i,l)) + M$$(i,0)"
+      by (metis iin finite_atLeastLessThan sum.remove)
+    finally show ?thesis using val val2 val3 by simp
+  qed
+qed
+
+text \<open>Transformed matrix is upper triangular \<close>
+lemma transform_upper_triangular: 
+  defines mdef: "M \<equiv> (add_row_to_multiple (-1) [1..<dim_row (N * N\<^sup>T)] 0 (N * N\<^sup>T))"
+  shows "upper_triangular (add_multiple_cols 1 0 [1..<dim_col M] M)"
+  using transform_N_step2_vals(4) by (intro upper_triangularI) (simp add: assms)
+
+text \<open>Find the determinant of the $NN^T$ matrix using transformed matrix values\<close>
+lemma determinant_inc_mat_square: "det (N * N\<^sup>T) = (\<r> + \<Lambda> * (\<v> - 1))* (\<r> - \<Lambda>)^(\<v> - 1)"
+proof -
+\<comment> \<open> Show the matrix is now lower triangular, therefore the det is the product of the sum of diagonal \<close>
+  have cm: "(N * N\<^sup>T) \<in> carrier_mat \<v> \<v>"
+    using transpose_N_mult_dim(1) transpose_N_mult_dim(2) by blast  
+  define C where "C \<equiv>(add_row_to_multiple (-1) [1..<dim_row (N * N\<^sup>T)] 0 (N * N\<^sup>T))"
+  have "0 \<notin> set [1..<dim_row (N * N\<^sup>T)]" by simp
+  then have detbc: "det (N * N\<^sup>T) = det C" 
+    using C_def add_row_to_multiple_det v_non_zero by (metis cm) 
+  define D where "D \<equiv> add_multiple_cols 1 0 [1..<dim_col C] C"
+  have d00: "D $$ (0, 0) = ((int \<r>) + (int \<Lambda>) * (\<v> - 1))" using transform_N_step2_vals(1)
+    by (simp add: C_def D_def v_non_zero) 
+  have ine0: "\<And> i. i \<in> {1..<dim_row D} \<Longrightarrow> i \<noteq> 0" by simp
+  have "\<And> i. i \<in> {1..<dim_row D} \<Longrightarrow> i < dim_row (N * N\<^sup>T)" using D_def C_def by simp       
+  then have diagnon0: "\<And> i. i \<in> {1..<\<v>} \<Longrightarrow> D $$ (i, i) = (int \<r>) - (int \<Lambda>)"   
+    using transform_N_step2_vals(3) ine0 D_def C_def by simp (* Slow *)
+  have alll: "\<And> l. l \<in> set [1..<dim_col C] \<Longrightarrow> l < \<v>" using C_def by simp
+  have cmc: "C \<in> carrier_mat \<v> \<v>" using cm C_def
+    by (simp add: add_row_to_multiple_carrier)
+  have dimgt2: "dim_row D \<ge> 2"
+    using t_lt_order D_def C_def by (simp)  
+  then have fstterm: "0 \<in> { 0 ..< dim_row D}" by (simp add: points_list_length)
+  have "0 \<notin> set [1..<dim_col C]" by simp
+  then have "det (N * N\<^sup>T) = det D" using add_multiple_cols_det alll cmc D_def C_def
+    by (metis detbc) 
+  also have "... = prod_list (diag_mat D)" using det_upper_triangular
+    using transform_upper_triangular D_def C_def by fastforce 
+  also have "... = (\<Prod> i = 0 ..< dim_row D. D $$ (i,i))" using prod_list_diag_prod by blast  
+  also have "... = (\<Prod> i = 0 ..< \<v>. D $$ (i,i))"  by (simp add: D_def C_def)  
+  finally have "det (N * N\<^sup>T) = D $$ (0, 0) * (\<Prod> i =  1 ..< \<v>. D $$ (i,i))" 
+    using dimgt2 by (simp add: prod.atLeast_Suc_lessThan v_non_zero) 
+  then have "det (N * N\<^sup>T) = (\<r> + \<Lambda> * (\<v> - 1)) * ((int \<r>) - (int \<Lambda>))^(\<v> - 1)"
+    using d00 diagnon0 by simp
+  then have "det (N * N\<^sup>T) = (\<r> + \<Lambda> * (\<v> - 1)) * ( \<r> - \<Lambda>)^(\<v> - 1)"
+    using index_lt_replication
+    by (metis (no_types, lifting) less_imp_le_nat of_nat_diff of_nat_mult of_nat_power)
+  then show ?thesis by blast 
+qed
+
+text \<open>Fisher's Inequality using the rank argument. 
+Note that to use the rank argument we must first map N to a real matrix. It is useful to explicitly
+include the parameters which should be used in the application of the @{thm [source] "rank_argument_det"} lemma \<close>
+theorem Fishers_Inequality_BIBD: "\<v> \<le> \<b>"
+proof (intro rank_argument_det[of "map_mat real_of_int N" "\<v>" "\<b>"], simp_all)
+  show "N \<in> carrier_mat \<v> (length \<B>s)" using blocks_list_length N_carrier_mat by simp
+  let ?B = "map_mat (real_of_int) (N * N\<^sup>T)"
+  have b_split: "?B = map_mat (real_of_int) N * (map_mat (real_of_int) N)\<^sup>T"
+    using semiring_hom.mat_hom_mult  of_int_hom.semiring_hom_axioms transpose_carrier_mat map_mat_transpose
+    by (metis (no_types, lifting) N_carrier_mat) 
+  have db: "det ?B = (\<r> + \<Lambda> * (\<v> - 1))* (\<r> - \<Lambda>)^(\<v> - 1)"
+    using determinant_inc_mat_square by simp
+  have lhn0: "(\<r> + \<Lambda> * (\<v> - 1)) > 0"
+    using r_gzero by blast 
+  have "(\<r> - \<Lambda>) > 0"
+    using index_lt_replication zero_less_diff by blast  
+  then have det_not_0:  "det ?B \<noteq> 0" using lhn0 db
+    by (metis gr_implies_not0 mult_is_0 of_nat_eq_0_iff power_not_zero) 
+  thus "det (of_int_hom.mat_hom N * (of_int_hom.mat_hom N)\<^sup>T) \<noteq> (0:: real)" using b_split by simp
+qed
+
+end
+
+subsection \<open>Generalised Fisher's Inequality \<close>
+
+context simp_ordered_const_intersect_design
+begin
+
+text \<open>Lemma to reason on sum coefficients \<close>
+lemma sum_split_coeffs_0: 
+  fixes c :: "nat \<Rightarrow> real"
+  assumes "\<b> \<ge> 2"
+  assumes "\<m> > 0"
+  assumes "j' < \<b>"
+  assumes "0 = (\<Sum> j \<in> {0..<\<b>} . (c j)^2 * ((card (\<B>s ! j))- (int \<m>))) +
+           \<m> * ((\<Sum> j \<in> {0..<\<b>} . c j)^2)"
+  shows "c j' = 0"
+proof (rule ccontr)
+  assume cine0: "c j' \<noteq> 0"
+  have innerge: "\<And> j . j < \<b>  \<Longrightarrow> (c j)^2 * (card (\<B>s ! j) - (int \<m>))  \<ge> 0" 
+    using inter_num_le_block_size assms(1) by simp
+  then have lhsge: "(\<Sum> j \<in> {0..<\<b>} . (c j)^2 * ((card (\<B>s ! j))- (int \<m>))) \<ge> 0"
+    using sum_bounded_below[of "{0..<\<b>}" "0" "\<lambda> i. (c i)^2 * ((card (\<B>s ! i))- (int \<m>))"] by simp
+  have "\<m> * ((\<Sum> j \<in> {0..<\<b>} . c j)^2) \<ge> 0" by simp
+  then have rhs0: "\<m> * ((\<Sum> j \<in> {0..<\<b>} . c j)^2) = 0" 
+    using assms(2) assms(4) lhsge by linarith
+  then have "(\<Sum> j \<in> {0..<\<b>} . (c j)^2 * ((card (\<B>s ! j))- (int \<m>))) = 0" 
+    using assms by linarith
+  then have lhs0inner: "\<And> j . j < \<b>  \<Longrightarrow> (c j)^2 * (card (\<B>s ! j) - (int \<m>)) = 0" 
+    using innerge sum_nonneg_eq_0_iff[of "{0..<\<b>}" "\<lambda> j . (c j)^2 * (card (\<B>s ! j) - (int \<m>))"] 
+    by simp
+  thus False proof (cases "card (\<B>s ! j') = \<m>")
+    case True
+    then have cj0: "\<And> j. j \<in> {0..<\<b>} - {j'} \<Longrightarrow> (c j) = 0"
+      using lhs0inner const_intersect_block_size_diff assms True by auto
+    then have "(\<Sum> i \<in> {0..<\<b>} . c i) \<noteq> 0" 
+      using sum.remove[of "{0..<\<b>}" "j'" "\<lambda> i. c i"] assms(3) cine0 cj0 by simp
+    then show ?thesis using rhs0 assms by simp
+  next
+    case False
+    then have ne: "(card (\<B>s ! j') - (int \<m>)) \<noteq> 0"
+      by linarith  
+    then have "(c j')^2 * (card (\<B>s ! j') - (int \<m>)) \<noteq> 0" using cine0
+      by auto 
+    then show ?thesis using lhs0inner assms(3) by auto
+  qed
+qed
+
+text \<open>The general non-uniform version of fisher's inequality is also known as the "Block town problem".
+In this case we are working in a constant intersect design, hence the inequality is the opposite
+way around compared to the BIBD version. The theorem below is the more traditional set theoretic 
+approach. This proof is based off one by Jukna \cite{juknaExtremalCombinatorics2011} \<close>
+theorem general_fishers_inequality:  "\<b> \<le> \<v>"
+proof (cases "\<m> = 0 \<or> \<b> = 1")
+  case True
+  then show ?thesis using empty_inter_implies_b_lt_v v_non_zero by linarith
+next
+  case False
+  then have mge: "\<m> > 0" by simp 
+  then have bge: "\<b> \<ge> 2" using b_positive False blocks_list_length by linarith
+  define NR :: "real mat" where "NR \<equiv> lift_01_mat N"
+  show ?thesis 
+  proof (intro lin_bound_argument2[of NR])
+    show "distinct (cols NR)" using lift_01_distinct_cols_N NR_def by simp
+    show nrcm: "NR \<in> carrier_mat \<v> \<b>" using NR_def N_carrier_mat_01_lift by simp 
+    have scalar_prod_real1: "\<And> i. i <\<b> \<Longrightarrow>  ((col NR i) \<bullet> (col NR i)) = card (\<B>s ! i)"
+      using scalar_prod_block_size_lift_01 NR_def by auto 
+    have scalar_prod_real2: "\<And> i j. i <\<b> \<Longrightarrow> j <\<b> \<Longrightarrow> i \<noteq> j \<Longrightarrow> ((col NR i) \<bullet> (col NR j)) = \<m>"
+      using scalar_prod_inter_num_lift_01 NR_def indexed_const_intersect by auto
+    show "\<And>f. vec \<v> (\<lambda>i. \<Sum>j = 0..<\<b>. f (col NR j) * (col NR j) $ i) = 0\<^sub>v \<v> \<Longrightarrow> \<forall>v\<in>set (cols NR). f v = 0"
+    proof (intro ballI)
+      fix f v
+      assume eq0: "vec \<v> (\<lambda>i. \<Sum>j = 0..<\<b>. f (col NR j) * col NR j $ i) = 0\<^sub>v \<v>"
+      assume vin: "v \<in> set (cols NR)"
+      define c where "c \<equiv> (\<lambda> j. f (col NR j))"
+      obtain j' where v_def: "col NR j' = v" and jvlt: "j' < dim_col NR"
+        using vin by (metis cols_length cols_nth index_less_size_conv nth_index)
+      have dim_col: "\<And>j. j \<in> {0..< \<b>} \<Longrightarrow> dim_vec (col NR j) = \<v>" using nrcm by auto
+      \<comment> \<open> Summation reasoning to obtain conclusion on coefficients \<close>
+      have "0 = (vec \<v> (\<lambda>i. \<Sum>j = 0..<\<b>. c j * (col NR j) $ i)) \<bullet> (vec \<v> (\<lambda>i. \<Sum>j = 0..<\<b>. c j * (col NR j) $ i))" 
+        using vec_prod_zero eq0 c_def by simp
+      also have "... = (\<Sum> j1 \<in> {0..<\<b>} . c j1 * c j1 * ((col NR j1) \<bullet> (col NR j1))) + (\<Sum> j1 \<in> {0..<\<b>} . 
+        (\<Sum> j2 \<in> ({0..< \<b>} - {j1}) . c j1 * c j2 * ((col NR j1) \<bullet> (col NR j2))))" 
+        using scalar_prod_double_sum_fn_vec[of \<b> "col NR" \<v> c] dim_col by simp
+      also have "... = (\<Sum> j1 \<in> {0..<\<b>} . (c j1) * (c j1) * (card (\<B>s ! j1))) + (\<Sum> j1 \<in> {0..<\<b>} . 
+        (\<Sum> j2 \<in> ({0..< \<b>} - {j1}) . c j1 * c j2 * ((col NR j1) \<bullet> (col NR j2))))"
+        using scalar_prod_real1 by simp
+      also have "... = (\<Sum> j1 \<in> {0..<\<b>} . (c j1)^2 * (card (\<B>s ! j1))) + (\<Sum> j1 \<in> {0..<\<b>} . 
+        (\<Sum> j2 \<in> ({0..< \<b>} - {j1}) . c j1 * c j2 * ((col NR j1) \<bullet> (col NR j2))))"
+        by (metis power2_eq_square) 
+      also have "... = (\<Sum> j1 \<in> {0..<\<b>} . (c j1)^2 * (card (\<B>s ! j1))) + (\<Sum> j1 \<in> {0..<\<b>} . 
+        (\<Sum> j2 \<in> ({0..< \<b>} - {j1}) . c j1 * c j2 * \<m>))" using scalar_prod_real2  by auto
+      also have "... = (\<Sum> j1 \<in> {0..<\<b>} . (c j1)^2 * (card (\<B>s ! j1))) + 
+         \<m> * (\<Sum> j1 \<in> {0..<\<b>} . (\<Sum> j2 \<in> ({0..< \<b>} - {j1}) . c j1 * c j2))" 
+        using double_sum_mult_hom[of "\<m>" "\<lambda> i j . c i * c j" "\<lambda> i.{0..<\<b>} - {i}" "{0..<\<b>}"]
+        by (metis (no_types, lifting) mult_of_nat_commute sum.cong) 
+      also have "... = (\<Sum> j \<in> {0..<\<b>} . (c j)^2 * (card (\<B>s ! j))) + 
+         \<m> * ((\<Sum> j \<in> {0..<\<b>} . c j)^2 - (\<Sum> j \<in> {0..<\<b>} . c j * c j))" 
+        using double_sum_split_square_diff by auto 
+      also have "... = (\<Sum> j \<in> {0..<\<b>} . (c j)^2 * (card (\<B>s ! j))) + (-\<m>) * (\<Sum> j \<in> {0..<\<b>} . (c j)^2) + 
+         \<m> * ((\<Sum> j \<in> {0..<\<b>} . c j)^2)" by (simp add: algebra_simps power2_eq_square)
+      also have "... = (\<Sum> j \<in> {0..<\<b>} . (c j)^2 * (card (\<B>s ! j))) + (\<Sum> j \<in> {0..<\<b>} . (-\<m>)* (c j)^2) + 
+         \<m> * ((\<Sum> j \<in> {0..<\<b>} . c j)^2)" by (simp add: sum_distrib_left) 
+      also have "... = (\<Sum> j \<in> {0..<\<b>} . (c j)^2 * (card (\<B>s ! j))+ (-\<m>)* (c j)^2) + 
+         \<m> * ((\<Sum> j \<in> {0..<\<b>} . c j)^2)" by (metis (no_types) sum.distrib)
+      finally have sum_rep: "0 = (\<Sum> j \<in> {0..<\<b>} . (c j)^2 * ((card (\<B>s ! j))- (int \<m>))) + 
+         \<m> * ((\<Sum> j \<in> {0..<\<b>} . c j)^2)" by (simp add: algebra_simps)
+      thus "f v = 0" using sum_split_coeffs_0[of "j'" "c"] mge bge jvlt nrcm c_def v_def by simp
+    qed
+  qed
+qed
+
+end
+
+text \<open>Using the dual design concept, it is easy to translate the set theoretic general definition
+of Fisher's inequality to a more traditional design theoretic version on pairwise balanced designs. 
+Two versions of this are given using different trivial (but crucial) conditions on design properties\<close>
+context ordered_pairwise_balance
+begin
+
+corollary general_nonuniform_fishers: \<comment> \<open>only valid on incomplete designs \<close>
+  assumes "\<Lambda> > 0" 
+  assumes "\<And> bl. bl \<in># \<B> \<Longrightarrow> incomplete_block bl" 
+    \<comment> \<open> i.e. not a super trivial design with only complete blocks \<close>
+  shows "\<v> \<le> \<b>"
+proof -
+  have "mset (\<B>s*) = dual_blocks \<V> \<B>s" using dual_blocks_ordered_eq by simp
+  then interpret des: simple_const_intersect_design "set [0..<(length \<B>s)]" "mset (\<B>s*)" \<Lambda> 
+    using assms dual_is_simp_const_inter_des by simp
+  interpret odes: simp_ordered_const_intersect_design "[0..<length \<B>s]" "\<B>s*" \<Lambda> 
+    using distinct_upt des.wellformed by (unfold_locales) (blast)
+  have "length (\<B>s*) \<le> length [0..<length \<B>s]" using odes.general_fishers_inequality
+    using odes.blocks_list_length odes.points_list_length by presburger
+  then have "\<v> \<le> length \<B>s"
+    by (simp add: dual_blocks_len points_list_length) 
+  then show ?thesis by auto
+qed
+
+corollary general_nonuniform_fishers_comp: 
+  assumes "\<Lambda> > 0" 
+  assumes "count \<B> \<V> < \<Lambda>" \<comment> \<open> i.e. not a super trivial design with only complete blocks and single blocks \<close>
+  shows "\<v> \<le> \<b>"
+proof -
+  define B where "B = (removeAll_mset \<V> \<B>)"
+  have b_smaller: "size B \<le> \<b>" using B_def removeAll_size_lt by simp
+  then have b_incomp: "\<And> bl. bl \<in># B \<Longrightarrow> card bl < \<v>"
+    using wellformed B_def by (simp add: psubsetI psubset_card_mono) 
+  have index_gt: "(\<Lambda> - (count \<B> \<V>)) > 0" using assms by simp 
+  interpret pbd: pairwise_balance \<V> B "(\<Lambda> - (count \<B> \<V>))"
+    using remove_all_complete_blocks_pbd B_def assms(2) by blast 
+  obtain Bs where m: "mset Bs = B"
+    using ex_mset by blast 
+  interpret opbd: ordered_pairwise_balance \<V>s Bs "(\<Lambda> - (count \<B> \<V>))" 
+    by (intro pbd.ordered_pbdI) (simp_all add: m distinct)
+  have "\<v> \<le> (size B)" using b_incomp opbd.general_nonuniform_fishers
+    using index_gt m by blast 
+  then show ?thesis using b_smaller m by auto
+qed
+
+end
+end
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/Fishers_Inequality_Root.thy b/thys/Fishers_Inequality/Fishers_Inequality_Root.thy
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/Fishers_Inequality_Root.thy
@@ -0,0 +1,21 @@
+(* Title: Fishers_Inequality_Root.thy
+   Author: Chelsea Edmonds
+*)
+
+theory Fishers_Inequality_Root
+imports
+  Set_Multiset_Extras
+  Matrix_Vector_Extras
+  Design_Extras
+
+  Incidence_Matrices
+  Dual_Systems
+  Rank_Argument_General
+  Linear_Bound_Argument
+
+  Fishers_Inequality
+  Vector_Matrix_Mod
+  Fishers_Inequality_Variations
+begin
+
+end
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/Fishers_Inequality_Variations.thy b/thys/Fishers_Inequality/Fishers_Inequality_Variations.thy
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/Fishers_Inequality_Variations.thy
@@ -0,0 +1,211 @@
+(* Title: Fishers_Inequality_Variations.thy
+   Author: Chelsea Edmonds
+*)
+
+section \<open>Variations on Fisher's Inequality \<close>
+
+theory Fishers_Inequality_Variations imports Dual_Systems Rank_Argument_General
+Vector_Matrix_Mod Linear_Bound_Argument
+begin
+
+subsection \<open> Matrix mod properties \<close>
+text \<open>This is reasoning on properties specific to incidence matrices under @{term "mat_mod"}. Ultimately, 
+this definition was not used in the final proof but it is left as is in case of future use \<close>
+
+context mat_mod
+begin
+
+lemma mat_mod_proper_iff:  "proper_inc_mat (mat_mod N)  \<longleftrightarrow> proper_inc_mat N"
+  by (simp add: proper_inc_mat_def)
+
+lemma mat_mod_rep_num_eq:  "i < dim_row N \<Longrightarrow> elements_mat N \<subseteq> {0..<m} \<Longrightarrow> 
+    mat_rep_num (mat_mod N) i = mat_rep_num N i"
+  by (simp add: mat_mod_count_row_eq mat_rep_num_def)
+
+lemma mat_point_index_eq: "elements_mat N \<subseteq> {0..<m} \<Longrightarrow> 
+    mat_point_index (mat_mod N) I = mat_point_index N I"
+  by (simp add:  mat_mod_eq_cond) 
+
+lemma mod_mat_inter_num_eq: "elements_mat N \<subseteq> {0..<m} \<Longrightarrow> 
+    mat_inter_num (mat_mod N) j1 j2 = mat_inter_num N j1 j2"
+  by (simp add: mat_mod_eq_cond) 
+
+lemma mod_mat_block_size: "elements_mat N \<subseteq> {0..<m} \<Longrightarrow> mat_block_size (mat_mod N) j = mat_block_size N j"
+  by (simp add: mat_mod_eq_cond) 
+
+lemma mat_mod_non_empty_col_iff: "elements_mat M \<subseteq> {0..<m} \<Longrightarrow> 
+    non_empty_col (mat_mod M) j \<longleftrightarrow> non_empty_col M j"
+  using mat_mod_eq_cond by auto 
+end
+
+context mat_mod_type
+begin
+
+lemma mat_rep_num_MM_Rel: 
+  assumes "MM_Rel A B"
+  assumes "i < dim_row A"
+  shows "mat_rep_num (mat_mod A) i = mat_rep_num B i"
+  unfolding mat_rep_num_def using vec_count_MV_Rel_direct assms mat_mod_vec_mod_row row_map_mat
+  by (metis MM_Rel_def MV_Rel_def index_map_mat(2) mat_mod_dim(1) to_int_mod_ring_hom.hom_one) 
+
+
+lemma mat_block_size_MM_Rel: 
+  assumes "MM_Rel A B"
+  assumes " j < dim_col A"
+  shows "mat_block_size (mat_mod A) j = mat_block_size B j"
+  unfolding mat_block_size_def using vec_count_MV_Rel_direct assms MM_Rel_MV_Rel_col
+  by (metis mat_mod_vec_mod_col to_int_mod_ring_hom.hom_one) 
+
+lemma mat_inter_num_MM_Rel: 
+  assumes "MM_Rel A B"
+  assumes "j1 < dim_col A" "j2 < dim_col B"
+  shows "mat_inter_num (mat_mod A) j1 j2 = mat_inter_num B j1 j2"
+  unfolding mat_inter_num_def using assms index_map_mat mat_mod_dim(2)
+  by (smt (z3) Collect_cong MM_Rel_def to_int_mod_ring_hom.hom_1 to_int_mod_ring_hom.hom_one) 
+
+
+text \<open> Lift 01 and mat mod equivalence on 0-1 matrices \<close>
+
+lemma of_int_mod_ring_lift_01_eq: 
+  assumes "zero_one_matrix N"
+  shows "map_mat (of_int_mod_ring) N = (lift_01_mat) N"
+  apply (auto simp add: mat_eq_iff[of "map_mat (of_int_mod_ring) N" "lift_01_mat N"])
+  using assms zero_one_matrix.M_not_one_simp by fastforce
+
+lemma to_int_mod_ring_lift_01_eq: 
+  assumes "zero_one_matrix N"
+  shows "to_int_mat N = (lift_01_mat) N"
+  apply (auto simp add: mat_eq_iff[of "to_int_mat N" "lift_01_mat N"])
+  using assms using zero_one_matrix.M_not_zero_simp by fastforce 
+
+end
+
+subsection \<open>The Odd-town Problem\<close>
+text \<open> The odd-town problem \cite{abaiLINEARALGEBRAMETHODS1988} is perhaps one of the most common 
+introductory problems for applying the linear algebra bound method to a combinatorial problem. 
+In mathematical literature, it is considered simpler than Fisher's Inequality, however presents some 
+interesting challenges to formalisation. Most significantly, it considers the incidence matrix to have 
+elements of types integers mod 2. \<close>
+
+text \<open>Initially, define a locale to represent the odd town context (a town with v people, and b groups) 
+which must each be of odd size, but have an even intersection number with any other group \<close>
+locale odd_town = ordered_design + 
+  assumes odd_groups: "bl \<in># \<B> \<Longrightarrow> odd (card bl)"
+  and even_inters: "bl1 \<in># \<B> \<Longrightarrow> bl2 \<in># (\<B> - {#bl1#})  \<Longrightarrow> even (bl1 |\<inter>| bl2)"
+begin
+
+lemma odd_town_no_repeat_clubs: "distinct_mset \<B>"
+proof (rule ccontr)
+  assume "\<not> distinct_mset \<B>"
+  then obtain a where ain: "a \<in># \<B>" and countne: "count \<B> a \<noteq> 1"
+    by (auto simp add: distinct_mset_def)
+  then have "count \<B> a > 1"
+    using nat_less_le by auto 
+  then have ain2: "a \<in># (\<B> - {#a#})"
+    by (simp add: in_diff_count) 
+  then have "odd (a |\<inter>| a)" using odd_groups ain by simp
+  thus False using even_inters ain ain2
+    by blast 
+qed
+
+lemma odd_blocks_mat_block_size: "j < dim_col N \<Longrightarrow> odd (mat_block_size N j)"
+  using mat_block_size_conv odd_groups 
+  by (metis dim_col_is_b valid_blocks_index) 
+
+lemma odd_block_size_mod_2: 
+  assumes "CARD('b::prime_card) = 2"
+  assumes "j < \<b>"
+  shows "of_nat (card (\<B>s ! j)) = (1 :: 'b mod_ring)"
+proof -
+  have cb2: "CARD('b) = 2" using assms by simp
+  then have "odd (card (\<B>s ! j))" using \<open>j < \<b>\<close> odd_groups by auto 
+  then show "of_nat (card (\<B>s ! j)) = (1 :: 'b mod_ring)"
+    by(transfer' fixing: j \<B>s, simp add: cb2) presburger
+qed
+
+lemma valid_indices_block_min: "j1 < dim_col N \<Longrightarrow> j2 < dim_col N \<Longrightarrow> j1 \<noteq> j2 \<Longrightarrow> \<b> \<ge> 2"
+  by simp
+
+lemma even_inter_mat_intersections: "j1 < dim_col N \<Longrightarrow> j2 < dim_col N \<Longrightarrow> j1 \<noteq> j2
+  \<Longrightarrow> even (mat_inter_num N j1 j2)"
+  using even_inters mat_inter_num_conv valid_indices_block_min
+  by (metis dim_col_is_b obtains_two_diff_block_indexes) 
+
+lemma even_inter_mod_2: 
+  assumes "CARD('b::prime_card) = 2"
+  assumes "i < \<b>" and jlt: "j < \<b>" and ne: "i \<noteq> j"
+  shows "of_nat ((\<B>s ! i) |\<inter>| (\<B>s ! j)) = (0 :: 'b mod_ring)"
+proof -
+  have cb2: "CARD('b) = 2" using assms by simp
+  have "even ((\<B>s ! i) |\<inter>| (\<B>s ! j))" using even_inters assms
+    using blocks_index_ne_belong blocks_list_length valid_blocks_index by presburger 
+  then show "of_nat ((\<B>s ! i) |\<inter>| (\<B>s ! j)) = (0 :: 'b mod_ring)"
+    by (transfer' fixing: i j \<B>s, simp add: cb2)
+qed
+
+end
+
+text \<open>The odd town locale must be simple by definition \<close>
+sublocale odd_town \<subseteq> ordered_simple_design
+  using odd_town_no_repeat_clubs by (unfold_locales) (meson distinct_mset_def) 
+
+context odd_town 
+begin
+
+text \<open>The upper bound lemma (i.e. variation on Fisher's) for the odd town property using the linear 
+bound argument. Notice it follows exactly the same pattern as the generalised version, however
+it's sum manipulation argument is significantly simpler (in line with the mathematical proofs) \<close>
+lemma upper_bound_clubs: 
+  assumes "CARD('b::prime_card) = 2"
+  shows "\<b> \<le> \<v>"
+proof -
+  have cb2: "CARD('b) = 2" using assms by simp
+  then interpret mmt: mat_mod_type 2 "TYPE('b::prime_card)" 
+    using assms by (unfold_locales) (simp_all)
+  define N2 :: "'b mod_ring mat" where "N2 \<equiv> lift_01_mat N"
+  show ?thesis proof (intro lin_bound_argument2[of "N2"])
+    show "distinct (cols (N2))" using lift_01_distinct_cols_N N2_def by simp
+    show n2cm:"N2 \<in> carrier_mat \<v> \<b>" using N2_def N_carrier_mat_01_lift by simp 
+    have scalar_prod_odd: "\<And> i. i <\<b> \<Longrightarrow> ((col N2 i) \<bullet> (col N2 i)) = 1"
+      using scalar_prod_block_size_lift_01 N2_def odd_block_size_mod_2 assms by (metis cb2) 
+    have scalar_prod_even: "\<And> i j. i <\<b> \<Longrightarrow> j <\<b> \<Longrightarrow> i \<noteq> j \<Longrightarrow> ((col N2 i) \<bullet> (col N2 j)) = 0"
+      using even_inter_mod_2 scalar_prod_inter_num_lift_01 N2_def assms by metis 
+    show "\<And>f. vec \<v> (\<lambda>i. \<Sum>j = 0..<\<b>. f (col N2 j) * (col N2 j) $ i) = 0\<^sub>v \<v> \<Longrightarrow> \<forall>v\<in>set (cols N2). f v = 0"
+    proof (auto)
+      fix f v 
+      assume eq0: "vec \<v> (\<lambda>i. \<Sum>j = 0..<length \<B>s. f (col N2 j) * (col N2 j) $ i) = 0\<^sub>v \<v>" 
+      assume vin: "v \<in> set (cols N2)"
+      define c where "c \<equiv> (\<lambda> j. f (col N2 j))"
+      have inner: "\<And> j l. v $ l * (c j * (col N2 j) $ l) = c j * v $ l *  (col N2 j) $ l" 
+        using mult.commute by auto
+      obtain j' where v_def: "col N2 j' = v" and jvlt: "j' < dim_col N2"
+        using vin by (metis cols_length cols_nth index_less_size_conv nth_index) 
+      then have jvltb: "j' < \<b>" using n2cm by simp
+      then have even0: "\<And> j. j \<in> {0..<\<b>} - {j'} \<Longrightarrow>  c j * (v \<bullet> (col N2 j)) = 0"
+        using scalar_prod_even v_def by fastforce
+      have vinc: "v \<in> carrier_vec \<v>" using n2cm set_cols_carrier vin by blast
+      then have "0 = v \<bullet> vec \<v> (\<lambda>i. \<Sum>j = 0..<\<b>. c j * (col N2 j) $ i)"
+        using eq0 c_def by auto  
+      also have "... = (\<Sum> l =0..<dim_row N2 . v $ l *  (\<Sum> j = 0..<dim_col N2 . (c j * (col N2 j) $ l)))"
+        unfolding scalar_prod_def using n2cm by auto 
+      also have "... = (\<Sum> l =0..<dim_row N2 . (\<Sum> j = 0..<dim_col N2 . v $ l * (c j * (col N2 j) $ l)))"
+        by (simp add: sum_distrib_left) 
+      also have "... = (\<Sum> j \<in> {0..<dim_col N2} .  v \<bullet> (c j \<cdot>\<^sub>v (col N2 j)))" 
+        using sum.swap scalar_prod_def[of v] by simp
+      also have "... = v \<bullet> (c j' \<cdot>\<^sub>v v) + (\<Sum> j \<in> {0..<dim_col N2} - {j'}.  v \<bullet> (c j \<cdot>\<^sub>v (col N2 j)))" 
+        using jvlt sum.remove[of "{0..<dim_col N2}" "j'" "\<lambda> j. v \<bullet> (c j \<cdot>\<^sub>v (col N2 j))"] v_def by simp
+      also have "... = v \<bullet> (c j' \<cdot>\<^sub>v v) + (\<Sum> j \<in> {0..<\<b>} - {j'}.  c j * (v \<bullet> (col N2 j)))" 
+        using n2cm scalar_prod_smult_distrib col_dim v_def by force 
+      also have "... = v \<bullet> (c j' \<cdot>\<^sub>v v)" 
+        using even0 by (simp add: sum.neutral)
+      also have "... = (c j') * (v \<bullet> v)" 
+        using scalar_prod_smult_distrib by (simp add: v_def)                 
+      finally have "0 = (c j')" using v_def jvlt n2cm scalar_prod_odd by fastforce 
+      then show "f v = 0" using c_def v_def by simp 
+    qed
+  qed
+qed
+
+end
+
+end
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/Incidence_Matrices.thy b/thys/Fishers_Inequality/Incidence_Matrices.thy
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/Incidence_Matrices.thy
@@ -0,0 +1,2084 @@
+(* Author: Chelsea Edmonds
+Theory: Incidence_Matrices.thy 
+*)
+
+section \<open> Incidence Vectors and Matrices \<close>
+text \<open>Incidence Matrices are an important representation for any incidence set system. The majority
+of basic definitions and properties proved in this theory are based on Stinson \cite{stinsonCombinatorialDesignsConstructions2004}
+and Colbourn \cite{colbournHandbookCombinatorialDesigns2007}.\<close>
+
+theory Incidence_Matrices imports "Design_Extras" Matrix_Vector_Extras "List-Index.List_Index"
+ "Design_Theory.Design_Isomorphisms"
+begin
+
+subsection \<open>Incidence Vectors \<close>
+text \<open>A function which takes an ordered list of points, and a block, 
+returning a 0-1 vector $v$ where there is a 1 in the ith position if point i is in that block \<close>
+
+definition inc_vec_of :: "'a list \<Rightarrow> 'a set \<Rightarrow> ('b :: {ring_1}) vec" where
+"inc_vec_of Vs bl \<equiv> vec (length Vs) (\<lambda> i . if (Vs ! i) \<in> bl then 1 else 0)"
+
+lemma inc_vec_one_zero_elems: "set\<^sub>v (inc_vec_of Vs bl) \<subseteq> {0, 1}"
+  by (auto simp add: vec_set_def inc_vec_of_def)
+
+lemma finite_inc_vec_elems: "finite (set\<^sub>v (inc_vec_of Vs bl))"
+  using finite_subset inc_vec_one_zero_elems by blast
+
+lemma inc_vec_elems_max_two: "card (set\<^sub>v (inc_vec_of Vs bl)) \<le> 2"
+  using card_mono inc_vec_one_zero_elems finite.insertI card_0_eq card_2_iff
+  by (smt (verit)  insert_absorb2 linorder_le_cases linordered_nonzero_semiring_class.zero_le_one 
+      obtain_subset_with_card_n one_add_one subset_singletonD trans_le_add1) 
+
+lemma inc_vec_dim: "dim_vec (inc_vec_of Vs bl) = length Vs"
+  by (simp add: inc_vec_of_def)
+
+lemma inc_vec_index: "i < length Vs \<Longrightarrow> inc_vec_of Vs bl $ i = (if (Vs ! i) \<in> bl then 1 else 0)"
+  by (simp add: inc_vec_of_def)
+
+lemma inc_vec_index_one_iff:  "i < length Vs \<Longrightarrow> inc_vec_of Vs bl $ i = 1 \<longleftrightarrow> Vs ! i \<in> bl"
+  by (auto simp add: inc_vec_of_def ) 
+
+lemma inc_vec_index_zero_iff: "i < length Vs \<Longrightarrow> inc_vec_of Vs bl $ i = 0 \<longleftrightarrow> Vs ! i \<notin> bl"
+  by (auto simp add: inc_vec_of_def)
+
+lemma inc_vec_of_bij_betw: 
+  assumes "inj_on f (set Vs)"
+  assumes "bl \<subseteq> (set Vs)"
+  shows "inc_vec_of Vs bl = inc_vec_of (map f Vs) (f ` bl)"
+proof (intro eq_vecI, simp_all add: inc_vec_dim)
+  fix i assume "i < length Vs"
+  then have "Vs ! i \<in> bl \<longleftrightarrow> (map f Vs) ! i \<in> (f ` bl)"
+    by (metis assms(1) assms(2) inj_on_image_mem_iff nth_map nth_mem)
+  then show "inc_vec_of Vs bl $ i = inc_vec_of (map f Vs) (f ` bl) $ i"
+    using inc_vec_index by (metis \<open>i < length Vs\<close> length_map) 
+qed
+
+subsection \<open> Incidence Matrices \<close>
+
+text \<open> A function which takes a list of points, and list of sets of points, and returns 
+a $v \times b$ 0-1 matrix $M$, where $v$ is the number of points, and $b$ the number of sets, such 
+that there is a 1 in the i, j position if and only if point i is in block j. The matrix has 
+type @{typ "('b :: ring_1) mat"} to allow for operations commonly used on matrices \cite{stinsonCombinatorialDesignsConstructions2004}\<close>
+
+definition inc_mat_of :: "'a list \<Rightarrow> 'a set list \<Rightarrow> ('b :: {ring_1}) mat" where
+"inc_mat_of Vs Bs \<equiv> mat (length Vs) (length Bs) (\<lambda> (i,j) . if (Vs ! i) \<in> (Bs ! j) then 1 else 0)"
+
+text \<open> Basic lemmas on the @{term "inc_mat_of"} matrix result (elements/dimensions/indexing)\<close>
+
+lemma inc_mat_one_zero_elems: "elements_mat (inc_mat_of Vs Bs) \<subseteq> {0, 1}"
+  by (auto simp add: inc_mat_of_def elements_mat_def)
+
+lemma fin_incidence_mat_elems: "finite (elements_mat (inc_mat_of Vs Bs))"
+  using finite_subset inc_mat_one_zero_elems by auto 
+
+lemma inc_matrix_elems_max_two: "card (elements_mat (inc_mat_of Vs Bs)) \<le> 2"
+  using inc_mat_one_zero_elems order_trans card_2_iff
+  by (smt (verit, del_insts) antisym bot.extremum card.empty insert_commute insert_subsetI 
+      is_singletonI is_singleton_altdef linorder_le_cases not_one_le_zero one_le_numeral  subset_insert) 
+
+lemma inc_mat_of_index [simp]: "i < dim_row (inc_mat_of Vs Bs) \<Longrightarrow> j < dim_col (inc_mat_of Vs Bs) \<Longrightarrow> 
+  inc_mat_of Vs Bs $$ (i, j) = (if (Vs ! i) \<in> (Bs ! j) then 1 else 0)"
+  by (simp add: inc_mat_of_def)
+
+lemma inc_mat_dim_row: "dim_row (inc_mat_of Vs Bs) = length Vs"
+  by (simp add: inc_mat_of_def)
+
+lemma inc_mat_dim_vec_row: "dim_vec (row (inc_mat_of Vs Bs) i) = length Bs"
+  by (simp add:  inc_mat_of_def)
+
+lemma inc_mat_dim_col: "dim_col (inc_mat_of Vs Bs) = length Bs"
+  by (simp add:  inc_mat_of_def)
+
+lemma inc_mat_dim_vec_col: "dim_vec (col (inc_mat_of Vs Bs) i) = length Vs"
+  by (simp add:  inc_mat_of_def)
+
+lemma inc_matrix_point_in_block_one: "i < length Vs \<Longrightarrow> j < length Bs \<Longrightarrow> Vs ! i \<in> Bs ! j
+    \<Longrightarrow> (inc_mat_of Vs Bs) $$ (i, j) = 1"
+  by (simp add: inc_mat_of_def)   
+
+lemma inc_matrix_point_not_in_block_zero: "i < length Vs \<Longrightarrow> j < length Bs \<Longrightarrow> Vs ! i \<notin> Bs ! j \<Longrightarrow> 
+    (inc_mat_of Vs Bs) $$ (i, j) = 0"
+  by(simp add: inc_mat_of_def)
+
+lemma inc_matrix_point_in_block: "i < length Vs \<Longrightarrow> j < length Bs \<Longrightarrow> (inc_mat_of Vs Bs) $$ (i, j) = 1 
+    \<Longrightarrow> Vs ! i \<in> Bs ! j"
+  using inc_matrix_point_not_in_block_zero by (metis zero_neq_one) 
+
+lemma inc_matrix_point_not_in_block:  "i < length Vs \<Longrightarrow> j < length Bs \<Longrightarrow> 
+    (inc_mat_of Vs Bs) $$ (i, j) = 0 \<Longrightarrow> Vs ! i \<notin> Bs ! j"
+  using inc_matrix_point_in_block_one by (metis zero_neq_one)
+
+lemma inc_matrix_point_not_in_block_iff:  "i < length Vs \<Longrightarrow> j < length Bs \<Longrightarrow> 
+    (inc_mat_of Vs Bs) $$ (i, j) = 0 \<longleftrightarrow> Vs ! i \<notin> Bs ! j"
+  using inc_matrix_point_not_in_block inc_matrix_point_not_in_block_zero by blast
+
+lemma inc_matrix_point_in_block_iff:  "i < length Vs \<Longrightarrow> j < length Bs \<Longrightarrow>
+    (inc_mat_of Vs Bs) $$ (i, j) = 1 \<longleftrightarrow> Vs ! i \<in> Bs ! j"
+  using inc_matrix_point_in_block inc_matrix_point_in_block_one by blast
+
+lemma inc_matrix_subset_implies_one: 
+  assumes "I \<subseteq> {..< length Vs}"
+  assumes "j < length Bs"
+  assumes "(!) Vs ` I \<subseteq> Bs ! j"
+  assumes "i \<in> I"
+  shows "(inc_mat_of Vs Bs) $$ (i, j) = 1"
+proof - 
+  have iin: "Vs ! i \<in> Bs ! j" using assms(3) assms(4) by auto
+  have "i < length Vs" using assms(1) assms(4) by auto
+  thus ?thesis using iin inc_matrix_point_in_block_iff assms(2) by blast  
+qed
+
+lemma inc_matrix_one_implies_membership: "I \<subseteq> {..< length Vs} \<Longrightarrow> j < length Bs \<Longrightarrow> 
+    (\<And> i. i\<in>I \<Longrightarrow> (inc_mat_of Vs Bs) $$ (i, j) = 1) \<Longrightarrow> i \<in> I \<Longrightarrow> Vs ! i \<in> Bs ! j"
+  using inc_matrix_point_in_block subset_iff by blast 
+
+lemma inc_matrix_elems_one_zero: "i < length Vs \<Longrightarrow> j < length Bs \<Longrightarrow> 
+    (inc_mat_of Vs Bs) $$ (i, j) = 0 \<or> (inc_mat_of Vs Bs) $$ (i, j) = 1"
+  using inc_matrix_point_in_block_one inc_matrix_point_not_in_block_zero by blast
+
+text \<open>Reasoning on Rows/Columns of the incidence matrix \<close>
+
+lemma inc_mat_col_def:  "j < length Bs \<Longrightarrow> i < length Vs \<Longrightarrow> 
+    (col (inc_mat_of Vs Bs) j) $ i = (if (Vs ! i \<in> Bs ! j) then 1 else 0)"
+  by (simp add: inc_mat_of_def) 
+
+lemma inc_mat_col_list_map_elem: "j < length Bs \<Longrightarrow> i < length Vs \<Longrightarrow> 
+    col (inc_mat_of Vs Bs) j $ i = map_vec (\<lambda> x . if (x \<in> (Bs ! j)) then 1 else 0) (vec_of_list Vs) $ i"
+  by (simp add: inc_mat_of_def index_vec_of_list)
+
+lemma inc_mat_col_list_map:  "j < length Bs \<Longrightarrow> 
+    col (inc_mat_of Vs Bs) j = map_vec (\<lambda> x . if (x \<in> (Bs ! j)) then 1 else 0) (vec_of_list Vs)"
+  by (intro eq_vecI) 
+    (simp_all add: inc_mat_dim_row inc_mat_dim_col inc_mat_col_list_map_elem index_vec_of_list)
+
+lemma inc_mat_row_def: "j < length Bs \<Longrightarrow> i < length Vs \<Longrightarrow> 
+    (row (inc_mat_of Vs Bs) i) $ j = (if (Vs ! i \<in> Bs ! j) then 1 else 0)"
+  by (simp add: inc_mat_of_def)
+
+lemma inc_mat_row_list_map_elem: "j < length Bs \<Longrightarrow> i < length Vs \<Longrightarrow> 
+    row (inc_mat_of Vs Bs) i $ j = map_vec (\<lambda> bl . if ((Vs ! i) \<in> bl) then 1 else 0) (vec_of_list Bs) $ j"
+  by (simp add: inc_mat_of_def vec_of_list_index)
+
+lemma inc_mat_row_list_map: "i < length Vs \<Longrightarrow> 
+    row (inc_mat_of Vs Bs) i = map_vec (\<lambda> bl . if ((Vs ! i) \<in> bl) then 1 else 0) (vec_of_list Bs)"
+  by (intro eq_vecI) 
+    (simp_all add: inc_mat_dim_row inc_mat_dim_col inc_mat_row_list_map_elem index_vec_of_list)
+
+text \<open> Connecting @{term "inc_vec_of"} and @{term "inc_mat_of"} \<close>
+
+lemma inc_mat_col_inc_vec: "j < length Bs \<Longrightarrow> col (inc_mat_of Vs Bs) j = inc_vec_of Vs (Bs ! j)"
+  by (auto simp add: inc_mat_of_def inc_vec_of_def)
+
+lemma inc_mat_of_cols_inc_vecs: "cols (inc_mat_of Vs Bs) = map (\<lambda> j . inc_vec_of Vs j) Bs"
+proof (intro nth_equalityI)
+  have l1: "length (cols (inc_mat_of Vs Bs)) = length Bs"
+    using inc_mat_dim_col by simp
+  have l2: "length (map (\<lambda> j . inc_vec_of Vs j) Bs) = length Bs"
+    using length_map by simp
+  then show "length (cols (inc_mat_of Vs Bs)) = length (map (inc_vec_of Vs) Bs)" 
+    using l1 l2 by simp
+  show "\<And> i. i < length (cols (inc_mat_of Vs Bs)) \<Longrightarrow> 
+    (cols (inc_mat_of Vs Bs) ! i) = (map (\<lambda> j . inc_vec_of Vs j) Bs) ! i"
+    using inc_mat_col_inc_vec l1 by (metis cols_nth inc_mat_dim_col nth_map) 
+qed
+
+lemma inc_mat_of_bij_betw: 
+  assumes "inj_on f (set Vs)"
+  assumes "\<And> bl . bl \<in> (set Bs) \<Longrightarrow> bl \<subseteq> (set Vs)"
+  shows "inc_mat_of Vs Bs = inc_mat_of (map f Vs) (map ((`) f) Bs)"
+proof (intro eq_matI, simp_all add: inc_mat_dim_row inc_mat_dim_col, intro impI)
+  fix i j assume ilt: "i < length Vs" and jlt: " j < length Bs" and "Vs ! i \<notin> Bs ! j"
+  then show "f (Vs ! i) \<notin> f ` Bs ! j"
+    by (meson assms(1) assms(2) ilt inj_on_image_mem_iff jlt nth_mem) 
+qed
+
+text \<open>Definitions for the incidence matrix representation of common incidence system properties \<close>
+
+definition non_empty_col :: "('a :: {zero_neq_one}) mat \<Rightarrow> nat \<Rightarrow> bool" where
+"non_empty_col M j \<equiv> \<exists> k. k \<noteq> 0 \<and> k \<in>$ col M j"
+
+definition proper_inc_mat :: "('a :: {zero_neq_one}) mat \<Rightarrow> bool" where
+"proper_inc_mat M \<equiv> (dim_row M > 0 \<and> dim_col M > 0)"
+
+text \<open>Matrix version of the representation number property @{term "point_replication_number"}\<close>
+definition mat_rep_num :: "('a :: {zero_neq_one}) mat \<Rightarrow> nat \<Rightarrow> nat" where
+"mat_rep_num M i \<equiv> count_vec (row M i) 1"
+
+text \<open>Matrix version of the points index property @{term "points_index"}\<close>
+definition mat_point_index :: "('a :: {zero_neq_one}) mat \<Rightarrow> nat set \<Rightarrow> nat" where
+"mat_point_index M I \<equiv> card {j . j < dim_col M \<and> (\<forall> i \<in> I. M $$ (i, j) = 1)}"
+
+definition mat_inter_num :: "('a :: {zero_neq_one}) mat \<Rightarrow> nat \<Rightarrow> nat \<Rightarrow> nat" where
+"mat_inter_num M j1 j2 \<equiv> card {i . i < dim_row M \<and> M $$ (i, j1) = 1 \<and>  M $$ (i, j2) = 1}"
+
+text \<open>Matrix version of the block size property\<close>
+definition mat_block_size :: "('a :: {zero_neq_one}) mat \<Rightarrow> nat \<Rightarrow> nat" where
+"mat_block_size M j \<equiv> count_vec (col M j) 1"
+
+lemma non_empty_col_obtains: 
+  assumes "non_empty_col M j"
+  obtains i where "i < dim_row M" and "(col M j) $ i \<noteq> 0"
+proof -
+  have d: "dim_vec (col M j) = dim_row M" by simp
+  from assms obtain k where "k \<noteq> 0" and "k \<in>$ col M j" 
+    by (auto simp add: non_empty_col_def)
+  thus ?thesis using vec_contains_obtains_index d
+    by (metis that) 
+qed
+
+lemma non_empty_col_alt_def: 
+  assumes "j < dim_col M" 
+  shows "non_empty_col M j \<longleftrightarrow> (\<exists> i. i < dim_row M \<and> M $$ (i, j) \<noteq> 0)"
+proof (intro iffI)
+  show "non_empty_col M j \<Longrightarrow> \<exists>i<dim_row M. M $$ (i, j) \<noteq> 0"
+    by(metis assms index_col non_empty_col_obtains)
+next 
+  assume "\<exists>i<dim_row M. M $$ (i, j) \<noteq> 0"
+  then obtain i where ilt: " i < dim_row M" and ne: "M $$ (i, j) \<noteq> 0" by blast
+  then have ilt2: " i < dim_vec (col M j)" by simp
+  then have "(col M j) $ i \<noteq> 0" using ne by (simp add: assms) 
+  then obtain k where "(col M j) $ i = k" and "k \<noteq> 0"
+    by simp
+  then show "non_empty_col M j " using non_empty_col_def
+    by (metis ilt2 vec_setI) 
+qed
+
+lemma proper_inc_mat_map: "proper_inc_mat M \<Longrightarrow> proper_inc_mat (map_mat f M)"
+  by (simp add: proper_inc_mat_def)
+
+lemma mat_point_index_alt: "mat_point_index M I = card {j \<in> {0..<dim_col M} . (\<forall> i \<in> I . M $$(i, j) = 1)}"
+  by (simp add: mat_point_index_def)
+
+lemma mat_block_size_sum_alt: 
+  fixes M :: "'a :: {ring_1} mat"
+  shows "elements_mat M \<subseteq> {0, 1} \<Longrightarrow> j < dim_col M \<Longrightarrow> of_nat (mat_block_size M j) = sum_vec (col M j)"
+  unfolding mat_block_size_def using count_vec_sum_ones_alt col_elems_subset_mat subset_trans
+  by metis  
+
+lemma mat_rep_num_sum_alt: 
+  fixes M :: "'a :: {ring_1} mat"
+  shows "elements_mat M \<subseteq> {0, 1} \<Longrightarrow> i < dim_row M \<Longrightarrow> of_nat (mat_rep_num M i) = sum_vec (row M i)"
+  using count_vec_sum_ones_alt
+  by (metis mat_rep_num_def row_elems_subset_mat subset_trans) 
+
+lemma mat_point_index_two_alt: 
+  assumes "i1 < dim_row M"
+  assumes "i2 < dim_row M"
+  shows "mat_point_index M {i1, i2} = card {j . j < dim_col M \<and> M $$(i1, j) = 1 \<and> M $$ (i2, j) = 1}"
+proof -
+  let ?I = "{i1, i2}"
+  have ss: "{i1, i2} \<subseteq> {..<dim_row M}" using assms by blast
+  have filter: "\<And> j . j < dim_col M \<Longrightarrow> (\<forall> i \<in> ?I . M $$(i, j) = 1) \<longleftrightarrow> M $$(i1, j) = 1 \<and> M $$ (i2, j) = 1"
+    by auto
+  have "?I \<subseteq> {..< dim_row M}" using assms(1) assms(2) by fastforce
+  thus ?thesis using filter ss unfolding mat_point_index_def
+    by meson 
+qed
+
+text \<open> Transpose symmetries \<close>
+
+lemma trans_mat_rep_block_size_sym: "j < dim_col M \<Longrightarrow> mat_block_size M j = mat_rep_num M\<^sup>T j"
+  "i < dim_row M \<Longrightarrow> mat_rep_num M i = mat_block_size M\<^sup>T i"
+  unfolding mat_block_size_def mat_rep_num_def by simp_all
+
+lemma trans_mat_point_index_inter_sym: 
+  "i1 < dim_row M \<Longrightarrow> i2 < dim_row M \<Longrightarrow> mat_point_index M {i1, i2} = mat_inter_num M\<^sup>T i1 i2"
+  "j1 < dim_col M \<Longrightarrow> j2 < dim_col M \<Longrightarrow> mat_inter_num M j1 j2 = mat_point_index M\<^sup>T {j1, j2}"
+   apply (simp_all add: mat_inter_num_def mat_point_index_two_alt)
+   apply (metis (no_types, lifting) index_transpose_mat(1))
+  by (metis (no_types, lifting) index_transpose_mat(1))
+
+subsection \<open>0-1 Matrices \<close>
+text \<open>Incidence matrices contain only two elements: 0 and 1. We define a locale which provides
+a context to work in for matrices satisfying this condition for any @{typ "'b :: zero_neq_one"} type.\<close>
+locale zero_one_matrix = 
+  fixes matrix :: "'b :: {zero_neq_one} mat" ("M")
+  assumes elems01: "elements_mat M \<subseteq> {0, 1}"
+begin
+
+text \<open> Row and Column Properties of the Matrix \<close>
+
+lemma row_elems_ss01:"i < dim_row M \<Longrightarrow> vec_set (row M i) \<subseteq> {0, 1}"
+  using row_elems_subset_mat elems01 by blast
+
+lemma col_elems_ss01: 
+  assumes "j < dim_col M"
+  shows "vec_set (col M j) \<subseteq> {0, 1}"
+proof -
+  have "vec_set (col M j) \<subseteq> elements_mat M" using assms 
+    by (simp add: col_elems_subset_mat assms) 
+  thus ?thesis using elems01 by blast
+qed
+
+lemma col_nth_0_or_1_iff: 
+  assumes "j < dim_col M"
+  assumes "i < dim_row M"
+  shows "col M j $ i = 0 \<longleftrightarrow> col M j $ i \<noteq> 1"
+proof (intro iffI)
+  have dv: "i < dim_vec (col M j)" using assms by simp
+  have sv: "set\<^sub>v (col M j) \<subseteq> {0, 1}" using col_elems_ss01 assms by simp
+  then show "col M j $ i = 0 \<Longrightarrow> col M j $ i \<noteq> 1" using dv by simp
+  show "col M j $ i \<noteq> 1 \<Longrightarrow> col M j $ i = 0" using dv sv
+    by (meson insertE singletonD subset_eq vec_setI) 
+qed
+
+lemma row_nth_0_or_1_iff: 
+  assumes "j < dim_col M"
+  assumes "i < dim_row M"
+  shows "row M i $ j = 0 \<longleftrightarrow> row M i $ j \<noteq> 1"
+proof (intro iffI)
+  have dv: "j < dim_vec (row M i)" using assms by simp
+  have sv: "set\<^sub>v (row M i) \<subseteq> {0, 1}" using row_elems_ss01 assms by simp
+  then show "row M i $ j = 0 \<Longrightarrow> row M i $ j \<noteq> 1" by simp
+  show "row M i $ j \<noteq> 1 \<Longrightarrow> row M i $ j = 0" using dv sv
+    by (meson insertE singletonD subset_eq vec_setI) 
+qed
+
+lemma transpose_entries: "elements_mat (M\<^sup>T) \<subseteq> {0, 1}"
+  using elems01 transpose_mat_elems by metis 
+
+lemma M_not_zero_simp: "j < dim_col M \<Longrightarrow> i < dim_row M \<Longrightarrow> M $$ (i, j) \<noteq> 0 \<Longrightarrow> M $$ (i, j) = 1"
+  using elems01 by auto
+
+lemma M_not_one_simp: "j < dim_col M \<Longrightarrow> i < dim_row M \<Longrightarrow> M $$ (i, j) \<noteq> 1 \<Longrightarrow> M $$ (i, j) = 0"
+  using elems01 by auto
+
+text \<open>Definition for mapping a column to a block \<close>
+definition map_col_to_block :: "'a :: {zero_neq_one} vec  \<Rightarrow> nat set" where
+"map_col_to_block c \<equiv> { i \<in> {..<dim_vec c} . c $ i = 1}"
+
+lemma map_col_to_block_alt: "map_col_to_block c = {i . i < dim_vec c \<and> c$ i = 1}"
+  by (simp add: map_col_to_block_def)
+
+lemma map_col_to_block_elem: "i < dim_vec c \<Longrightarrow> i \<in> map_col_to_block c \<longleftrightarrow>  c $ i = 1"
+  by (simp add: map_col_to_block_alt)
+
+lemma in_map_col_valid_index: "i \<in> map_col_to_block c \<Longrightarrow> i < dim_vec c"
+  by (simp add: map_col_to_block_alt)
+
+lemma map_col_to_block_size: "j < dim_col M \<Longrightarrow> card (map_col_to_block (col M j)) = mat_block_size M j"
+  unfolding mat_block_size_def map_col_to_block_alt using count_vec_alt[of "col M j" "1"] Collect_cong
+  by (metis (no_types, lifting))
+
+lemma in_map_col_valid_index_M: "j < dim_col M \<Longrightarrow> i \<in> map_col_to_block (col M j) \<Longrightarrow> i < dim_row M"
+  using in_map_col_valid_index by (metis dim_col) 
+
+lemma map_col_to_block_elem_not: "c \<in> set (cols M) \<Longrightarrow> i < dim_vec c \<Longrightarrow> i \<notin> map_col_to_block c \<longleftrightarrow> c $ i = 0"
+  apply (auto simp add: map_col_to_block_alt)
+  using elems01 by (metis col_nth_0_or_1_iff dim_col obtain_col_index) 
+
+lemma obtain_block_index_map_block_set: 
+  assumes "bl \<in># {# map_col_to_block c . c \<in># mset (cols M)#}"
+  obtains j where "j < dim_col M" and "bl = map_col_to_block (col M j)"
+proof -
+  obtain c where bleq: "bl = map_col_to_block c" and "c \<in># mset (cols M)"
+    using assms by blast
+  then have "c \<in> set (cols M)" by simp
+  thus ?thesis using bleq obtain_col_index
+    by (metis that)
+qed
+
+lemma mat_ord_inc_sys_point[simp]: "x < dim_row M \<Longrightarrow> [0..<(dim_row M)] ! x = x"
+  by simp
+
+lemma mat_ord_inc_sys_block[simp]: "j < dim_col M \<Longrightarrow> 
+  (map (map_col_to_block) (cols M)) ! j = map_col_to_block (col M j)"
+  by auto
+
+lemma ordered_to_mset_col_blocks:
+  "{# map_col_to_block c . c \<in># mset (cols M)#} = mset (map (map_col_to_block) (cols M))"
+  by simp
+
+text \<open> Lemmas on incidence matrix properties \<close>
+lemma non_empty_col_01: 
+  assumes "j < dim_col M"
+  shows "non_empty_col M j \<longleftrightarrow> 1 \<in>$ col M j"
+proof (intro iffI)
+  assume "non_empty_col M j"
+  then obtain k where kn0: "k \<noteq> 0" and kin: "k \<in>$ col M j" using non_empty_col_def
+    by blast
+  then have "k \<in> elements_mat M" using vec_contains_col_elements_mat assms
+    by metis 
+  then have "k = 1" using kn0
+    using elems01 by blast 
+  thus "1 \<in>$ col M j" using kin by simp
+next
+  assume "1 \<in>$ col M j"
+  then show "non_empty_col M j" using non_empty_col_def
+    by (metis zero_neq_one)
+qed
+
+lemma mat_rep_num_alt: 
+  assumes "i < dim_row M"
+  shows "mat_rep_num M i = card {j . j < dim_col M \<and> M $$ (i, j) = 1}"
+proof (simp add: mat_rep_num_def)
+  have eq: "\<And> j. (j < dim_col M \<and> M $$ (i, j) = 1) = (row M i $ j = 1 \<and> j < dim_vec (row M i))" 
+    using assms by auto
+  have "count_vec (row M i) 1 = card {j. (row M i) $ j = 1 \<and>  j < dim_vec (row M i)}"
+    using count_vec_alt[of "row M i" "1"] by simp
+  thus "count_vec (row M i) 1 = card {j. j < dim_col M \<and> M $$ (i, j) = 1}"
+    using eq Collect_cong by simp
+qed
+
+lemma mat_rep_num_alt_col: "i < dim_row M \<Longrightarrow> mat_rep_num M i = size {#c \<in># (mset (cols M)) . c $ i = 1#}"
+  using mat_rep_num_alt index_to_col_card_size_prop[of i M] by auto
+
+text \<open> A zero one matrix is an incidence system \<close>
+
+lemma map_col_to_block_wf: "\<And>c. c \<in> set (cols M) \<Longrightarrow> map_col_to_block c \<subseteq> {0..<dim_row M}"
+  by (auto simp add: map_col_to_block_def)(metis dim_col obtain_col_index)
+
+lemma one_implies_block_nempty: "j < dim_col M \<Longrightarrow> 1 \<in>$ (col M j) \<Longrightarrow> map_col_to_block (col M j) \<noteq> {}"
+  unfolding map_col_to_block_def using vec_setE by force 
+
+interpretation incidence_sys: incidence_system "{0..<dim_row M}" 
+    "{# map_col_to_block c . c \<in># mset (cols M)#}"
+  using map_col_to_block_wf by (unfold_locales) auto 
+
+interpretation fin_incidence_sys: finite_incidence_system "{0..<dim_row M}" 
+    "{# map_col_to_block c . c \<in># mset (cols M)#}"
+  by (unfold_locales) (simp)
+
+lemma block_nempty_implies_all_zeros: "j < dim_col M \<Longrightarrow> map_col_to_block (col M j) = {} \<Longrightarrow> 
+    i < dim_row M \<Longrightarrow> col M j $ i = 0"
+  by (metis col_nth_0_or_1_iff dim_col one_implies_block_nempty vec_setI)
+
+lemma block_nempty_implies_no_one: "j < dim_col M \<Longrightarrow> map_col_to_block (col M j) = {} \<Longrightarrow> \<not> (1 \<in>$ (col M j))"
+  using one_implies_block_nempty by blast
+
+lemma mat_is_design:
+  assumes "\<And>j. j < dim_col M\<Longrightarrow> 1 \<in>$ (col M j)"
+  shows "design {0..<dim_row M} {# map_col_to_block c . c \<in># mset (cols M)#}"
+proof (unfold_locales)
+  fix bl 
+  assume "bl \<in># {# map_col_to_block c . c \<in># mset (cols M)#}"
+  then obtain j where "j < dim_col M" and map: "bl = map_col_to_block (col M j)"
+    using obtain_block_index_map_block_set by auto
+  thus "bl \<noteq> {}" using assms one_implies_block_nempty
+    by simp 
+qed
+
+lemma mat_is_proper_design: 
+  assumes "\<And>j. j < dim_col M \<Longrightarrow> 1 \<in>$ (col M j)"
+  assumes "dim_col M > 0"
+  shows "proper_design {0..<dim_row M} {# map_col_to_block c . c \<in># mset (cols M)#}"
+proof -
+  interpret des: design "{0..<dim_row M}" "{# map_col_to_block c . c \<in># mset (cols M)#}"
+    using mat_is_design assms by simp
+  show ?thesis proof (unfold_locales)
+    have "length (cols M) \<noteq> 0" using assms(2) by auto
+    then have "size {# map_col_to_block c . c \<in># mset (cols M)#} \<noteq> 0" by auto
+    then show "incidence_sys.\<b> \<noteq> 0" by simp
+  qed
+qed
+
+text \<open> Show the 01 injective function preserves system properties \<close>
+
+lemma inj_on_01_hom_index:
+  assumes "inj_on_01_hom f"
+  assumes "i < dim_row M" "j < dim_col M"
+  shows "M $$ (i, j) = 1  \<longleftrightarrow> (map_mat f M) $$ (i, j) = 1"
+    and "M $$ (i, j) = 0  \<longleftrightarrow> (map_mat f M) $$ (i, j) = 0"
+proof -
+  interpret hom: inj_on_01_hom f using assms by simp
+  show "M $$ (i, j) = 1  \<longleftrightarrow> (map_mat f M) $$ (i, j) = 1" 
+    using assms col_nth_0_or_1_iff
+    by (simp add: hom.inj_1_iff) 
+  show "M $$ (i, j) = 0  \<longleftrightarrow> (map_mat f M) $$ (i, j) = 0"
+    using assms col_nth_0_or_1_iff
+    by (simp add: hom.inj_0_iff) 
+qed
+
+lemma preserve_non_empty: 
+  assumes "inj_on_01_hom f" 
+  assumes "j < dim_col M"
+  shows "non_empty_col M j \<longleftrightarrow> non_empty_col (map_mat f M) j"
+proof(simp add: non_empty_col_def, intro iffI) 
+  interpret hom: inj_on_01_hom f using assms(1) by simp
+  assume "\<exists>k. k \<noteq> 0 \<and> k \<in>$ col M j"
+  then obtain k where kneq: "k \<noteq> 0" and kin: "k \<in>$ col M j" by blast
+  then have "f k \<in>$ col (map_mat f M) j" using vec_contains_img
+    by (metis assms(2) col_map_mat) 
+  then have "f k \<noteq> 0" using assms(1) kneq kin assms(2) col_elems_ss01 hom.inj_0_iff by blast
+  thus "\<exists>k. k \<noteq> 0 \<and> k \<in>$ col (map_mat f M) j"
+    using \<open>f k \<in>$ col (map_mat f M) j\<close> by blast
+next
+  interpret hom: inj_on_01_hom f using assms(1) by simp
+  assume "\<exists>k. k \<noteq> 0 \<and> k \<in>$ col (map_mat f M) j"
+  then obtain k where kneq: "k \<noteq> 0" and kin: "k \<in>$ col (map_mat f M) j" by blast
+  then have "k \<in>$ map_vec f (col M j)" using assms(2) col_map_mat by simp
+  then have "k \<in> f ` set\<^sub>v (col M j)"
+    by (smt (verit) image_eqI index_map_vec(1) index_map_vec(2) vec_setE vec_setI) 
+  then obtain k' where keq: "k = f k'" and kin2: "k' \<in> set\<^sub>v (col M j)"
+    by blast 
+  then have "k' \<noteq> 0" using assms(1) kneq hom.inj_0_iff by blast 
+  thus  "\<exists>k. k \<noteq> 0 \<and> k \<in>$ col M j" using kin2 by auto
+qed
+
+lemma preserve_mat_rep_num:
+  assumes "inj_on_01_hom f"
+  assumes "i < dim_row M"
+  shows "mat_rep_num M i = mat_rep_num (map_mat f M) i"
+  unfolding mat_rep_num_def using injective_lim.lim_inj_hom_count_vec inj_on_01_hom_def row_map_mat
+  by (metis assms(1) assms(2) inj_on_01_hom.inj_1_iff insert_iff row_elems_ss01)
+
+lemma preserve_mat_block_size: 
+  assumes "inj_on_01_hom f"
+  assumes "j < dim_col M"
+  shows "mat_block_size M j = mat_block_size (map_mat f M) j"
+  unfolding mat_block_size_def using injective_lim.lim_inj_hom_count_vec inj_on_01_hom_def col_map_mat
+  by (metis assms(1) assms(2) inj_on_01_hom.inj_1_iff insert_iff col_elems_ss01)
+
+
+lemma preserve_mat_point_index: 
+  assumes "inj_on_01_hom f"
+  assumes "\<And> i. i \<in> I \<Longrightarrow> i < dim_row M"
+  shows "mat_point_index M I = mat_point_index (map_mat f M) I"
+proof -
+  have "\<And> i j. i \<in> I \<Longrightarrow> j < dim_col M \<and> M $$ (i, j) = 1 \<longleftrightarrow> 
+      j < dim_col (map_mat f M) \<and> (map_mat f M) $$ (i, j) = 1"
+    using assms(2) inj_on_01_hom_index(1) assms(1) by (metis index_map_mat(3)) 
+  thus ?thesis unfolding mat_point_index_def
+    by (metis (no_types, opaque_lifting) index_map_mat(3)) 
+qed
+
+lemma preserve_mat_inter_num: 
+  assumes "inj_on_01_hom f"
+  assumes "j1 < dim_col M" "j2 < dim_col M"
+  shows "mat_inter_num M j1 j2 = mat_inter_num (map_mat f M) j1 j2"
+  unfolding mat_inter_num_def using assms
+  by (metis (no_types, opaque_lifting) index_map_mat(2) inj_on_01_hom_index(1)) 
+
+lemma lift_mat_01_index_iff: 
+  "i < dim_row M \<Longrightarrow> j < dim_col M \<Longrightarrow> (lift_01_mat M) $$ (i, j) = 0 \<longleftrightarrow> M $$ (i, j) = 0"
+  "i < dim_row M \<Longrightarrow> j < dim_col M \<Longrightarrow> (lift_01_mat M) $$ (i, j) = 1 \<longleftrightarrow> M $$ (i, j) = 1"
+  by (simp) (metis col_nth_0_or_1_iff index_col lift_01_mat_simp(3) of_zero_neq_one_def zero_neq_one) 
+
+lemma lift_mat_elems: "elements_mat (lift_01_mat M) \<subseteq> {0, 1}"
+proof -
+  have "elements_mat (lift_01_mat M) = of_zero_neq_one ` (elements_mat M)"
+    by (simp add: lift_01_mat_def map_mat_elements)
+  then have "elements_mat (lift_01_mat M) \<subseteq> of_zero_neq_one ` {0, 1}" using elems01
+    by fastforce 
+  thus ?thesis
+    by simp 
+qed
+
+lemma lift_mat_is_0_1: "zero_one_matrix (lift_01_mat M)"
+  using lift_mat_elems by (unfold_locales)
+
+lemma lift_01_mat_distinct_cols: "distinct (cols M) \<Longrightarrow> distinct (cols (lift_01_mat M))"
+  using of_injective_lim.mat_cols_hom_lim_distinct_iff lift_01_mat_def
+  by (metis elems01 map_vec_mat_cols) 
+
+end
+
+text \<open>Some properties must be further restricted to matrices having a @{typ "'a :: ring_1"} type \<close>
+locale zero_one_matrix_ring_1 = zero_one_matrix M for M :: "'b :: {ring_1} mat"
+begin
+
+lemma map_col_block_eq: 
+  assumes "c \<in> set(cols M)"
+  shows "inc_vec_of [0..<dim_vec c] (map_col_to_block c) = c"
+proof (intro eq_vecI, simp add: map_col_to_block_def inc_vec_of_def, intro impI)
+  show "\<And>i. i < dim_vec c \<Longrightarrow> c $ i \<noteq> 1 \<Longrightarrow> c $ i = 0"
+    using assms map_col_to_block_elem map_col_to_block_elem_not by auto 
+  show "dim_vec (inc_vec_of [0..<dim_vec c] (map_col_to_block c)) = dim_vec c"
+    unfolding inc_vec_of_def by simp 
+qed
+
+lemma inc_mat_of_map_rev: "inc_mat_of [0..<dim_row M] (map map_col_to_block (cols M)) = M"
+proof (intro eq_matI, simp_all add: inc_mat_of_def, intro conjI impI)
+  show "\<And>i j. i < dim_row M \<Longrightarrow> j < dim_col M \<Longrightarrow> i \<in> map_col_to_block (col M j) \<Longrightarrow> M $$ (i, j) = 1"
+    by (simp add: map_col_to_block_elem)
+  show "\<And>i j. i < dim_row M \<Longrightarrow> j < dim_col M \<Longrightarrow> i \<notin> map_col_to_block (col M j) \<Longrightarrow> M $$ (i, j) = 0"
+    by (metis col_nth_0_or_1_iff dim_col index_col map_col_to_block_elem)
+qed
+
+lemma M_index_square_itself: "j < dim_col M \<Longrightarrow> i < dim_row M \<Longrightarrow> (M $$ (i, j))^2 = M $$ (i, j)"
+  using M_not_zero_simp by (cases "M $$ (i, j) = 0")(simp_all, metis power_one) 
+
+lemma M_col_index_square_itself: "j < dim_col M \<Longrightarrow> i < dim_row M \<Longrightarrow> ((col M j) $ i)^2 = (col M j) $ i"
+  using index_col M_index_square_itself by auto 
+
+
+text \<open> Scalar Prod Alternative definitions for matrix properties \<close>
+
+lemma scalar_prod_inc_vec_block_size_mat:
+  assumes "j < dim_col M"
+  shows "(col M j) \<bullet> (col M j) = of_nat (mat_block_size M j)"
+proof -
+  have "(col M j) \<bullet> (col M j) = (\<Sum> i \<in> {0..<dim_row M} . (col M j) $ i * (col M j) $ i)" 
+     using assms  scalar_prod_def sum.cong by (smt (verit, ccfv_threshold) dim_col) 
+  also have "... = (\<Sum> i \<in> {0..<dim_row M} . ((col M j) $ i)^2)"
+    by (simp add: power2_eq_square ) 
+  also have "... = (\<Sum> i \<in> {0..<dim_row M} . ((col M j) $ i))"
+    using M_col_index_square_itself assms by auto
+  finally show ?thesis using sum_vec_def mat_block_size_sum_alt
+    by (metis assms dim_col elems01) 
+qed
+
+lemma scalar_prod_inc_vec_mat_inter_num: 
+  assumes "j1 < dim_col M" "j2 < dim_col M"
+  shows "(col M j1) \<bullet> (col M j2) = of_nat (mat_inter_num M j1 j2)"
+proof -
+  have split: "{0..<dim_row M} = {i \<in> {0..<dim_row M} . (M $$ (i, j1) = 1) \<and> (M $$ (i, j2) = 1) } \<union> 
+    {i \<in> {0..<dim_row M} . M $$ (i, j1) = 0 \<or> M $$ (i, j2) = 0}" using assms M_not_zero_simp by auto
+  have inter: "{i \<in> {0..<dim_row M} . (M $$ (i, j1) = 1) \<and> (M $$ (i, j2) = 1) } \<inter> 
+    {i \<in> {0..<dim_row M} . M $$ (i, j1) = 0 \<or> M $$ (i, j2) = 0} = {}" by auto
+  have "(col M j1) \<bullet> (col M j2) = (\<Sum> i \<in> {0..<dim_row M} . (col M j1) $ i * (col M j2) $ i)" 
+    using assms scalar_prod_def by (metis (full_types) dim_col) 
+  also have "... = (\<Sum> i \<in> {0..<dim_row M} . M $$ (i, j1) * M $$ (i, j2))" 
+    using assms by simp
+  also have "... = (\<Sum> i \<in> {i \<in> {0..<dim_row M} . (M $$ (i, j1) = 1) \<and> (M $$ (i, j2) = 1) } . M $$ (i, j1) * M $$ (i, j2)) 
+      + (\<Sum> i \<in> {i \<in> {0..<dim_row M} . M $$ (i, j1) = 0 \<or> M $$ (i, j2) = 0} . M $$ (i, j1) * M $$ (i, j2))" 
+    using split inter sum.union_disjoint[of " {i \<in> {0..<dim_row M} . (M $$ (i, j1) = 1) \<and> (M $$ (i, j2) = 1)}" 
+      "{i \<in> {0..<dim_row M} . M $$ (i, j1) = 0 \<or> M $$ (i, j2) = 0}" "\<lambda> i . M $$ (i, j1) * M $$ (i, j2)"]
+    by (metis (no_types, lifting) finite_Un finite_atLeastLessThan) 
+  also have "... = (\<Sum> i \<in> {i \<in> {0..<dim_row M} . (M $$ (i, j1) = 1) \<and> (M $$ (i, j2) = 1) } . 1) 
+      + (\<Sum> i \<in> {i \<in> {0..<dim_row M} . M $$ (i, j1) = 0 \<or> M $$ (i, j2) = 0} . 0)" 
+    using sum.cong mem_Collect_eq by (smt (z3) mult.right_neutral mult_not_zero) 
+  finally have "(col M j1) \<bullet> (col M j2) = 
+      of_nat (card {i . i < dim_row M \<and> (M $$ (i, j1) = 1) \<and> (M $$ (i, j2) = 1)})"
+    by simp 
+  then show ?thesis using mat_inter_num_def[of M j1 j2] by simp
+qed
+
+end
+
+text \<open> Any matrix generated by @{term "inc_mat_of"} is a 0-1 matrix.\<close>
+lemma inc_mat_of_01_mat: "zero_one_matrix_ring_1 (inc_mat_of Vs Bs)"
+  by (unfold_locales) (simp add: inc_mat_one_zero_elems) 
+
+subsection \<open>Ordered Incidence Systems \<close>
+text \<open>We impose an arbitrary ordering on the point set and block collection to enable
+matrix reasoning. Note that this is also common in computer algebra representations of designs \<close>
+
+locale ordered_incidence_system =
+  fixes \<V>s :: "'a list" and \<B>s :: "'a set list"
+  assumes wf_list: "b \<in># (mset \<B>s) \<Longrightarrow> b \<subseteq> set \<V>s"
+  assumes distinct: "distinct \<V>s"
+
+text \<open>An ordered incidence system, as it is defined on lists, can only represent finite incidence systems \<close>
+sublocale ordered_incidence_system \<subseteq> finite_incidence_system "set \<V>s" "mset \<B>s"
+  by(unfold_locales) (auto simp add: wf_list)
+
+lemma ordered_incidence_sysI: 
+  assumes "finite_incidence_system \<V> \<B>" 
+  assumes "\<V>s \<in> permutations_of_set \<V>" and "\<B>s \<in> permutations_of_multiset \<B>"
+  shows "ordered_incidence_system \<V>s \<B>s"
+proof -
+  have veq: "\<V> = set \<V>s" using assms permutations_of_setD(1) by auto 
+  have beq: "\<B> = mset \<B>s" using assms permutations_of_multisetD by auto
+  interpret fisys: finite_incidence_system "set \<V>s" "mset \<B>s" using assms(1) veq beq by simp
+  show ?thesis proof (unfold_locales)
+    show "\<And>b. b \<in># mset \<B>s \<Longrightarrow> b \<subseteq> set \<V>s" using fisys.wellformed
+      by simp 
+    show "distinct \<V>s" using assms permutations_of_setD(2) by auto
+  qed
+qed
+
+lemma ordered_incidence_sysII: 
+  assumes "finite_incidence_system \<V> \<B>" and "set \<V>s = \<V>" and "distinct \<V>s" and "mset \<B>s = \<B>"
+  shows "ordered_incidence_system \<V>s \<B>s"
+proof -
+  interpret fisys: finite_incidence_system "set \<V>s" "mset \<B>s" using assms by simp
+  show ?thesis using fisys.wellformed assms by (unfold_locales) (simp_all)
+qed
+
+context ordered_incidence_system 
+begin
+text \<open>For ease of notation, establish the same notation as for incidence systems \<close>
+
+abbreviation "\<V> \<equiv> set \<V>s"
+abbreviation "\<B> \<equiv> mset \<B>s"
+
+text \<open>Basic properties on ordered lists \<close>
+lemma points_indexing: "\<V>s \<in> permutations_of_set \<V>"
+  by (simp add: permutations_of_set_def distinct)
+
+lemma blocks_indexing: "\<B>s \<in> permutations_of_multiset \<B>"
+  by (simp add: permutations_of_multiset_def)
+
+lemma points_list_empty_iff: "\<V>s = [] \<longleftrightarrow> \<V> = {}"
+  using finite_sets points_indexing
+  by (simp add: elem_permutation_of_set_empty_iff) 
+
+lemma points_indexing_inj: "\<forall> i \<in> I . i < length \<V>s \<Longrightarrow> inj_on ((!) \<V>s) I"
+  by (simp add: distinct inj_on_nth)
+
+lemma blocks_list_empty_iff: "\<B>s = [] \<longleftrightarrow> \<B> = {#}"
+  using blocks_indexing by (simp) 
+
+lemma blocks_list_nempty: "proper_design \<V> \<B> \<Longrightarrow> \<B>s \<noteq> []"
+  using mset.simps(1) proper_design.design_blocks_nempty by blast
+
+lemma points_list_nempty: "proper_design \<V> \<B> \<Longrightarrow> \<V>s \<noteq> []"
+  using proper_design.design_points_nempty points_list_empty_iff by blast
+
+lemma points_list_length: "length \<V>s = \<v>"
+  using points_indexing
+  by (simp add: length_finite_permutations_of_set) 
+
+lemma blocks_list_length: "length \<B>s = \<b>"
+  using blocks_indexing length_finite_permutations_of_multiset by blast
+
+lemma valid_points_index: "i < \<v> \<Longrightarrow> \<V>s ! i \<in> \<V>"
+  using points_list_length by simp 
+
+lemma valid_points_index_cons: "x \<in> \<V> \<Longrightarrow> \<exists> i. \<V>s ! i = x \<and> i < \<v>"
+  using points_list_length by (auto simp add: in_set_conv_nth)
+
+lemma valid_points_index_obtains: 
+  assumes "x \<in> \<V>"
+  obtains i where "\<V>s ! i = x \<and> i < \<v>"
+  using valid_points_index_cons assms by auto
+
+lemma valid_blocks_index: "j < \<b> \<Longrightarrow> \<B>s ! j \<in># \<B>"
+  using blocks_list_length by (metis nth_mem_mset)
+
+lemma valid_blocks_index_cons: "bl \<in># \<B> \<Longrightarrow> \<exists> j . \<B>s ! j = bl \<and> j < \<b>"
+  by (auto simp add: in_set_conv_nth)
+
+lemma valid_blocks_index_obtains: 
+  assumes "bl \<in># \<B>"
+  obtains j where  "\<B>s ! j = bl \<and> j < \<b>"
+  using assms valid_blocks_index_cons by auto
+
+lemma block_points_valid_point_index: 
+  assumes "bl \<in># \<B>" "x \<in> bl"
+  obtains i where "i < length \<V>s \<and> \<V>s ! i = x"
+  using wellformed valid_points_index_obtains assms
+  by (metis points_list_length wf_invalid_point) 
+
+lemma points_set_index_img: "\<V> = image(\<lambda> i . (\<V>s ! i)) ({..<\<v>})"
+  using valid_points_index_cons valid_points_index by auto
+
+lemma blocks_mset_image: "\<B> = image_mset (\<lambda> i . (\<B>s ! i)) (mset_set {..<\<b>})"
+  by (simp add: mset_list_by_index)
+
+lemma incidence_cond_indexed[simp]: "i < \<v> \<Longrightarrow> j < \<b> \<Longrightarrow> incident (\<V>s ! i) (\<B>s ! j) \<longleftrightarrow> (\<V>s ! i) \<in> (\<B>s ! j)"
+  using incidence_alt_def valid_points_index valid_blocks_index by simp
+
+lemma bij_betw_points_index: "bij_betw (\<lambda> i. \<V>s ! i) {0..<\<v>} \<V>"
+proof (simp add: bij_betw_def, intro conjI)
+  show "inj_on ((!) \<V>s) {0..<\<v>}"
+    by (simp add: points_indexing_inj points_list_length) 
+  show "(!) \<V>s ` {0..<\<v>} = \<V>" 
+  proof (intro subset_antisym subsetI)
+    fix x assume "x \<in> (!) \<V>s ` {0..<\<v>}" 
+    then obtain i where "x = \<V>s ! i" and "i < \<v>" by auto
+    then show "x \<in> \<V>"
+      by (simp add: valid_points_index) 
+  next 
+    fix x assume "x \<in> \<V>"
+    then obtain i where "\<V>s ! i = x" and "i <\<v>"
+      using valid_points_index_cons by auto 
+    then show "x \<in> (!) \<V>s ` {0..<\<v>}" by auto
+  qed
+qed
+
+text \<open>Some lemmas on cardinality due to different set descriptor filters \<close>
+lemma card_filter_point_indices: "card {i \<in> {0..<\<v>}. P (\<V>s ! i)} = card {v \<in> \<V> . P v }"
+proof -
+  have "{v \<in> \<V> . P v }= (\<lambda> i. \<V>s ! i) ` {i \<in> {0..<\<v>}. P (\<V>s ! i)}"
+    by (metis Compr_image_eq lessThan_atLeast0 points_set_index_img)
+  thus ?thesis using inj_on_nth points_list_length
+    by (metis (no_types, lifting) card_image distinct lessThan_atLeast0 lessThan_iff mem_Collect_eq)
+qed
+
+lemma card_block_points_filter: 
+  assumes "j < \<b>"
+  shows "card (\<B>s ! j) = card {i \<in> {0..<\<v>} . (\<V>s ! i) \<in> (\<B>s ! j)}"
+proof -
+  obtain bl where "bl \<in># \<B>" and blis: "bl = \<B>s ! j"
+    using assms by auto
+  then have cbl: "card bl = card {v \<in> \<V> . v \<in> bl}" using block_size_alt by simp
+  have "\<V> = (\<lambda> i. \<V>s ! i) ` {0..<\<v>}" using bij_betw_points_index
+    using lessThan_atLeast0 points_set_index_img by presburger
+  then have "Set.filter (\<lambda> v . v \<in> bl) \<V> = Set.filter (\<lambda> v . v \<in> bl) ((\<lambda> i. \<V>s ! i) ` {0..<\<v>})"
+    by presburger 
+  have "card {i \<in> {0..<\<v>} . (\<V>s ! i) \<in> bl} = card {v \<in> \<V> . v \<in> bl}" 
+    using card_filter_point_indices by simp
+  thus ?thesis using cbl blis by simp
+qed
+
+lemma obtains_two_diff_block_indexes: 
+  assumes "j1 < \<b>"
+  assumes "j2 < \<b>"
+  assumes "j1 \<noteq> j2"
+  assumes "\<b> \<ge> 2"
+  obtains bl1 bl2 where "bl1 \<in># \<B>" and "\<B>s ! j1 = bl1" and "bl2 \<in># \<B> - {#bl1#}" and "\<B>s ! j2 = bl2"
+proof -
+  have j1lt: "min j1 (length \<B>s) = j1" using assms by auto
+  obtain bl1 where bl1in: "bl1 \<in># \<B>" and bl1eq: "\<B>s ! j1 = bl1"
+    using assms(1) valid_blocks_index by blast
+  then have split: "\<B>s = take j1 \<B>s @ \<B>s!j1 # drop (Suc j1) \<B>s" 
+    using assms id_take_nth_drop by auto
+  then have lj1: "length (take j1 \<B>s) = j1" using j1lt by (simp add: length_take[of j1 \<B>s]) 
+  have "\<B> = mset (take j1 \<B>s @ \<B>s!j1 # drop (Suc j1) \<B>s)" using split assms(1) by presburger 
+  then have bsplit: "\<B> = mset (take j1 \<B>s) + {#bl1#} + mset (drop (Suc j1) \<B>s)" by (simp add: bl1eq)
+  then have btake: "\<B> - {#bl1#} = mset (take j1 \<B>s) + mset (drop (Suc j1) \<B>s)" by simp
+  thus ?thesis proof (cases "j2 < j1")
+    case True
+    then have "j2 < length (take j1 \<B>s)" using lj1 by simp
+    then obtain bl2 where bl2eq: "bl2 = (take j1 \<B>s) ! j2" by auto
+    then have bl2eq2: "bl2 = \<B>s ! j2"
+      by (simp add: True) 
+    then have "bl2 \<in># \<B> - {#bl1#}" using btake
+      by (metis bl2eq \<open>j2 < length (take j1 \<B>s)\<close> nth_mem_mset union_iff) 
+    then show ?thesis using bl2eq2 bl1in bl1eq that by auto
+  next
+    case False
+    then have j2gt: "j2 \<ge> Suc j1" using assms by simp
+    then obtain i where ieq: "i = j2 - Suc j1"
+      by simp 
+    then have j2eq: "j2 = (Suc j1) + i" using j2gt by presburger
+    have "length (drop (Suc j1) \<B>s) = \<b> - (Suc j1)" using blocks_list_length by auto
+    then have "i < length (drop (Suc j1) \<B>s)" using ieq assms blocks_list_length
+      using diff_less_mono j2gt by presburger 
+    then obtain bl2 where bl2eq: "bl2 = (drop (Suc j1) \<B>s) ! i" by auto
+    then have bl2in: "bl2 \<in># \<B> - {#bl1#}" using btake nth_mem_mset union_iff
+      by (metis \<open>i < length (drop (Suc j1) \<B>s)\<close>) 
+    then have "bl2 = \<B>s ! j2" using bl2eq nth_drop blocks_list_length assms j2eq
+      by (metis Suc_leI)
+    then show ?thesis using bl1in bl1eq bl2in that by auto
+  qed
+qed
+
+lemma filter_size_blocks_eq_card_indexes: "size {# b \<in># \<B> . P b #} = card {j \<in> {..<(\<b>)}. P (\<B>s ! j)}"
+proof -
+  have "\<B> = image_mset (\<lambda> j . \<B>s ! j) (mset_set {..<(\<b>)})" 
+    using blocks_mset_image by simp
+  then have helper: "{# b \<in># \<B> . P b #} = image_mset (\<lambda> j . \<B>s ! j) {# j \<in># (mset_set {..< \<b>}). P (\<B>s ! j) #} "
+    by (simp add: filter_mset_image_mset)
+  have "card {j \<in> {..<\<b>}. P (\<B>s ! j)} = size {# j \<in># (mset_set {..< \<b>}). P (\<B>s ! j) #}"
+    using card_size_filter_eq [of "{..<\<b>}"] by simp
+  thus ?thesis using helper by simp
+qed
+
+lemma blocks_index_ne_belong: 
+  assumes "i1 < length \<B>s"
+  assumes "i2 < length \<B>s"
+  assumes "i1 \<noteq> i2"
+  shows "\<B>s ! i2 \<in># \<B> - {#(\<B>s ! i1)#}"
+proof (cases "\<B>s ! i1 = \<B>s ! i2")
+  case True
+  then have "count (mset \<B>s) (\<B>s ! i1) \<ge> 2" using count_min_2_indices assms by fastforce
+  then have "count ((mset \<B>s) - {#(\<B>s ! i1)#}) (\<B>s ! i1) \<ge> 1"
+    by (metis Nat.le_diff_conv2 add_leD2 count_diff count_single nat_1_add_1) 
+  then show ?thesis
+    by (metis True count_inI not_one_le_zero)
+next
+  case False
+  have "\<B>s ! i2 \<in># \<B>" using assms
+    by simp 
+  then show ?thesis using False
+    by (metis in_remove1_mset_neq)
+qed
+
+lemma inter_num_points_filter_def: 
+  assumes "j1 < \<b>" "j2 < \<b>" "j1 \<noteq> j2"
+  shows "card {x \<in> {0..<\<v>} . ((\<V>s ! x) \<in> (\<B>s ! j1) \<and> (\<V>s ! x) \<in> (\<B>s ! j2)) } = (\<B>s ! j1) |\<inter>| (\<B>s ! j2)"
+proof - 
+  have inter: "\<And> v. v \<in> \<V> \<Longrightarrow> v \<in> (\<B>s ! j1) \<and> v \<in> (\<B>s ! j2) \<longleftrightarrow> v \<in> (\<B>s ! j1) \<inter> (\<B>s ! j2)"
+    by simp 
+  obtain bl1 bl2 where bl1in: "bl1 \<in># \<B>" and bl1eq: "\<B>s ! j1 = bl1" and bl2in: "bl2 \<in># \<B> - {#bl1#}" 
+    and bl2eq: "\<B>s ! j2 = bl2" 
+    using assms obtains_two_diff_block_indexes
+    by (metis blocks_index_ne_belong size_mset valid_blocks_index) 
+  have "card {x \<in> {0..<\<v>} . (\<V>s ! x) \<in> (\<B>s ! j1) \<and> (\<V>s ! x) \<in> (\<B>s ! j2) } = 
+      card {v \<in> \<V> . v \<in> (\<B>s ! j1) \<and> v \<in> (\<B>s ! j2) }" 
+    using card_filter_point_indices by simp
+  also have "... = card {v \<in> \<V> . v \<in> bl1 \<and> v \<in> bl2 }" using bl1eq bl2eq by simp
+  finally show ?thesis using points_inter_num_rep bl1in bl2in
+    by (simp add: bl1eq bl2eq) 
+qed
+
+text \<open>Define an incidence matrix for this ordering of an incidence system \<close>
+
+abbreviation N :: "int mat" where
+"N \<equiv> inc_mat_of \<V>s \<B>s"
+
+sublocale zero_one_matrix_ring_1 "N"
+  using inc_mat_of_01_mat .
+
+lemma N_alt_def_dim: "N = mat \<v> \<b> (\<lambda> (i,j) . if (incident (\<V>s ! i) (\<B>s ! j)) then 1 else 0) " 
+  using incidence_cond_indexed inc_mat_of_def 
+  by (intro eq_matI) (simp_all add: inc_mat_dim_row inc_mat_dim_col inc_matrix_point_in_block_one 
+      inc_matrix_point_not_in_block_zero points_list_length)
+
+text \<open>Matrix Dimension related lemmas \<close>
+ 
+lemma N_carrier_mat: "N \<in> carrier_mat \<v> \<b>" 
+  by (simp add: N_alt_def_dim)
+
+lemma dim_row_is_v[simp]: "dim_row N = \<v>"
+  by (simp add: N_alt_def_dim)
+
+lemma dim_col_is_b[simp]: "dim_col N = \<b>"
+  by (simp add:  N_alt_def_dim)
+
+lemma dim_vec_row_N: "dim_vec (row N i) = \<b>"
+  by (simp add:  N_alt_def_dim)
+
+lemma dim_vec_col_N: "dim_vec (col N i) = \<v>" by simp 
+
+lemma dim_vec_N_col: 
+  assumes "j < \<b>"
+  shows "dim_vec (cols N ! j) = \<v>"
+proof -
+  have "cols N ! j = col N j" using assms dim_col_is_b by simp
+  then have "dim_vec (cols N ! j) = dim_vec (col N j)" by simp
+  thus ?thesis using dim_col assms by (simp) 
+qed
+
+lemma N_carrier_mat_01_lift: "lift_01_mat N \<in> carrier_mat \<v> \<b>"
+  by auto
+
+text \<open>Transpose properties \<close>
+
+lemma transpose_N_mult_dim: "dim_row (N * N\<^sup>T) = \<v>" "dim_col (N * N\<^sup>T) = \<v>"
+  by (simp_all)
+
+lemma N_trans_index_val: "i < dim_col N \<Longrightarrow> j < dim_row N \<Longrightarrow> 
+    N\<^sup>T $$ (i, j) = (if (\<V>s ! j) \<in> (\<B>s ! i) then 1 else 0)"
+  by (simp add: inc_mat_of_def)
+
+text \<open>Matrix element and index related lemmas \<close>
+lemma mat_row_elems: "i < \<v> \<Longrightarrow> vec_set (row N i) \<subseteq> {0, 1}"
+  using points_list_length
+  by (simp add: row_elems_ss01) 
+
+lemma mat_col_elems: "j < \<b> \<Longrightarrow> vec_set (col N j) \<subseteq> {0, 1}"
+  using blocks_list_length by (metis col_elems_ss01 dim_col_is_b)
+
+lemma matrix_elems_one_zero: "i < \<v> \<Longrightarrow> j < \<b> \<Longrightarrow> N $$ (i, j) = 0 \<or> N $$ (i, j) = 1"
+  by (metis blocks_list_length inc_matrix_elems_one_zero points_list_length)
+
+lemma matrix_point_in_block_one: "i < \<v> \<Longrightarrow> j < \<b> \<Longrightarrow> (\<V>s ! i)\<in> (\<B>s ! j) \<Longrightarrow>N $$ (i, j) = 1"
+  by (metis inc_matrix_point_in_block_one points_list_length blocks_list_length )   
+
+lemma matrix_point_not_in_block_zero: "i < \<v> \<Longrightarrow> j < \<b> \<Longrightarrow> \<V>s ! i \<notin> \<B>s ! j \<Longrightarrow> N $$ (i, j) = 0"
+  by(metis inc_matrix_point_not_in_block_zero points_list_length blocks_list_length)
+
+lemma matrix_point_in_block: "i < \<v> \<Longrightarrow> j < \<b> \<Longrightarrow> N $$ (i, j) = 1 \<Longrightarrow> \<V>s ! i \<in> \<B>s ! j"
+  by (metis blocks_list_length points_list_length  inc_matrix_point_in_block)
+
+lemma matrix_point_not_in_block: "i < \<v> \<Longrightarrow> j < \<b> \<Longrightarrow> N $$ (i, j) = 0 \<Longrightarrow> \<V>s ! i \<notin> \<B>s ! j"
+  by (metis blocks_list_length points_list_length inc_matrix_point_not_in_block)
+
+lemma matrix_point_not_in_block_iff: "i < \<v> \<Longrightarrow> j < \<b> \<Longrightarrow> N $$ (i, j) = 0 \<longleftrightarrow> \<V>s ! i \<notin> \<B>s ! j"
+  by (metis blocks_list_length points_list_length inc_matrix_point_not_in_block_iff)
+
+lemma matrix_point_in_block_iff: "i < \<v> \<Longrightarrow> j < \<b> \<Longrightarrow> N $$ (i, j) = 1 \<longleftrightarrow> \<V>s ! i \<in> \<B>s ! j"
+  by (metis blocks_list_length points_list_length inc_matrix_point_in_block_iff)
+
+lemma matrix_subset_implies_one: "I \<subseteq> {..< \<v>} \<Longrightarrow> j < \<b> \<Longrightarrow> (!) \<V>s ` I \<subseteq> \<B>s ! j \<Longrightarrow> i \<in> I \<Longrightarrow> 
+  N $$ (i, j) = 1"
+  by (metis blocks_list_length points_list_length inc_matrix_subset_implies_one)
+
+lemma matrix_one_implies_membership: 
+"I \<subseteq> {..< \<v>} \<Longrightarrow> j < size \<B> \<Longrightarrow> \<forall>i\<in>I. N $$ (i, j) = 1 \<Longrightarrow> i \<in> I \<Longrightarrow> \<V>s ! i \<in> \<B>s ! j"
+  by (simp add: matrix_point_in_block_iff subset_iff)
+
+text \<open>Incidence Vector's of Incidence Matrix columns \<close>
+
+lemma col_inc_vec_of: "j < length \<B>s \<Longrightarrow> inc_vec_of \<V>s (\<B>s ! j) = col N j"
+  by (simp add: inc_mat_col_inc_vec) 
+
+lemma inc_vec_eq_iff_blocks: 
+  assumes "bl \<in># \<B>"
+  assumes "bl' \<in># \<B>"
+  shows "inc_vec_of \<V>s bl = inc_vec_of \<V>s bl' \<longleftrightarrow> bl = bl'"
+proof (intro iffI eq_vecI, simp_all add: inc_vec_dim assms)
+  define v1 :: "'c :: {ring_1} vec" where "v1 = inc_vec_of \<V>s bl"
+  define v2 :: "'c :: {ring_1} vec" where "v2 = inc_vec_of \<V>s bl'"
+  assume a: "v1 = v2"
+  then have "dim_vec v1 = dim_vec v2"
+    by (simp add: inc_vec_dim) 
+  then have "\<And> i. i < dim_vec v1 \<Longrightarrow> v1 $ i = v2 $ i" using a by simp
+  then have "\<And> i. i < length \<V>s \<Longrightarrow> v1 $ i = v2 $ i" by (simp add: v1_def inc_vec_dim)
+  then have "\<And> i. i < length \<V>s \<Longrightarrow> (\<V>s ! i)  \<in> bl \<longleftrightarrow> (\<V>s ! i)  \<in> bl'"
+    using  inc_vec_index_one_iff v1_def v2_def by metis 
+  then have "\<And> x. x \<in> \<V> \<Longrightarrow> x \<in> bl \<longleftrightarrow> x \<in> bl'"
+    using points_list_length valid_points_index_cons by auto 
+  then show "bl = bl'" using wellformed assms
+    by (meson subset_antisym subset_eq)
+qed
+
+text \<open>Incidence matrix column properties\<close>
+
+lemma N_col_def: "j < \<b> \<Longrightarrow> i < \<v> \<Longrightarrow> (col N j) $ i = (if (\<V>s ! i \<in> \<B>s ! j) then 1 else 0)"
+  by (metis inc_mat_col_def points_list_length blocks_list_length) 
+
+lemma N_col_def_indiv: "j < \<b> \<Longrightarrow> i < \<v> \<Longrightarrow> \<V>s ! i \<in> \<B>s ! j \<Longrightarrow> (col N j) $ i = 1"
+     "j < \<b> \<Longrightarrow> i < \<v> \<Longrightarrow> \<V>s ! i \<notin> \<B>s ! j \<Longrightarrow> (col N j) $ i = 0"
+  by(simp_all add: inc_matrix_point_in_block_one inc_matrix_point_not_in_block_zero points_list_length)
+
+lemma N_col_list_map_elem: "j < \<b> \<Longrightarrow> i < \<v> \<Longrightarrow> 
+    col N j $ i = map_vec (\<lambda> x . if (x \<in> (\<B>s ! j)) then 1 else 0) (vec_of_list \<V>s) $ i"
+  by (metis inc_mat_col_list_map_elem points_list_length blocks_list_length) 
+
+lemma N_col_list_map: "j < \<b> \<Longrightarrow> col N j = map_vec (\<lambda> x . if (x \<in> (\<B>s ! j)) then 1 else 0) (vec_of_list \<V>s)"
+  by (metis inc_mat_col_list_map blocks_list_length) 
+
+lemma N_col_mset_point_set_img: "j < \<b> \<Longrightarrow> 
+    vec_mset (col N j) = image_mset (\<lambda> x. if (x \<in> (\<B>s ! j)) then 1 else 0) (mset_set \<V>)"
+  using vec_mset_img_map N_col_list_map points_indexing
+  by (metis (no_types, lifting) finite_sets permutations_of_multisetD permutations_of_set_altdef) 
+
+lemma matrix_col_to_block: 
+  assumes "j < \<b>"
+  shows "\<B>s ! j = (\<lambda> k . \<V>s ! k) ` {i \<in> {..< \<v>} . (col N j) $ i = 1}"
+proof (intro subset_antisym subsetI)
+  fix x assume assm1: "x \<in> \<B>s ! j"
+  then have "x \<in> \<V>" using wellformed assms valid_blocks_index by blast 
+  then obtain i where vs: "\<V>s ! i = x" and "i < \<v>"
+    using valid_points_index_cons by auto 
+  then have inset: "i \<in> {..< \<v>}"
+    by fastforce
+  then have "col N j $ i = 1" using assm1 N_col_def assms vs
+    using \<open>i < \<v>\<close> by presburger 
+  then have "i \<in> {i. i \<in> {..< \<v>} \<and> col N j $ i = 1}"
+    using inset by blast
+  then show "x \<in> (!) \<V>s ` {i.  i \<in> {..<\<v>} \<and> col N j $ i = 1}" using vs by blast
+next
+  fix x assume assm2: "x \<in> ((\<lambda> k . \<V>s ! k) ` {i \<in> {..< \<v>} . col N j $ i = 1})"
+  then obtain k where "x = \<V>s !k" and inner: "k \<in>{i \<in> {..< \<v>} . col N j $ i = 1}"
+    by blast 
+  then have ilt: "k < \<v>" by auto
+  then have "N $$ (k, j) = 1" using inner
+    by (metis (mono_tags) N_col_def assms matrix_point_in_block_iff matrix_point_not_in_block_zero mem_Collect_eq) 
+  then show "x \<in> \<B>s ! j" using ilt
+    using \<open>x = \<V>s ! k\<close> assms matrix_point_in_block_iff by blast
+qed
+
+lemma matrix_col_to_block_v2: "j < \<b> \<Longrightarrow> \<B>s ! j = (\<lambda> k . \<V>s ! k) ` map_col_to_block (col N j)"
+  using matrix_col_to_block map_col_to_block_def by fastforce
+
+lemma matrix_col_in_blocks: "j < \<b> \<Longrightarrow> (!) \<V>s ` map_col_to_block (col N j) \<in># \<B>"
+  using matrix_col_to_block_v2 by (metis (no_types, lifting) valid_blocks_index) 
+
+lemma inc_matrix_col_block: 
+  assumes "c \<in> set (cols N)"
+  shows "(\<lambda> x. \<V>s ! x) ` (map_col_to_block c) \<in># \<B>"
+proof -
+  obtain j where "c = col N j" and "j < \<b>" using assms cols_length cols_nth in_mset_conv_nth 
+    ordered_incidence_system_axioms set_mset_mset by (metis dim_col_is_b)  
+  thus ?thesis
+    using matrix_col_in_blocks by blast 
+qed
+
+text \<open> Incidence Matrix Row Definitions \<close>
+lemma N_row_def: "j < \<b> \<Longrightarrow> i < \<v> \<Longrightarrow> (row N i) $ j = (if (\<V>s ! i \<in> \<B>s ! j) then 1 else 0)"
+  by (metis inc_mat_row_def points_list_length blocks_list_length) 
+
+lemma N_row_list_map_elem: "j < \<b> \<Longrightarrow> i < \<v> \<Longrightarrow> 
+    row N i $ j = map_vec (\<lambda> bl . if ((\<V>s ! i) \<in> bl) then 1 else 0) (vec_of_list \<B>s) $ j"
+  by (metis inc_mat_row_list_map_elem points_list_length blocks_list_length) 
+
+lemma N_row_list_map: "i < \<v> \<Longrightarrow> 
+    row N i = map_vec (\<lambda> bl . if ((\<V>s ! i) \<in> bl) then 1 else 0) (vec_of_list \<B>s)"
+  by (simp add: inc_mat_row_list_map points_list_length blocks_list_length) 
+
+lemma N_row_mset_blocks_img: "i < \<v> \<Longrightarrow> 
+    vec_mset (row N i) = image_mset (\<lambda> x . if ((\<V>s ! i) \<in> x) then 1 else 0) \<B>"
+  using vec_mset_img_map N_row_list_map by metis
+
+text \<open>Alternate Block representations \<close>
+
+lemma block_mat_cond_rep:
+  assumes "j < length \<B>s"
+  shows "(\<B>s ! j) = {\<V>s ! i | i. i < length \<V>s \<and> N $$ (i, j) = 1}"
+proof -
+  have cond: "\<And> i. i < length \<V>s \<and> N $$ (i, j) = 1 \<longleftrightarrow>i \<in> {..< \<v>} \<and> (col N j) $ i = 1"
+    using assms points_list_length by auto
+  have "(\<B>s ! j) = (\<lambda> k . \<V>s ! k) ` {i \<in> {..< \<v>} . (col N j) $ i = 1}" 
+    using matrix_col_to_block assms by simp
+  also have "... = {\<V>s ! i | i. i \<in> {..< \<v>} \<and> (col N j) $ i = 1}" by auto
+  finally show "(\<B>s ! j) = {\<V>s ! i | i. i < length \<V>s \<and> N $$ (i, j) = 1}"
+    using Collect_cong cond by auto
+qed
+
+lemma block_mat_cond_rep': "j < length \<B>s \<Longrightarrow> (\<B>s ! j) = ((!) \<V>s) ` {i . i < length \<V>s \<and> N $$ (i, j) = 1}"
+  by (simp add: block_mat_cond_rep setcompr_eq_image)
+
+lemma block_mat_cond_rev: 
+  assumes "j < length \<B>s"
+  shows "{i . i < length \<V>s \<and> N $$ (i, j) = 1} = ((List_Index.index) \<V>s) ` (\<B>s ! j)"
+proof (intro Set.set_eqI iffI)
+  fix i assume a1: "i \<in> {i. i < length \<V>s \<and> N $$ (i, j) = 1}"
+  then have ilt1: "i < length \<V>s" and Ni1: "N $$ (i, j) = 1" by auto
+  then obtain x where "\<V>s ! i = x" and "x \<in> (\<B>s ! j)"
+    using assms inc_matrix_point_in_block by blast  
+  then have "List_Index.index \<V>s x = i" using distinct  index_nth_id ilt1 by auto
+  then show "i \<in> List_Index.index \<V>s ` \<B>s ! j" by (metis \<open>x \<in> \<B>s ! j\<close> imageI) 
+next
+  fix i assume a2: "i \<in> List_Index.index \<V>s ` \<B>s ! j"
+  then obtain x where ieq: "i = List_Index.index \<V>s x" and xin: "x \<in> \<B>s !j"
+    by blast 
+  then have ilt: "i < length \<V>s"
+    by (smt (z3) assms index_first index_le_size nat_less_le nth_mem_mset points_list_length 
+        valid_points_index_cons wf_invalid_point)
+  then have "N $$ (i, j) = 1" using xin inc_matrix_point_in_block_one
+    by (metis ieq assms index_conv_size_if_notin less_irrefl_nat nth_index)
+  then show "i \<in> {i. i < length \<V>s \<and> N $$ (i, j) = 1}" using ilt by simp
+qed
+
+text \<open>Incidence Matrix incidence system properties \<close>
+lemma incomplete_block_col:
+  assumes "j < \<b>"
+  assumes "incomplete_block (\<B>s ! j)"
+  shows "0 \<in>$ (col N j)" 
+proof -
+  obtain x where "x \<in> \<V>" and "x \<notin> (\<B>s ! j)"
+    by (metis Diff_iff assms(2) incomplete_block_proper_subset psubset_imp_ex_mem)
+  then obtain i where "\<V>s ! i = x" and "i< \<v>" 
+    using valid_points_index_cons by blast 
+  then have "N $$ (i, j) = 0"
+    using \<open>x \<notin> \<B>s ! j\<close> assms(1) matrix_point_not_in_block_zero by blast 
+  then have "col N j $ i = 0"
+    using N_col_def \<open>\<V>s ! i = x\<close> \<open>i < \<v>\<close> \<open>x \<notin> \<B>s ! j\<close> assms(1) by fastforce 
+  thus ?thesis using vec_setI
+    by (smt (z3) \<open>i < \<v>\<close> dim_col dim_row_is_v)
+qed
+
+lemma mat_rep_num_N_row: 
+  assumes "i < \<v>"
+  shows "mat_rep_num N i = \<B> rep (\<V>s ! i)"
+proof -
+  have "count (image_mset (\<lambda> x . if ((\<V>s ! i) \<in> x) then 1 else (0 :: int )) \<B>) 1 = 
+    size (filter_mset (\<lambda> x . (\<V>s ! i) \<in> x) \<B>)"
+    using count_mset_split_image_filter[of "\<B>" "1" "\<lambda> x . (0 :: int)" "\<lambda> x . (\<V>s ! i) \<in> x"] by simp
+  then have "count (image_mset (\<lambda> x . if ((\<V>s ! i) \<in> x) then 1 else (0 :: int )) \<B>) 1
+    = \<B> rep (\<V>s ! i)" by (simp add: point_rep_number_alt_def)
+  thus ?thesis using N_row_mset_blocks_img assms
+    by (simp add: mat_rep_num_def) 
+qed
+
+lemma point_rep_mat_row_sum:  "i < \<v> \<Longrightarrow> sum_vec (row N i) = \<B> rep (\<V>s ! i)"
+  using count_vec_sum_ones_alt mat_rep_num_N_row mat_row_elems mat_rep_num_def by metis 
+
+lemma mat_block_size_N_col: 
+  assumes "j < \<b>"
+  shows "mat_block_size N j = card (\<B>s ! j)"
+proof -
+  have val_b: "\<B>s ! j \<in># \<B>" using assms valid_blocks_index by auto 
+  have "\<And> x. x \<in># mset_set \<V> \<Longrightarrow> (\<lambda>x . (0 :: int)) x \<noteq> 1" using zero_neq_one by simp
+  then have "count (image_mset (\<lambda> x. if (x \<in> (\<B>s ! j)) then 1 else (0 :: int)) (mset_set \<V>)) 1 = 
+    size (filter_mset (\<lambda> x . x \<in> (\<B>s ! j)) (mset_set \<V>))"
+    using count_mset_split_image_filter [of "mset_set \<V>" "1" "(\<lambda> x . (0 :: int))" "\<lambda> x . x \<in> \<B>s ! j"] 
+    by simp
+  then have "count (image_mset (\<lambda> x. if (x \<in> (\<B>s ! j)) then 1 else (0 :: int)) (mset_set \<V>)) 1 = card (\<B>s ! j)"
+    using val_b block_size_alt by (simp add: finite_sets)
+  thus ?thesis using N_col_mset_point_set_img assms mat_block_size_def by metis 
+qed
+
+lemma block_size_mat_rep_sum: "j < \<b> \<Longrightarrow> sum_vec (col N j) = mat_block_size N j"
+  using count_vec_sum_ones_alt mat_block_size_N_col mat_block_size_def by (metis mat_col_elems) 
+
+lemma mat_point_index_rep:
+  assumes "I \<subseteq> {..<\<v>}"
+  shows "mat_point_index N I = \<B> index ((\<lambda> i. \<V>s ! i) ` I)"
+proof - 
+  have "\<And> i . i \<in> I \<Longrightarrow> \<V>s ! i \<in> \<V>" using assms valid_points_index by auto 
+  then have eqP: "\<And> j. j < dim_col N \<Longrightarrow> ((\<lambda> i. \<V>s ! i) ` I) \<subseteq> (\<B>s ! j) \<longleftrightarrow> (\<forall> i \<in> I . N $$ (i, j) = 1)"
+  proof (intro iffI subsetI, simp_all)
+    show "\<And>j i. j < length \<B>s \<Longrightarrow> (\<And>i. i \<in> I \<Longrightarrow> \<V>s ! i \<in> \<V>) \<Longrightarrow> (!) \<V>s ` I \<subseteq> \<B>s ! j \<Longrightarrow> 
+        \<forall>i\<in>I. N $$ (i, j) = 1"
+      using matrix_subset_implies_one assms by simp
+    have "\<And>x.  x\<in> (!) \<V>s ` I \<Longrightarrow> \<exists> i \<in> I. \<V>s ! i = x"
+      by auto 
+    then show "\<And>j x. j < length \<B>s \<Longrightarrow> \<forall>i\<in>I. N $$ (i, j) = 1 \<Longrightarrow> x \<in> (!) \<V>s ` I 
+        \<Longrightarrow> (\<And>i. i \<in> I \<Longrightarrow> \<V>s ! i \<in> \<V>) \<Longrightarrow> x \<in> \<B>s ! j"
+      using assms matrix_one_implies_membership by (metis blocks_list_length) 
+  qed
+  have "card {j . j < dim_col N \<and> (\<forall> i \<in> I . N $$(i, j) = 1)} = 
+      card {j . j < dim_col N \<and> ((\<lambda> i . \<V>s ! i) ` I) \<subseteq> \<B>s ! j}"
+    using eqP by (metis (mono_tags, lifting))
+  also have "... = size {# b \<in># \<B> . ((\<lambda> i . \<V>s ! i) ` I) \<subseteq> b #}"
+    using filter_size_blocks_eq_card_indexes by auto
+  also have "... = points_index \<B> ((\<lambda> i . \<V>s ! i) ` I)"
+    by (simp add: points_index_def)
+  finally have "card {j . j < dim_col N \<and> (\<forall> i \<in> I . N $$(i, j) = 1)} = \<B> index ((\<lambda> i . \<V>s ! i) ` I)"
+    by blast
+  thus ?thesis unfolding mat_point_index_def by simp
+qed
+
+lemma incidence_mat_two_index: "i1 < \<v> \<Longrightarrow> i2 < \<v> \<Longrightarrow> 
+    mat_point_index N {i1, i2} = \<B> index {\<V>s ! i1, \<V>s ! i2}"
+  using mat_point_index_two_alt[of  i1 N i2 ] mat_point_index_rep[of "{i1, i2}"] dim_row_is_v
+  by (metis (no_types, lifting) empty_subsetI image_empty image_insert insert_subset lessThan_iff) 
+
+lemma ones_incidence_mat_block_size: 
+  assumes "j < \<b>"
+  shows "((u\<^sub>v \<v>) \<^sub>v* N) $ j = mat_block_size N j"
+proof - 
+  have "dim_vec ((u\<^sub>v \<v>) \<^sub>v* N) = \<b>" by (simp) 
+  then have "((u\<^sub>v \<v>) \<^sub>v* N) $ j = (u\<^sub>v \<v>) \<bullet> col N j" using assms by simp 
+  also have "... = (\<Sum> i \<in> {0 ..< \<v>}. (u\<^sub>v \<v>) $ i * (col N j) $ i)" 
+    by (simp add: scalar_prod_def)
+  also have "... = sum_vec (col N j)" using dim_row_is_v by (simp add: sum_vec_def)
+  finally show ?thesis  using block_size_mat_rep_sum assms by simp
+qed
+
+lemma mat_block_size_conv:  "j < dim_col N \<Longrightarrow> card (\<B>s ! j) = mat_block_size N j"
+  by (simp add: mat_block_size_N_col)
+
+lemma mat_inter_num_conv: 
+  assumes "j1 < dim_col N" "j2 < dim_col N"
+  shows "(\<B>s ! j1) |\<inter>| (\<B>s ! j2) = mat_inter_num N j1 j2"
+proof -
+  have eq_sets: "\<And> P. (\<lambda> i . \<V>s ! i) ` {i \<in> {0..<\<v>}. P (\<V>s ! i)} = {x \<in> \<V> . P x}"
+    by (metis Compr_image_eq lessThan_atLeast0 points_set_index_img)
+  have bin: "\<B>s ! j1 \<in># \<B>" "\<B>s ! j2 \<in># \<B>" using assms dim_col_is_b by simp_all
+  have "(\<B>s ! j1) |\<inter>| (\<B>s ! j2) = card ((\<B>s ! j1) \<inter> (\<B>s ! j2))" 
+    by (simp add: intersection_number_def)
+  also have "... = card {x . x \<in> (\<B>s ! j1) \<and> x \<in> (\<B>s ! j2)}"
+    by (simp add: Int_def) 
+  also have "... = card {x \<in> \<V>. x \<in> (\<B>s ! j1) \<and> x \<in> (\<B>s ! j2)}" using wellformed bin
+    by (meson wf_invalid_point) 
+  also have "... = card ((\<lambda> i . \<V>s ! i) ` {i \<in> {0..<\<v>}. (\<V>s ! i) \<in> (\<B>s ! j1) \<and> (\<V>s ! i) \<in> (\<B>s ! j2)})" 
+    using eq_sets[of "\<lambda> x. x \<in> (\<B>s ! j1) \<and> x \<in> (\<B>s ! j2)"] by simp
+  also have "... = card ({i \<in> {0..<\<v>}. (\<V>s ! i) \<in> (\<B>s ! j1) \<and> (\<V>s ! i) \<in> (\<B>s ! j2)})"
+    using points_indexing_inj card_image
+    by (metis (no_types, lifting) lessThan_atLeast0 lessThan_iff mem_Collect_eq points_list_length) 
+  also have "... = card ({i . i < \<v> \<and> (\<V>s ! i) \<in> (\<B>s ! j1) \<and> (\<V>s ! i) \<in> (\<B>s ! j2)})" by auto
+  also have "... = card ({i . i < \<v> \<and> N $$ (i, j1) = 1 \<and> N $$ (i, j2) = 1})" using assms
+    by (metis (no_types, opaque_lifting) inc_mat_dim_col inc_matrix_point_in_block_iff points_list_length) 
+  finally have "(\<B>s ! j1) |\<inter>| (\<B>s ! j2) = card {i . i < dim_row N \<and> N $$ (i, j1) = 1 \<and> N $$ (i, j2) = 1}"
+    using dim_row_is_v by presburger
+  thus ?thesis using assms by (simp add: mat_inter_num_def)
+qed
+
+lemma non_empty_col_map_conv: 
+  assumes "j < dim_col N"
+  shows "non_empty_col N j \<longleftrightarrow> \<B>s ! j \<noteq> {}"
+proof (intro iffI)
+  assume "non_empty_col N j"
+  then obtain i where ilt: "i < dim_row N" and "(col N j) $ i \<noteq> 0"
+    using non_empty_col_obtains assms by blast
+  then have "(col N j) $ i = 1"
+    using assms
+    by (metis N_col_def_indiv(1) N_col_def_indiv(2) dim_col_is_b dim_row_is_v) 
+  then have "\<V>s ! i \<in> \<B>s ! j"
+    by (smt (verit, best) assms ilt inc_mat_col_def dim_col_is_b inc_mat_dim_col inc_mat_dim_row) 
+  thus "\<B>s ! j \<noteq> {}" by blast
+next
+  assume a: "\<B>s ! j \<noteq> {}"
+  have "\<B>s ! j \<in># \<B>" using assms dim_col_is_b by simp
+  then obtain x where "x \<in> \<B>s ! j" and "x \<in> \<V>" using wellformed a by auto
+  then obtain i where "\<V>s ! i \<in> \<B>s ! j" and "i < dim_row N" using dim_row_is_v
+    using valid_points_index_cons by auto 
+  then have "N $$ (i, j) = 1"
+    using assms by (meson inc_mat_of_index)  
+  then show "non_empty_col N j" using non_empty_col_alt_def
+    using \<open>i < dim_row N\<close> assms by fastforce 
+qed
+
+lemma scalar_prod_inc_vec_inter_num: 
+  assumes "j1 < \<b>" "j2 < \<b>"
+  shows "(col N j1) \<bullet> (col N j2) = (\<B>s ! j1) |\<inter>| (\<B>s ! j2)"
+  using scalar_prod_inc_vec_mat_inter_num assms N_carrier_mat
+  by (simp add: mat_inter_num_conv)
+
+lemma scalar_prod_block_size_lift_01: 
+  assumes "i < \<b>"
+  shows "((col (lift_01_mat N) i) \<bullet> (col (lift_01_mat N) i)) = (of_nat (card (\<B>s ! i)) :: ('b :: {ring_1}))"
+proof -
+  interpret z1: zero_one_matrix_ring_1 "(lift_01_mat N)"
+    by (intro_locales) (simp add: lift_mat_is_0_1)
+  show ?thesis using assms z1.scalar_prod_inc_vec_block_size_mat preserve_mat_block_size 
+      mat_block_size_N_col lift_01_mat_def
+    by (metis inc_mat_dim_col lift_01_mat_simp(2) of_inj_on_01_hom.inj_on_01_hom_axioms size_mset)
+qed
+
+lemma scalar_prod_inter_num_lift_01: 
+  assumes "j1 < \<b>" "j2 < \<b>"
+  shows "((col (lift_01_mat N) j1) \<bullet> (col (lift_01_mat N) j2)) = (of_nat ((\<B>s ! j1) |\<inter>| (\<B>s ! j2)) :: ('b :: {ring_1}))"
+proof -
+  interpret z1: zero_one_matrix_ring_1 "(lift_01_mat N)"
+    by (intro_locales) (simp add: lift_mat_is_0_1)
+  show ?thesis using assms z1.scalar_prod_inc_vec_mat_inter_num preserve_mat_inter_num 
+    mat_inter_num_conv lift_01_mat_def blocks_list_length inc_mat_dim_col
+    by (metis  lift_01_mat_simp(2) of_inj_on_01_hom.inj_on_01_hom_axioms)
+qed
+
+text \<open> The System complement's incidence matrix flips 0's and 1's \<close>
+
+lemma map_block_complement_entry: "j < \<b> \<Longrightarrow> (map block_complement \<B>s) ! j = block_complement (\<B>s ! j)"
+  using blocks_list_length by (metis nth_map) 
+
+lemma complement_mat_entries: 
+  assumes "i < \<v>" and "j < \<b>"
+  shows "(\<V>s ! i \<notin> \<B>s ! j) \<longleftrightarrow> (\<V>s ! i \<in> (map block_complement \<B>s) ! j)"
+  using assms block_complement_def map_block_complement_entry valid_points_index by simp
+
+lemma length_blocks_complement: "length (map block_complement \<B>s) = \<b>"
+  by auto 
+
+lemma ordered_complement: "ordered_incidence_system \<V>s (map block_complement \<B>s)"
+proof -
+  interpret inc: finite_incidence_system \<V> "complement_blocks"
+    by (simp add: complement_finite)
+  have "map inc.block_complement \<B>s \<in> permutations_of_multiset complement_blocks"
+    using complement_image by (simp add: permutations_of_multiset_def)
+  then show ?thesis using ordered_incidence_sysI[of "\<V>" "complement_blocks" "\<V>s" "(map block_complement \<B>s)"]
+    by (simp add: inc.finite_incidence_system_axioms points_indexing) 
+qed
+
+interpretation ordered_comp: ordered_incidence_system "\<V>s" "(map block_complement \<B>s)"
+  using ordered_complement by simp
+
+lemma complement_mat_entries_val: 
+  assumes "i < \<v>" and "j < \<b>"
+  shows "ordered_comp.N $$ (i, j) = (if \<V>s ! i \<in> \<B>s ! j then 0 else 1)"
+proof -
+  have cond: "(\<V>s ! i \<notin> \<B>s ! j) \<longleftrightarrow> (\<V>s ! i \<in> (map block_complement \<B>s) ! j)"
+    using complement_mat_entries assms by simp
+  then have "ordered_comp.N $$ (i, j) = (if (\<V>s ! i \<in> (map block_complement \<B>s) ! j) then 1 else 0)"
+    using assms ordered_comp.matrix_point_in_block_one ordered_comp.matrix_point_not_in_block_iff 
+    by force 
+  then show ?thesis using cond by simp
+qed
+
+lemma ordered_complement_mat: "ordered_comp.N = mat \<v> \<b> (\<lambda> (i,j) . if (\<V>s ! i) \<in> (\<B>s ! j) then 0 else 1)"
+  using complement_mat_entries_val by (intro eq_matI, simp_all)
+
+lemma ordered_complement_mat_map: "ordered_comp.N = map_mat (\<lambda>x. if x = 1 then 0 else 1) N"
+  apply (intro eq_matI, simp_all)
+  using ordered_incidence_system.matrix_point_in_block_iff ordered_incidence_system_axioms 
+    complement_mat_entries_val by (metis blocks_list_length) 
+
+
+end
+
+text \<open>Establishing connection between incidence system and ordered incidence system locale \<close>
+
+lemma (in incidence_system) alt_ordering_sysI: "Vs \<in> permutations_of_set \<V> \<Longrightarrow> Bs \<in> permutations_of_multiset \<B> \<Longrightarrow> 
+    ordered_incidence_system Vs Bs"
+  by (unfold_locales) (simp_all add: permutations_of_multisetD permutations_of_setD wellformed)
+
+lemma (in finite_incidence_system) exists_ordering_sysI: "\<exists> Vs Bs . Vs \<in> permutations_of_set \<V> \<and> 
+  Bs \<in> permutations_of_multiset \<B> \<and> ordered_incidence_system Vs Bs"
+proof -
+  obtain Vs where "Vs \<in> permutations_of_set \<V>"
+    by (meson all_not_in_conv finite_sets permutations_of_set_empty_iff) 
+  obtain Bs where "Bs \<in> permutations_of_multiset \<B>"
+    by (meson all_not_in_conv permutations_of_multiset_not_empty) 
+  then show ?thesis using alt_ordering_sysI \<open>Vs \<in> permutations_of_set \<V>\<close> by blast 
+qed
+
+lemma inc_sys_orderedI: 
+  assumes "incidence_system V B" and "distinct Vs" and "set Vs = V" and "mset Bs = B" 
+  shows "ordered_incidence_system Vs Bs"
+proof -
+  interpret inc: incidence_system V B using assms by simp
+  show ?thesis proof (unfold_locales)
+    show "\<And>b. b \<in># mset Bs \<Longrightarrow> b \<subseteq> set Vs" using inc.wellformed assms by simp
+    show "distinct Vs" using assms(2)permutations_of_setD(2) by auto 
+  qed
+qed
+
+text \<open>Generalise the idea of an incidence matrix to an unordered context \<close>
+
+definition is_incidence_matrix :: "'c :: {ring_1} mat \<Rightarrow> 'a set \<Rightarrow> 'a set multiset \<Rightarrow> bool" where
+"is_incidence_matrix N V B \<longleftrightarrow> 
+  (\<exists> Vs Bs . (Vs \<in> permutations_of_set V \<and> Bs \<in> permutations_of_multiset B \<and> N = (inc_mat_of Vs Bs)))"
+
+lemma (in incidence_system) is_incidence_mat_alt: "is_incidence_matrix N \<V> \<B> \<longleftrightarrow> 
+  (\<exists> Vs Bs. (set Vs = \<V> \<and> mset Bs = \<B> \<and> ordered_incidence_system Vs Bs \<and> N = (inc_mat_of Vs Bs)))"
+proof (intro iffI, simp add: is_incidence_matrix_def)
+  assume "\<exists>Vs. Vs \<in> permutations_of_set \<V> \<and> (\<exists>Bs. Bs \<in> permutations_of_multiset \<B> \<and> N = inc_mat_of Vs Bs)"
+  then obtain Vs Bs where "Vs \<in> permutations_of_set \<V> \<and> Bs \<in> permutations_of_multiset \<B> \<and> N = inc_mat_of Vs Bs"
+    by auto
+  then show "\<exists>Vs. set Vs = \<V> \<and> (\<exists>Bs. mset Bs = \<B> \<and> ordered_incidence_system Vs Bs \<and> N = inc_mat_of Vs Bs)"
+    using incidence_system.alt_ordering_sysI incidence_system_axioms permutations_of_multisetD permutations_of_setD(1) 
+    by blast 
+next
+  assume "\<exists>Vs Bs. set Vs = \<V> \<and> mset Bs = \<B> \<and> ordered_incidence_system Vs Bs \<and> N = inc_mat_of Vs Bs"
+  then obtain Vs Bs where s: "set Vs = \<V>" and ms: "mset Bs = \<B>" and "ordered_incidence_system Vs Bs" 
+    and n: "N = inc_mat_of Vs Bs" by auto 
+  then interpret ois: ordered_incidence_system Vs Bs by simp 
+  have vs: "Vs \<in> permutations_of_set \<V>"
+    using ois.points_indexing s by blast 
+  have "Bs \<in> permutations_of_multiset \<B>" using ois.blocks_indexing ms by blast
+  then show "is_incidence_matrix N \<V> \<B> " using n vs
+    using is_incidence_matrix_def by blast 
+qed
+
+lemma (in ordered_incidence_system) is_incidence_mat_true: "is_incidence_matrix N \<V> \<B> = True"
+  using blocks_indexing is_incidence_matrix_def points_indexing by blast
+
+subsection\<open>Incidence Matrices on Design Subtypes \<close>
+
+locale ordered_design = ordered_incidence_system \<V>s \<B>s + design "set \<V>s" "mset \<B>s" 
+  for \<V>s and \<B>s
+begin
+
+lemma incidence_mat_non_empty_blocks: 
+  assumes "j < \<b>"
+  shows "1 \<in>$ (col N j)" 
+proof -
+  obtain bl where isbl: "\<B>s ! j = bl" by simp
+  then have "bl \<in># \<B>"
+    using assms valid_blocks_index by auto 
+  then obtain x where inbl: "x \<in> bl"
+    using blocks_nempty by blast
+  then obtain i where isx: "\<V>s ! i = x" and vali: "i < \<v>"
+    using \<open>bl \<in># \<B>\<close> valid_points_index_cons wf_invalid_point by blast
+  then have "N $$ (i, j) = 1"
+    using \<open>\<B>s ! j = bl\<close> \<open>x \<in> bl\<close> assms matrix_point_in_block_one by blast
+  thus ?thesis using vec_setI
+    by (smt (verit, ccfv_SIG) N_col_def isx vali isbl inbl assms dim_vec_col_N of_nat_less_imp_less) 
+qed
+
+lemma all_cols_non_empty: "j < dim_col N \<Longrightarrow> non_empty_col N j"
+  using blocks_nempty non_empty_col_map_conv dim_col_is_b by simp 
+end
+
+locale ordered_simple_design = ordered_design \<V>s \<B>s + simple_design "(set \<V>s)" "mset \<B>s" for \<V>s \<B>s
+begin
+
+lemma block_list_distinct: "distinct \<B>s"
+  using block_mset_distinct by auto
+  
+lemma distinct_cols_N: "distinct (cols N)"
+proof -
+  have "inj_on (\<lambda> bl . inc_vec_of \<V>s bl) (set \<B>s)" using inc_vec_eq_iff_blocks 
+    by (simp add: inc_vec_eq_iff_blocks inj_on_def) 
+  then show ?thesis using distinct_map inc_mat_of_cols_inc_vecs block_list_distinct
+    by (simp add: distinct_map inc_mat_of_cols_inc_vecs ) 
+qed
+
+lemma simp_blocks_length_card: "length \<B>s = card (set \<B>s)"
+  using design_support_def simple_block_size_eq_card by fastforce
+
+lemma blocks_index_inj_on: "inj_on (\<lambda> i . \<B>s ! i) {0..<length \<B>s}"
+  by (auto simp add: inj_on_def) (metis simp_blocks_length_card card_distinct nth_eq_iff_index_eq)
+
+lemma x_in_block_set_img: assumes "x \<in> set \<B>s" shows "x \<in> (!) \<B>s ` {0..<length \<B>s}"
+proof -
+  obtain i where "\<B>s ! i = x" and "i < length \<B>s" using assms
+    by (meson in_set_conv_nth) 
+  thus ?thesis by auto
+qed
+
+lemma blocks_index_simp_bij_betw: "bij_betw (\<lambda> i . \<B>s ! i) {0..<length \<B>s} (set \<B>s)"
+  using blocks_index_inj_on x_in_block_set_img by (auto simp add: bij_betw_def) 
+
+lemma blocks_index_simp_unique:  "i1 < length \<B>s \<Longrightarrow> i2 < length \<B>s \<Longrightarrow> i1 \<noteq> i2 \<Longrightarrow> \<B>s ! i1 \<noteq> \<B>s ! i2"
+  using block_list_distinct nth_eq_iff_index_eq by blast 
+
+lemma lift_01_distinct_cols_N: "distinct (cols (lift_01_mat N))"
+  using  lift_01_mat_distinct_cols distinct_cols_N by simp
+
+end
+
+locale ordered_proper_design = ordered_design \<V>s \<B>s + proper_design "set \<V>s" "mset \<B>s" 
+  for \<V>s and \<B>s
+begin
+
+lemma mat_is_proper: "proper_inc_mat N"
+  using design_blocks_nempty v_non_zero 
+  by (auto simp add: proper_inc_mat_def)
+
+end
+
+locale ordered_constant_rep = ordered_proper_design \<V>s \<B>s + constant_rep_design "set \<V>s" "mset \<B>s" \<r> 
+  for \<V>s and \<B>s and \<r>
+
+begin
+
+lemma incidence_mat_rep_num: "i < \<v> \<Longrightarrow> mat_rep_num N i = \<r>"
+  using mat_rep_num_N_row rep_number valid_points_index by simp 
+
+lemma incidence_mat_rep_num_sum: "i < \<v> \<Longrightarrow> sum_vec (row N i) = \<r>"
+  using incidence_mat_rep_num  mat_rep_num_N_row
+  by (simp add: point_rep_mat_row_sum)  
+
+lemma transpose_N_mult_diag: 
+  assumes "i = j" and "i < \<v>" and "j < \<v>" 
+  shows "(N * N\<^sup>T) $$ (i, j) = \<r>"
+proof -
+  have unsq: "\<And> k . k < \<b> \<Longrightarrow> (N $$ (i, k))^2 = N $$ (i, k)"
+    using assms(2) matrix_elems_one_zero by fastforce
+  then have "(N * N\<^sup>T) $$ (i, j) = (\<Sum>k \<in>{0..<\<b>} . N $$ (i, k) * N $$ (j, k))"
+    using assms(2) assms(3) transpose_mat_mult_entries[of "i" "N" "j"] by (simp) 
+  also have "... = (\<Sum>k \<in>{0..<\<b>} . (N $$ (i, k))^2)" using assms(1)
+    by (simp add: power2_eq_square)
+  also have "... = (\<Sum>k \<in>{0..<\<b>} . N $$ (i, k))"
+    by (meson atLeastLessThan_iff sum.cong unsq) 
+  also have "... = (\<Sum>k \<in>{0..<\<b>} . (row N i) $ k)"
+    using assms(2) dim_col_is_b dim_row_is_v by auto 
+  finally have "(N * N\<^sup>T) $$ (i, j) = sum_vec (row N i)"
+    by (simp add: sum_vec_def)
+  thus ?thesis using incidence_mat_rep_num_sum
+    using assms(2) by presburger 
+qed
+
+end
+
+locale ordered_block_design = ordered_proper_design \<V>s \<B>s + block_design "set \<V>s" "mset \<B>s" \<k>
+  for \<V>s and \<B>s and \<k>
+
+begin 
+
+(* Every col has k ones *)
+lemma incidence_mat_block_size: "j < \<b> \<Longrightarrow> mat_block_size N j = \<k>"
+  using mat_block_size_N_col uniform valid_blocks_index by fastforce
+
+lemma incidence_mat_block_size_sum: "j < \<b> \<Longrightarrow> sum_vec (col N j) = \<k>"
+  using incidence_mat_block_size block_size_mat_rep_sum by presburger 
+
+lemma ones_mult_incidence_mat_k_index: "j < \<b> \<Longrightarrow> ((u\<^sub>v \<v>) \<^sub>v* N) $ j = \<k>"
+  using ones_incidence_mat_block_size uniform incidence_mat_block_size by blast 
+
+lemma ones_mult_incidence_mat_k: "((u\<^sub>v \<v>) \<^sub>v* N) = \<k> \<cdot>\<^sub>v (u\<^sub>v \<b>)"
+  using ones_mult_incidence_mat_k_index dim_col_is_b by (intro eq_vecI) (simp_all)
+
+end
+
+locale ordered_incomplete_design = ordered_block_design \<V>s \<B>s \<k> + incomplete_design \<V> \<B> \<k>
+  for \<V>s and \<B>s and \<k>
+
+begin 
+
+lemma incidence_mat_incomplete:  "j < \<b> \<Longrightarrow> 0 \<in>$ (col N j)"
+  using valid_blocks_index incomplete_block_col incomplete_imp_incomp_block by blast 
+
+end
+
+locale ordered_t_wise_balance = ordered_proper_design \<V>s \<B>s + t_wise_balance "set \<V>s" "mset \<B>s" \<t> \<Lambda>\<^sub>t
+  for \<V>s and \<B>s and \<t> and \<Lambda>\<^sub>t
+
+begin
+
+lemma incidence_mat_des_index: 
+  assumes "I \<subseteq> {0..<\<v>}"
+  assumes "card I = \<t>"
+  shows "mat_point_index N I = \<Lambda>\<^sub>t"
+proof -
+  have card: "card ((!) \<V>s ` I) = \<t>" using assms points_indexing_inj
+    by (metis (mono_tags, lifting) card_image ex_nat_less_eq not_le points_list_length subset_iff) 
+  have "((!) \<V>s ` I) \<subseteq> \<V>" using assms
+    by (metis atLeastLessThan_iff image_subset_iff subsetD valid_points_index)
+  then have "\<B> index ((!) \<V>s ` I) = \<Lambda>\<^sub>t" using balanced assms(2) card by simp
+  thus ?thesis using mat_point_index_rep assms(1) lessThan_atLeast0 by presburger 
+qed
+
+end
+
+locale ordered_pairwise_balance = ordered_t_wise_balance \<V>s \<B>s 2 \<Lambda> + pairwise_balance "set \<V>s" "mset \<B>s" \<Lambda>
+  for \<V>s and \<B>s and \<Lambda>
+begin
+
+lemma incidence_mat_des_two_index: 
+  assumes "i1 < \<v>"
+  assumes "i2 < \<v>"
+  assumes "i1 \<noteq> i2"
+  shows "mat_point_index N {i1, i2} = \<Lambda>"
+  using incidence_mat_des_index incidence_mat_two_index 
+proof -
+  have "\<V>s ! i1 \<noteq> \<V>s ! i2" using assms(3)
+    by (simp add: assms(1) assms(2) distinct nth_eq_iff_index_eq points_list_length) 
+  then have pair: "card {\<V>s ! i1, \<V>s ! i2} = 2" using card_2_iff by blast
+  have "{\<V>s ! i1, \<V>s ! i2} \<subseteq> \<V>" using assms
+    by (simp add: valid_points_index) 
+  then have "\<B> index {\<V>s ! i1, \<V>s ! i2} = \<Lambda>" using pair
+    using balanced by blast 
+  thus ?thesis using incidence_mat_two_index assms by simp
+qed
+
+lemma transpose_N_mult_off_diag: 
+  assumes "i \<noteq> j" and "i < \<v>" and "j < \<v>"
+  shows "(N * N\<^sup>T) $$ (i, j) = \<Lambda>"
+proof -
+  have rev: "\<And> k. k \<in> {0..<\<b>} \<Longrightarrow> \<not> (N $$ (i, k) = 1 \<and> N $$ (j, k) = 1) \<longleftrightarrow> N $$ (i, k) = 0 \<or> N $$ (j, k) = 0"
+    using assms matrix_elems_one_zero by auto
+  then have split: "{0..<\<b>} = {k \<in> {0..<\<b>}. N $$ (i, k) = 1 \<and> N $$ (j, k) = 1} \<union> 
+      {k \<in> {0..<\<b>}. N $$ (i, k) = 0 \<or> N $$ (j, k) = 0}"
+    by blast
+  have zero: "\<And> k . k \<in> {0..<\<b>} \<Longrightarrow> N $$ (i, k) = 0 \<or> N $$ (j, k) = 0 \<Longrightarrow> N $$ (i, k) * N$$ (j, k) = 0"
+    by simp 
+  have djnt: "{k \<in> {0..<\<b>}. N $$ (i, k) = 1 \<and> N $$ (j, k) = 1} \<inter> 
+    {k \<in> {0..<\<b>}. N $$ (i, k) = 0 \<or> N $$ (j, k) = 0} = {}" using rev by auto
+  have fin1: "finite {k \<in> {0..<\<b>}. N $$ (i, k) = 1 \<and> N $$ (j, k) = 1}" by simp
+  have fin2: "finite {k \<in> {0..<\<b>}. N $$ (i, k) = 0 \<or> N $$ (j, k) = 0}" by simp
+  have "(N * N\<^sup>T) $$ (i, j) = (\<Sum>k \<in>{0..<\<b>} . N $$ (i, k) * N $$ (j, k))"
+    using assms(2) assms(3) transpose_mat_mult_entries[of "i" "N" "j"] by (simp)
+  also have "... = (\<Sum>k \<in>({k' \<in> {0..<\<b>}. N $$ (i, k') = 1 \<and> N $$ (j, k') = 1} \<union> 
+    {k' \<in> {0..<\<b>}. N $$ (i, k') = 0 \<or> N $$ (j, k') = 0}) . N $$ (i, k) * N $$ (j, k))"
+    using split by metis
+  also have "... = (\<Sum>k \<in>{k' \<in> {0..<\<b>}. N $$ (i, k') = 1 \<and> N $$ (j, k') = 1} . N $$ (i, k) * N $$ (j, k)) + 
+    (\<Sum>k \<in>{k' \<in> {0..<\<b>}. N $$ (i, k') = 0 \<or> N $$ (j, k') = 0} . N $$ (i, k) * N $$ (j, k))"
+    using fin1 fin2 djnt sum.union_disjoint by blast 
+  also have "... = card {k' \<in> {0..<\<b>}. N $$ (i, k') = 1 \<and> N $$ (j, k') = 1}" 
+    by (simp add: zero)
+  also have "... = mat_point_index N {i, j}" 
+    using assms mat_point_index_two_alt[of i N j] by simp
+  finally show ?thesis using incidence_mat_des_two_index assms by simp
+qed
+
+end
+
+context pairwise_balance
+begin
+
+lemma ordered_pbdI: 
+  assumes "\<B> = mset \<B>s" and "\<V> = set \<V>s" and "distinct \<V>s"
+  shows "ordered_pairwise_balance \<V>s \<B>s \<Lambda>"
+proof -
+  interpret ois: ordered_incidence_system \<V>s \<B>s 
+    using ordered_incidence_sysII assms finite_incidence_system_axioms by blast 
+  show ?thesis using b_non_zero blocks_nempty assms t_lt_order balanced 
+    by (unfold_locales)(simp_all)
+qed
+end
+
+locale ordered_regular_pairwise_balance = ordered_pairwise_balance "\<V>s" "\<B>s" \<Lambda> + 
+  regular_pairwise_balance "set \<V>s" "mset \<B>s" \<Lambda> \<r> for \<V>s and \<B>s and \<Lambda> and \<r>
+
+sublocale ordered_regular_pairwise_balance \<subseteq> ordered_constant_rep
+  by unfold_locales
+
+context ordered_regular_pairwise_balance
+begin
+
+text \<open> Stinson's Theorem 1.15. Stinson \cite{stinsonCombinatorialDesignsConstructions2004} 
+gives an iff condition for incidence matrices of regular pairwise 
+balanced designs. The other direction is proven in the @{term "zero_one_matrix"} context \<close>
+lemma rpbd_incidence_matrix_cond: "N * (N\<^sup>T) = \<Lambda> \<cdot>\<^sub>m (J\<^sub>m \<v>) + (\<r> - \<Lambda>) \<cdot>\<^sub>m (1\<^sub>m \<v>)"
+proof (intro eq_matI)
+  fix i j
+  assume ilt: "i < dim_row (int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v> + int (\<r> - \<Lambda>) \<cdot>\<^sub>m 1\<^sub>m \<v>)" 
+    and jlt: "j < dim_col (int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v> + int (\<r> - \<Lambda>) \<cdot>\<^sub>m 1\<^sub>m \<v>)"
+  then have "(int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v> + int (\<r> - \<Lambda>) \<cdot>\<^sub>m 1\<^sub>m \<v>) $$ (i, j) = 
+    (int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v>) $$(i, j) + (int (\<r> - \<Lambda>) \<cdot>\<^sub>m 1\<^sub>m \<v>) $$ (i, j)" 
+    by simp
+  then have split: "(int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v> + int (\<r> - \<Lambda>) \<cdot>\<^sub>m 1\<^sub>m \<v>) $$ (i, j) = 
+    (int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v>) $$(i, j) + (\<r> - \<Lambda>) * ((1\<^sub>m \<v>) $$ (i, j))"
+    using ilt jlt by simp
+  have lhs: "(int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v>) $$(i, j) = \<Lambda>" using ilt jlt by simp
+  show "(N * N\<^sup>T) $$ (i, j) = (int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v> + int (\<r> - \<Lambda>) \<cdot>\<^sub>m 1\<^sub>m \<v>) $$ (i, j)"
+  proof (cases "i = j")
+    case True
+    then have rhs: "(int (\<r> - \<Lambda>) \<cdot>\<^sub>m 1\<^sub>m \<v>) $$ (i, j) = (\<r> - \<Lambda>)" using ilt by fastforce 
+    have "(int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v> + int (\<r> - \<Lambda>) \<cdot>\<^sub>m 1\<^sub>m \<v>) $$ (i, j) = \<Lambda> + (\<r> - \<Lambda>)"
+      using True jlt by auto
+    then have "(int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v> + int (\<r> - \<Lambda>) \<cdot>\<^sub>m 1\<^sub>m \<v>) $$ (i, j) = \<r>" 
+      using reg_index_lt_rep by (simp add: nat_diff_split)
+    then show ?thesis using lhs split rhs True transpose_N_mult_diag ilt jlt by simp
+  next
+    case False
+    then have "(1\<^sub>m \<v>) $$ (i, j) = 0" using ilt jlt by simp
+    then have "(\<r> - \<Lambda>) * ((1\<^sub>m \<v>) $$ (i, j)) = 0" using ilt jlt
+      by (simp add: \<open>1\<^sub>m \<v> $$ (i, j) = 0\<close>) 
+    then show ?thesis using lhs transpose_N_mult_off_diag ilt jlt False by simp
+  qed
+next
+  show "dim_row (N * N\<^sup>T) = dim_row (int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v> + int (\<r> - \<Lambda>) \<cdot>\<^sub>m 1\<^sub>m \<v>)"
+    using transpose_N_mult_dim(1) by auto
+next
+  show "dim_col (N * N\<^sup>T) = dim_col (int \<Lambda> \<cdot>\<^sub>m J\<^sub>m \<v> + int (\<r> - \<Lambda>) \<cdot>\<^sub>m 1\<^sub>m \<v>)"
+    using transpose_N_mult_dim(1) by auto
+qed
+end
+
+locale ordered_bibd = ordered_proper_design \<V>s \<B>s + bibd "set \<V>s" "mset \<B>s" \<k> \<Lambda> 
+  for \<V>s and \<B>s and \<k> and \<Lambda>
+
+sublocale ordered_bibd \<subseteq> ordered_incomplete_design
+  by unfold_locales
+
+sublocale ordered_bibd \<subseteq> ordered_constant_rep \<V>s \<B>s \<r>
+  by unfold_locales
+
+sublocale ordered_bibd \<subseteq> ordered_pairwise_balance
+  by unfold_locales
+
+locale ordered_sym_bibd = ordered_bibd \<V>s \<B>s \<k> \<Lambda> + symmetric_bibd "set \<V>s" "mset \<B>s" \<k> \<Lambda> 
+  for \<V>s and \<B>s and \<k> and \<Lambda>
+
+
+sublocale ordered_sym_bibd \<subseteq> ordered_simple_design
+  by (unfold_locales)
+
+locale ordered_const_intersect_design = ordered_proper_design \<V>s \<B>s + const_intersect_design "set \<V>s" "mset \<B>s" \<m>
+  for \<V>s \<B>s \<m>
+
+
+locale simp_ordered_const_intersect_design = ordered_const_intersect_design + ordered_simple_design
+begin 
+
+lemma max_one_block_size_inter: 
+  assumes "\<b> \<ge> 2"
+  assumes "bl \<in># \<B>"
+  assumes "card bl = \<m>"
+  assumes "bl2 \<in># \<B> - {#bl#}"
+  shows "\<m> < card bl2"
+proof -
+  have sd: "simple_design \<V> \<B>"
+    by (simp add: simple_design_axioms) 
+  have bl2in: "bl2 \<in># \<B>" using assms(4)
+    by (meson in_diffD)
+  have blin: "bl \<in># {#b \<in># \<B> . card b = \<m>#}" using assms(3) assms(2) by simp
+  then have slt: "size {#b \<in># \<B> . card b = \<m>#} = 1" using simple_const_inter_iff sd assms(1)
+    by (metis count_empty count_eq_zero_iff less_one nat_less_le size_eq_0_iff_empty) 
+  then have "size {#b \<in># (\<B> - {#bl#}) . card b = \<m>#} = 0" using blin
+    by (smt (verit) add_mset_eq_singleton_iff count_eq_zero_iff count_filter_mset 
+        filter_mset_add_mset insert_DiffM size_1_singleton_mset size_eq_0_iff_empty) 
+  then have ne: "card bl2 \<noteq> \<m>" using assms(4)
+    by (metis (mono_tags, lifting) filter_mset_empty_conv size_eq_0_iff_empty) 
+  thus ?thesis using inter_num_le_block_size assms bl2in nat_less_le by presburger 
+qed
+
+lemma block_size_inter_num_cases:
+  assumes "bl \<in># \<B>"
+  assumes "\<b> \<ge> 2"
+  shows "\<m> < card bl \<or> (card bl = \<m> \<and> (\<forall> bl' \<in># (\<B> - {#bl#}) . \<m> < card bl'))"
+proof (cases "card bl = \<m>")
+  case True
+  have "(\<And> bl'. bl' \<in># (\<B> - {#bl#}) \<Longrightarrow> \<m> < card bl')"
+    using max_one_block_size_inter True assms by simp
+  then show ?thesis using True by simp
+next
+  case False
+  then have "\<m> < card bl" using assms inter_num_le_block_size nat_less_le by presburger
+  then show ?thesis by simp
+qed
+
+lemma indexed_const_intersect: 
+  assumes "j1 < \<b>"
+  assumes "j2 < \<b>"
+  assumes "j1 \<noteq> j2"
+  shows "(\<B>s ! j1) |\<inter>| (\<B>s ! j2) = \<m>"
+proof -
+  obtain bl1 bl2 where "bl1 \<in># \<B>" and "\<B>s ! j1 = bl1" and "bl2 \<in># \<B> - {#bl1#}" and "\<B>s ! j2 = bl2" 
+    using obtains_two_diff_block_indexes assms by fastforce 
+  thus ?thesis by (simp add: const_intersect)
+qed
+
+lemma const_intersect_block_size_diff: 
+  assumes "j' < \<b>" and "j < \<b>" and "j \<noteq> j'" and "card (\<B>s ! j') = \<m>" and "\<b> \<ge> 2"
+  shows "card (\<B>s ! j) - \<m> > 0"
+proof -
+  obtain bl1 bl2 where "bl1 \<in># \<B>" and "\<B>s ! j' = bl1" and "bl2 \<in># \<B> - {#bl1#}" and "\<B>s ! j = bl2"
+    using assms(1) assms(2) assms(3) obtains_two_diff_block_indexes by fastforce 
+  then have "\<m> < card (bl2)" 
+    using max_one_block_size_inter assms(4) assms(5) by blast  
+  thus ?thesis
+    by (simp add: \<open>\<B>s ! j = bl2\<close>) 
+qed
+
+lemma scalar_prod_inc_vec_const_inter: 
+  assumes "j1 < \<b>" "j2 < \<b>" "j1 \<noteq> j2"
+  shows "(col N j1) \<bullet> (col N j2) = \<m>"
+  using scalar_prod_inc_vec_inter_num indexed_const_intersect assms by simp
+
+end
+
+subsection \<open> Zero One Matrix Incidence System Existence \<close>
+text \<open>We prove 0-1 matrices with certain properties imply the existence of an incidence system
+with particular properties. This leads to Stinson's theorem in the other direction \cite{stinsonCombinatorialDesignsConstructions2004} \<close>
+
+context zero_one_matrix
+begin
+
+lemma mat_is_ordered_incidence_sys: "ordered_incidence_system [0..<(dim_row M)] (map (map_col_to_block) (cols M))"
+  apply (unfold_locales, simp_all)
+  using map_col_to_block_wf atLeastLessThan_upt by blast
+
+interpretation mat_ord_inc_sys: ordered_incidence_system "[0..<(dim_row M)]" "(map (map_col_to_block) (cols M))"
+  by (simp add: mat_is_ordered_incidence_sys)
+
+lemma mat_ord_inc_sys_N: "mat_ord_inc_sys.N = lift_01_mat M" 
+  by (intro eq_matI, simp_all add: inc_mat_of_def map_col_to_block_elem) 
+    (metis lift_01_mat_simp(3) lift_mat_01_index_iff(2) of_zero_neq_one_def)
+
+lemma map_col_to_block_mat_rep_num:
+  assumes "x <dim_row M"
+  shows "({# map_col_to_block c . c \<in># mset (cols M)#} rep x) = mat_rep_num M x"
+proof -
+  have "mat_rep_num M x = mat_rep_num (lift_01_mat M) x" 
+    using preserve_mat_rep_num mat_ord_inc_sys_N
+    by (metis assms lift_01_mat_def of_inj_on_01_hom.inj_on_01_hom_axioms)
+  then have "mat_rep_num M x = (mat_rep_num mat_ord_inc_sys.N x)" using mat_ord_inc_sys_N by (simp) 
+  then have "mat_rep_num M x = mset (map (map_col_to_block) (cols M)) rep x"
+    using assms atLeastLessThan_upt card_atLeastLessThan mat_ord_inc_sys.mat_rep_num_N_row 
+      mat_ord_inc_sys_point minus_nat.diff_0 by presburger
+  thus ?thesis using ordered_to_mset_col_blocks
+    by presburger 
+qed
+
+end 
+
+context zero_one_matrix_ring_1
+begin
+
+lemma transpose_cond_index_vals: 
+  assumes "M * (M\<^sup>T) = \<Lambda> \<cdot>\<^sub>m (J\<^sub>m (dim_row M)) + (r - \<Lambda>) \<cdot>\<^sub>m (1\<^sub>m (dim_row M))"
+  assumes "i < dim_row (M * (M\<^sup>T))"
+  assumes "j < dim_col (M * (M\<^sup>T))"
+  shows "i = j \<Longrightarrow> (M * (M\<^sup>T)) $$ (i, j) = r" "i \<noteq> j \<Longrightarrow> (M * (M\<^sup>T)) $$ (i, j) = \<Lambda>"
+  using assms by auto
+
+end
+
+locale zero_one_matrix_int = zero_one_matrix_ring_1 M for M :: "int mat"
+begin
+
+text \<open>Some useful conditions on the transpose product for matrix system properties \<close>
+lemma transpose_cond_diag_r:
+  assumes "i < dim_row (M * (M\<^sup>T))"
+  assumes "\<And> j. i = j \<Longrightarrow> (M * (M\<^sup>T)) $$ (i, j) = r"
+  shows "mat_rep_num M i = r"
+proof -
+  have eqr: "(M * M\<^sup>T) $$ (i, i) = r" using assms(2)
+    by simp
+  have unsq: "\<And> k . k < dim_col M \<Longrightarrow> (M $$ (i, k))^2 = M $$ (i, k)"
+    using assms elems01 by fastforce
+  have "sum_vec (row M i) = (\<Sum>k \<in>{0..<(dim_col M)} . (row M i) $ k)"
+    using assms by (simp add: sum_vec_def)
+  also have "... = (\<Sum>k \<in>{0..<(dim_col M)} . M $$ (i, k))"
+    using assms by auto
+  also have "... = (\<Sum>k \<in>{0..<(dim_col M)} . M $$ (i, k)^2)"
+    using atLeastLessThan_iff sum.cong unsq by simp
+  also have "... = (\<Sum>k \<in>{0..<(dim_col M)} . M $$ (i, k) * M $$ (i, k))"
+    using assms by (simp add: power2_eq_square)
+  also have "... = (M * M\<^sup>T) $$ (i, i)" 
+    using assms transpose_mat_mult_entries[of "i" "M" "i"] by simp
+  finally have "sum_vec (row M i) = r" using eqr by simp
+  thus ?thesis using mat_rep_num_sum_alt
+    by (metis assms(1) elems01 index_mult_mat(2) of_nat_eq_iff) 
+qed
+
+
+lemma transpose_cond_non_diag:
+  assumes "i1 < dim_row (M * (M\<^sup>T))"
+  assumes "i2 < dim_row (M * (M\<^sup>T))"
+  assumes "i1 \<noteq> i2"
+  assumes "\<And> j i. j \<noteq> i \<Longrightarrow> i < dim_row (M * (M\<^sup>T)) \<Longrightarrow> j < dim_row (M * (M\<^sup>T)) \<Longrightarrow> (M * (M\<^sup>T)) $$ (i, j) = \<Lambda>"
+  shows "\<Lambda> = mat_point_index M {i1, i2}"
+proof -
+  have ilt: "i1 < dim_row M" "i2 < dim_row M"
+    using assms(1) assms (2) by auto
+  have rev: "\<And> k. k \<in> {0..<dim_col M} \<Longrightarrow> 
+      \<not> (M $$ (i1, k) = 1 \<and> M $$ (i2, k) = 1) \<longleftrightarrow> M $$ (i1, k) = 0 \<or> M $$ (i2, k) = 0"
+    using assms elems01 by fastforce 
+  then have split: "{0..<dim_col M} = {k \<in> {0..<dim_col M}. M $$ (i1, k) = 1 \<and> M $$ (i2, k) = 1} \<union> 
+      {k \<in> {0..<dim_col M}. M $$ (i1, k) = 0 \<or> M $$ (i2, k) = 0}"
+    by blast
+  have zero: "\<And> k . k \<in> {0..<dim_col M} \<Longrightarrow> M $$ (i1, k) = 0 \<or> M $$ (i2, k) = 0 \<Longrightarrow> M $$ (i1, k) * M$$ (i2, k) = 0"
+    by simp 
+  have djnt: "{k \<in> {0..<dim_col M}. M $$ (i1, k) = 1 \<and> M $$ (i2, k) = 1} \<inter> 
+      {k \<in> {0..<dim_col M}. M $$ (i1, k) = 0 \<or> M $$ (i2, k) = 0} = {}" 
+    using rev by auto
+  have fin1: "finite {k \<in> {0..<dim_col M}. M $$ (i1, k) = 1 \<and> M $$ (i2, k) = 1}" by simp
+  have fin2: "finite {k \<in> {0..<dim_col M}. M $$ (i1, k) = 0 \<or> M $$ (i2, k) = 0}" by simp
+  have "mat_point_index M {i1, i2} = card {k' \<in> {0..<dim_col M}. M $$ (i1, k') = 1 \<and>M $$ (i2, k') = 1}"
+    using mat_point_index_two_alt ilt assms(3) by auto
+  then have "mat_point_index M {i1, i2} = 
+    (\<Sum>k \<in>{k' \<in> {0..<dim_col M}. M $$ (i1, k') = 1 \<and> M $$ (i2, k') = 1} . M $$ (i1, k) * M $$ (i2, k)) + 
+    (\<Sum>k \<in>{k' \<in> {0..<dim_col M}. M $$ (i1, k') = 0 \<or> M $$ (i2, k') = 0} . M $$ (i1, k) * M $$ (i2, k))"
+    by (simp add: zero) (* Odd behaviour if I use also have here *)
+  also have "... = (\<Sum>k \<in>({k' \<in> {0..<dim_col M}. M $$ (i1, k') = 1 \<and> M $$ (i2, k') = 1} \<union> 
+    {k' \<in> {0..<dim_col M}. M $$ (i1, k') = 0 \<or> M $$ (i2, k') = 0}) . M $$ (i1, k) * M $$ (i2, k))"
+    using fin1 fin2 djnt sum.union_disjoint by (metis (no_types, lifting)) 
+  also have "... =  (\<Sum>k \<in>{0..<dim_col M} . M $$ (i1, k) * M $$ (i2, k))"
+    using split by metis
+  finally have "mat_point_index M {i1, i2} = (M * (M\<^sup>T)) $$ (i1, i2)"
+    using assms(1) assms(2) transpose_mat_mult_entries[of "i1" "M" "i2"] by simp
+  thus ?thesis using assms by presburger 
+qed
+
+lemma trans_cond_implies_map_rep_num:
+  assumes "M * (M\<^sup>T) = \<Lambda> \<cdot>\<^sub>m (J\<^sub>m (dim_row M)) + (r - \<Lambda>) \<cdot>\<^sub>m (1\<^sub>m (dim_row M))"
+  assumes "x < dim_row M"
+  shows "(image_mset map_col_to_block (mset (cols M))) rep x = r"
+proof -
+  interpret ois: ordered_incidence_system "[0..<dim_row M]" "map map_col_to_block (cols M)"
+    using mat_is_ordered_incidence_sys by simp
+  have eq: "ois.\<B> rep x = sum_vec (row M x)" using ois.point_rep_mat_row_sum
+    by (simp add: assms(2) inc_mat_of_map_rev) 
+  then have "\<And> j. x = j \<Longrightarrow> (M * (M\<^sup>T)) $$ (x, j) = r" using assms(1) transpose_cond_index_vals
+    by (metis assms(2) index_mult_mat(2) index_mult_mat(3) index_transpose_mat(3)) 
+  thus ?thesis using eq transpose_cond_diag_r assms(2) index_mult_mat(2)
+    by (metis map_col_to_block_mat_rep_num) 
+qed
+
+lemma trans_cond_implies_map_index:
+  assumes "M * (M\<^sup>T) = \<Lambda> \<cdot>\<^sub>m (J\<^sub>m (dim_row M)) + (r - \<Lambda>) \<cdot>\<^sub>m (1\<^sub>m (dim_row M))"
+  assumes "ps \<subseteq> {0..<dim_row M}"
+  assumes "card ps = 2"
+  shows "(image_mset map_col_to_block (mset (cols M))) index ps = \<Lambda>"
+proof - 
+  interpret ois: ordered_incidence_system "[0..<dim_row M]" "map map_col_to_block (cols M)"
+    using mat_is_ordered_incidence_sys by simp
+  obtain i1 i2 where i1in: "i1 <dim_row M" and i2in: "i2 <dim_row M" and psis: "ps = {i1, i2}" and neqi: "i1 \<noteq> i2"
+    using assms(2) assms(3) card_2_iff insert_subset by (metis atLeastLessThan_iff) 
+  have cond: "\<And> j i. j \<noteq> i \<Longrightarrow> i < dim_row (M * (M\<^sup>T)) \<Longrightarrow> j < dim_row (M * (M\<^sup>T)) \<Longrightarrow> (M * (M\<^sup>T)) $$ (i, j) = \<Lambda>"
+    using assms(1) by simp
+  then have "(image_mset map_col_to_block (mset (cols M))) index ps = mat_point_index M ps"
+     using ois.incidence_mat_two_index psis i1in i2in by (simp add: neqi inc_mat_of_map_rev)
+  thus ?thesis using cond transpose_cond_non_diag[of i1 i2 \<Lambda>] i1in i2in index_mult_mat(2)[of "M" "M\<^sup>T"] 
+       neqi of_nat_eq_iff psis by simp
+qed
+
+text \<open> Stinson Theorem 1.15 existence direction \<close>
+lemma rpbd_exists: 
+  assumes "dim_row M \<ge> 2" \<comment> \<open>Min two points\<close>
+  assumes "dim_col M \<ge> 1" \<comment> \<open>Min one block\<close>
+  assumes "\<And> j. j < dim_col M \<Longrightarrow> 1 \<in>$ col M j" \<comment> \<open>no empty blocks \<close>
+  assumes "M * (M\<^sup>T) = \<Lambda> \<cdot>\<^sub>m (J\<^sub>m (dim_row M)) + (r - \<Lambda>) \<cdot>\<^sub>m (1\<^sub>m (dim_row M))"
+  shows "ordered_regular_pairwise_balance [0..<dim_row M] (map map_col_to_block (cols M)) \<Lambda> r"
+proof -
+  interpret ois: ordered_incidence_system "[0..<dim_row M]" "(map map_col_to_block (cols M))"
+    using mat_is_ordered_incidence_sys by simp
+  interpret pdes: ordered_design "[0..<dim_row M]" "(map map_col_to_block (cols M))"
+    using assms(2) mat_is_design assms(3)
+    by (simp add: ordered_design_def ois.ordered_incidence_system_axioms)  
+  show ?thesis using assms trans_cond_implies_map_index trans_cond_implies_map_rep_num 
+    by (unfold_locales) (simp_all)
+qed
+
+lemma vec_k_uniform_mat_block_size: 
+  assumes "((u\<^sub>v (dim_row M)) \<^sub>v* M) = k \<cdot>\<^sub>v (u\<^sub>v (dim_col M))"
+  assumes "j < dim_col M"
+  shows "mat_block_size M j = k"
+proof -
+  have "mat_block_size M j = sum_vec (col M j)" using assms(2)
+    by (simp add: elems01 mat_block_size_sum_alt) 
+  also have "... = ((u\<^sub>v (dim_row M)) \<^sub>v* M) $ j" using assms(2) 
+    by (simp add: sum_vec_def scalar_prod_def)
+  finally show ?thesis using  assms(1) assms(2) by (simp)
+qed
+
+lemma vec_k_impl_uniform_block_size: 
+  assumes "((u\<^sub>v (dim_row M)) \<^sub>v* M) = k \<cdot>\<^sub>v (u\<^sub>v (dim_col M))"
+  assumes "bl \<in># (image_mset map_col_to_block (mset (cols M)))"
+  shows "card bl = k"
+proof -
+  obtain j where jlt: "j < dim_col M" and bleq: "bl = map_col_to_block (col M j)"
+    using assms(2) obtain_block_index_map_block_set by blast 
+  then have "card (map_col_to_block (col M j)) = mat_block_size M j"
+    by (simp add: map_col_to_block_size) 
+  thus ?thesis using vec_k_uniform_mat_block_size assms(1) bleq jlt by blast 
+qed
+
+lemma bibd_exists: 
+  assumes "dim_col M \<ge> 1" \<comment> \<open>Min one block\<close>
+  assumes "\<And> j. j < dim_col M \<Longrightarrow> 1 \<in>$ col M j" \<comment> \<open>no empty blocks \<close>
+  assumes "M * (M\<^sup>T) = \<Lambda> \<cdot>\<^sub>m (J\<^sub>m (dim_row M)) + (r - \<Lambda>) \<cdot>\<^sub>m (1\<^sub>m (dim_row M))"
+  assumes "((u\<^sub>v (dim_row M)) \<^sub>v* M) = k \<cdot>\<^sub>v (u\<^sub>v (dim_col M))"
+  assumes "(r ::nat) \<ge> 0"
+  assumes "k \<ge> 2" "k < dim_row M"
+  shows "ordered_bibd [0..<dim_row M] (map map_col_to_block (cols M)) k \<Lambda>"
+proof -
+  interpret ipbd: ordered_regular_pairwise_balance "[0..<dim_row M]" "(map map_col_to_block (cols M))" \<Lambda> r
+    using rpbd_exists assms by simp
+  show ?thesis using vec_k_impl_uniform_block_size by (unfold_locales, simp_all add: assms)
+qed
+
+end
+
+subsection \<open>Isomorphisms and Incidence Matrices \<close>
+text \<open>If two incidence systems have the same incidence matrix, they are isomorphic. Similarly
+if two incidence systems are isomorphic there exists an ordering such that they have the same
+incidence matrix \<close>
+locale two_ordered_sys = D1: ordered_incidence_system \<V>s \<B>s + D2: ordered_incidence_system \<V>s' \<B>s'
+  for "\<V>s" and "\<B>s" and "\<V>s'" and "\<B>s'" 
+
+begin
+
+lemma equal_inc_mat_isomorphism: 
+  assumes "D1.N = D2.N"
+  shows "incidence_system_isomorphism D1.\<V> D1.\<B> D2.\<V> D2.\<B> (\<lambda> x . \<V>s' ! (List_Index.index \<V>s x))"
+proof (unfold_locales)
+  show "bij_betw (\<lambda>x. \<V>s' ! List_Index.index \<V>s x) D1.\<V> D2.\<V>" 
+  proof -
+    have comp: "(\<lambda>x. \<V>s' ! List_Index.index \<V>s x) = (\<lambda> i. \<V>s' ! i) \<circ> (\<lambda> y . List_Index.index \<V>s y)"
+      by (simp add: comp_def)
+    have leq: "length \<V>s = length \<V>s'" 
+      using assms D1.dim_row_is_v D1.points_list_length D2.dim_row_is_v D2.points_list_length by force 
+    have bij1: "bij_betw (\<lambda> i. \<V>s' !i) {..<length \<V>s} (set \<V>s') " using leq
+      by (simp add: bij_betw_nth D2.distinct) 
+    have "bij_betw (List_Index.index \<V>s) (set \<V>s) {..<length \<V>s}" using D1.distinct
+      by (simp add: bij_betw_index lessThan_atLeast0) 
+    thus ?thesis using bij_betw_trans comp bij1 by simp
+  qed
+next
+  have len:  "length (map ((`) (\<lambda>x. \<V>s' ! List_Index.index \<V>s x)) \<B>s) = length \<B>s'"
+    using length_map assms D1.dim_col_is_b by force 
+  have mat_eq: "\<And> i j . D1.N $$ (i, j) = D2.N $$ (i, j)" using assms
+    by simp 
+  have vslen: "length \<V>s = length \<V>s'" using assms
+      using D1.dim_row_is_v D1.points_list_length D2.dim_row_is_v D2.points_list_length by force 
+  have "\<And> j. j < length \<B>s' \<Longrightarrow> (map ((`) (\<lambda>x. \<V>s' ! List_Index.index \<V>s x)) \<B>s) ! j = \<B>s' ! j"
+  proof -
+    fix j assume a: "j < length \<B>s'" 
+    then have "(map ((`) (\<lambda>x. \<V>s' ! List_Index.index \<V>s x)) \<B>s) ! j = (\<lambda>x. \<V>s' ! List_Index.index \<V>s x) ` (\<B>s ! j)"
+      by (metis D1.blocks_list_length D1.dim_col_is_b D2.blocks_list_length D2.dim_col_is_b assms nth_map) 
+    also have "... = (\<lambda> i . \<V>s' ! i) ` ((\<lambda> x. List_Index.index \<V>s x) ` (\<B>s ! j))" 
+      by blast
+    also have "... = ((\<lambda> i . \<V>s' ! i) ` {i . i < length \<V>s \<and> D1.N $$ (i, j) = 1})" 
+      using D1.block_mat_cond_rev a assms
+      by (metis (no_types, lifting) D1.blocks_list_length D1.dim_col_is_b D2.blocks_list_length D2.dim_col_is_b) 
+    also have "... = ((\<lambda> i . \<V>s' ! i) ` {i . i < length \<V>s' \<and> D2.N $$ (i, j) = 1})" 
+      using vslen mat_eq by simp
+    finally have "(map ((`) (\<lambda>x. \<V>s' ! List_Index.index \<V>s x)) \<B>s) ! j = (\<B>s' ! j)" 
+      using D2.block_mat_cond_rep' a by presburger
+    then show "(map ((`) (\<lambda>x. \<V>s' ! List_Index.index \<V>s x)) \<B>s) ! j = (\<B>s' ! j)" by simp
+  qed
+  then have "map ((`) (\<lambda>x. \<V>s' ! List_Index.index \<V>s x)) \<B>s = \<B>s'" 
+    using len nth_equalityI[of "(map ((`) (\<lambda>x. \<V>s' ! List_Index.index \<V>s x)) \<B>s)" "\<B>s'"] by simp
+  then show "image_mset ((`) (\<lambda>x. \<V>s' ! List_Index.index \<V>s x)) D1.\<B> = D2.\<B>"
+    using mset_map by auto
+qed
+
+lemma equal_inc_mat_isomorphism_ex: "D1.N = D2.N \<Longrightarrow> \<exists> \<pi> . incidence_system_isomorphism D1.\<V> D1.\<B> D2.\<V> D2.\<B> \<pi>"
+  using equal_inc_mat_isomorphism by auto 
+
+lemma equal_inc_mat_isomorphism_obtain: 
+  assumes "D1.N = D2.N"
+  obtains \<pi> where "incidence_system_isomorphism D1.\<V> D1.\<B> D2.\<V> D2.\<B> \<pi>"
+  using equal_inc_mat_isomorphism assms by auto 
+
+end
+
+context incidence_system_isomorphism
+begin
+
+lemma exists_eq_inc_mats:
+  assumes "finite \<V>" "finite \<V>'"
+  obtains N where "is_incidence_matrix N \<V> \<B>" and "is_incidence_matrix N \<V>' \<B>'"
+proof -
+  obtain Vs where vsis: "Vs \<in> permutations_of_set \<V>" using assms
+    by (meson all_not_in_conv permutations_of_set_empty_iff) 
+  obtain Bs where bsis: "Bs \<in> permutations_of_multiset \<B>"
+    by (meson all_not_in_conv permutations_of_multiset_not_empty) 
+  have inj: "inj_on \<pi> \<V>" using bij
+    by (simp add: bij_betw_imp_inj_on) 
+  then have mapvs: "map \<pi> Vs \<in> permutations_of_set \<V>'" using permutations_of_set_image_inj
+    using \<open>Vs \<in> permutations_of_set \<V>\<close> iso_points_map by blast 
+  have "permutations_of_multiset (image_mset ((`)\<pi>) \<B>) = map ((`) \<pi>) ` permutations_of_multiset \<B>"
+    using block_img permutations_of_multiset_image by blast 
+  then have mapbs: "map ((`) \<pi>) Bs \<in> permutations_of_multiset \<B>'" using bsis block_img by blast 
+  define N :: "'c :: {ring_1} mat" where "N \<equiv> inc_mat_of Vs Bs" 
+  have "is_incidence_matrix N \<V> \<B>"
+    using N_def bsis is_incidence_matrix_def vsis by blast
+  have "\<And> bl . bl \<in> (set Bs) \<Longrightarrow> bl \<subseteq> (set Vs)"
+    by (meson bsis in_multiset_in_set ordered_incidence_system.wf_list source.alt_ordering_sysI vsis) 
+  then have "N = inc_mat_of (map \<pi> Vs) (map ((`) \<pi>) Bs)" 
+    using inc_mat_of_bij_betw inj
+    by (metis N_def permutations_of_setD(1) vsis) 
+  then have "is_incidence_matrix N \<V>' \<B>'"
+    using mapbs mapvs is_incidence_matrix_def by blast 
+  thus ?thesis
+    using \<open>is_incidence_matrix N \<V> \<B>\<close> that by auto 
+qed
+
+end
+
+end
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/Linear_Bound_Argument.thy b/thys/Fishers_Inequality/Linear_Bound_Argument.thy
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/Linear_Bound_Argument.thy
@@ -0,0 +1,161 @@
+(* Title: Linear_Bound_Argument.thy
+   Author: Chelsea Edmonds
+*)
+section \<open>Linear Bound Argument - General \<close>
+text \<open>Lemmas to enable general reasoning using the linear bound argument for combinatorial proofs.
+Jukna \cite{juknaExtremalCombinatorics2011} presents a good overview of the mathematical background 
+this theory is based on and applications \<close>
+theory Linear_Bound_Argument imports Incidence_Matrices Jordan_Normal_Form.DL_Rank 
+Jordan_Normal_Form.Ring_Hom_Matrix
+begin
+
+subsection \<open>Vec Space Extensions\<close>
+text \<open>Simple extensions to the existing vector space locale on linear independence \<close>
+context vec_space
+begin 
+lemma lin_indpt_set_card_lt_dim: 
+  fixes A :: "'a vec set"
+  assumes "A \<subseteq> carrier_vec n"
+  assumes "lin_indpt A"
+  shows "card A \<le> dim"
+  using assms(1) assms(2) fin_dim li_le_dim(2) by blast
+
+lemma lin_indpt_dim_col_lt_dim: 
+  fixes A :: "'a mat"
+  assumes "A \<in> carrier_mat n nc"
+  assumes "distinct (cols A)"
+  assumes "lin_indpt (set (cols A))"
+  shows "nc \<le> dim"
+proof -
+  have b: "card (set (cols A)) = dim_col A" using cols_length assms(2)
+    by (simp add: distinct_card) 
+  have "set (cols A) \<subseteq> carrier_vec n" using assms(1) cols_dim by blast
+  thus ?thesis using lin_indpt_set_card_lt_dim assms b by auto
+qed
+
+lemma lin_comb_imp_lin_dep_fin: 
+  fixes A :: "'a vec set"
+  assumes "finite A"
+  assumes "A \<subseteq> carrier_vec n"
+  assumes "lincomb c A = 0\<^sub>v n"
+  assumes "\<exists> a. a \<in> A \<and> c a \<noteq> 0"
+  shows "lin_dep A"
+  unfolding lin_dep_def using assms lincomb_as_lincomb_list_distinct sumlist_nth by auto
+
+text \<open>While a trivial definition, this enables us to directly reference the definition outside
+of a locale context, as @{term "lin_indpt"} is an inherited definition \<close>
+definition lin_indpt_vs:: "'a vec set \<Rightarrow> bool" where
+"lin_indpt_vs A \<longleftrightarrow> lin_indpt A"
+
+lemma lin_comb_sum_lin_indpt: 
+  fixes A :: "'a vec list"
+  assumes "set (A) \<subseteq> carrier_vec n"
+  assumes "distinct A"
+  assumes "\<And> f. lincomb_list (\<lambda>i. f (A ! i)) A = 0\<^sub>v n \<Longrightarrow> \<forall>v\<in> (set A). f v = 0"
+  shows "lin_indpt (set A)"
+  by (rule finite_lin_indpt2, auto simp add: assms lincomb_as_lincomb_list_distinct)
+
+lemma lin_comb_mat_lin_indpt: 
+  fixes A :: "'a vec list"
+  assumes "set (A) \<subseteq> carrier_vec n"
+  assumes "distinct A"
+  assumes "\<And> f. mat_of_cols n A *\<^sub>v vec (length A) (\<lambda>i. f (A ! i))  = 0\<^sub>v n \<Longrightarrow> \<forall>v\<in> (set A). f v = 0"
+  shows "lin_indpt (set A)"
+proof (rule lin_comb_sum_lin_indpt, auto simp add: assms)
+  fix f v 
+  have "\<And> v. v \<in> set A \<Longrightarrow> dim_vec v = n"
+    using assms by auto
+  then show "lincomb_list (\<lambda>i. f (A ! i)) A = 0\<^sub>v n \<Longrightarrow> v \<in> set A \<Longrightarrow> f v = 0"
+    using  lincomb_list_as_mat_mult[of A "(\<lambda>i. f (A ! i))"] assms(3)[of f] by auto
+qed
+
+lemma lin_comb_mat_lin_indpt_vs: 
+  fixes A :: "'a vec list"
+  assumes "set (A) \<subseteq> carrier_vec n"
+  assumes "distinct A"
+  assumes "\<And> f. mat_of_cols n A *\<^sub>v vec (length A) (\<lambda>i. f (A ! i))  = 0\<^sub>v n \<Longrightarrow> \<forall>v\<in> (set A). f v = 0"
+  shows "lin_indpt_vs (set A)"
+  using lin_comb_mat_lin_indpt lin_indpt_vs_def assms by auto
+
+
+end
+
+subsection \<open>Linear Bound Argument Lemmas\<close>
+
+text \<open>Three general representations of the linear bound argument, requiring a direct fact of 
+linear independence onthe rows of the vector space over either a set A of vectors, list xs of vectors
+or a Matrix' columns \<close>
+lemma lin_bound_arg_general_set: 
+  fixes A ::"('a :: {field})vec set"
+  assumes "A \<subseteq> carrier_vec nr"
+  assumes "vec_space.lin_indpt_vs nr A"
+  shows "card A \<le> nr"
+  using vec_space.lin_indpt_set_card_lt_dim[of "A" "nr"] vec_space.lin_indpt_vs_def[of nr A] 
+    vec_space.dim_is_n assms by metis 
+
+lemma lin_bound_arg_general_list: 
+  fixes xs ::"('a :: {field})vec list"
+  assumes "distinct xs"
+  assumes "(set xs) \<subseteq> carrier_vec nr"
+  assumes "vec_space.lin_indpt_vs nr (set xs)"
+  shows "length (xs) \<le> nr"
+  using lin_bound_arg_general_set[of "set xs" nr] distinct_card assms
+  by force 
+
+lemma lin_bound_arg_general: 
+  fixes A ::"('a :: {field}) mat"
+  assumes "distinct (cols A)"
+  assumes "A \<in> carrier_mat nr nc"
+  assumes "vec_space.lin_indpt_vs nr (set (cols A))"
+  shows "nc \<le> nr"
+proof -
+  have ss: "set (cols A) \<subseteq> carrier_vec nr" using assms cols_dim by blast 
+  have "length (cols A) = nc"
+    using assms(2) cols_length by blast 
+  thus ?thesis using lin_bound_arg_general_list[of "cols A" "nr"] ss assms by simp
+qed
+
+text\<open>The linear bound argument lemma on a matrix requiring the lower level assumption on a linear
+combination. This removes the need to directly refer to any aspect of the linear algebra libraries \<close>
+lemma lin_bound_argument: 
+  fixes A :: "('a :: {field}) mat"
+  assumes "distinct (cols A)"
+  assumes "A \<in> carrier_mat nr nc"
+  assumes "\<And> f. A *\<^sub>v vec nc (\<lambda>i. f (col A i)) = 0\<^sub>v nr \<Longrightarrow> \<forall>v\<in> (set (cols A)). f v = 0"
+  shows "nc \<le> nr"
+proof (intro lin_bound_arg_general[of "A" nr nc] vec_space.lin_comb_mat_lin_indpt_vs, simp_all add: assms)
+  show "set (cols A) \<subseteq> carrier_vec nr" using assms cols_dim by blast
+next
+  have mA: "mat_of_cols nr (cols A) = A" using mat_of_cols_def assms by auto
+  have "\<And> f. vec (dim_col A) (\<lambda>i. f (cols A ! i)) = vec nc (\<lambda>i. f (col A i))"
+  proof (intro eq_vecI, simp_all add: assms)
+    show "\<And>f i. i < nc \<Longrightarrow> vec (dim_col A) (\<lambda>i. f (cols A ! i)) $ i = f (col A i)"
+      using assms(2) by force
+    show "dim_col A = nc " using assms by simp
+  qed
+  then show "\<And>f. mat_of_cols nr (cols A) *\<^sub>v vec (dim_col A) (\<lambda>i. f (cols A ! i)) = 0\<^sub>v nr \<Longrightarrow> 
+      \<forall>v\<in>set (cols A). f v = 0"
+    using mA assms(3) by metis
+qed
+
+text \<open>A further extension to present the linear combination directly as a sum. This manipulation from 
+vector product to a summation was found to commonly be repeated in proofs applying this rule \<close>
+lemma lin_bound_argument2: 
+  fixes A :: "('a :: {field}) mat"
+  assumes "distinct (cols A)"
+  assumes "A \<in> carrier_mat nr nc"
+  assumes "\<And> f. vec nr (\<lambda>i. \<Sum> j \<in> {0..<nc} . f (col A j) * (col A j) $ i) = 0\<^sub>v nr \<Longrightarrow> 
+    \<forall>v\<in> (set (cols A)). f v = 0"
+  shows "nc \<le> nr"
+proof (intro lin_bound_argument[of A nr nc], simp add: assms, simp add: assms)
+  fix f 
+  have "A *\<^sub>v vec nc (\<lambda>i. f (col A i)) = 
+      vec (dim_row A) (\<lambda>i. \<Sum> j \<in> {0..<nc} . (row A i $ j) * f (col A j))"
+    by (auto simp add: mult_mat_vec_def scalar_prod_def assms(2)) 
+  also have "... = vec (dim_row A) (\<lambda>i. \<Sum> j \<in> {0..<nc} . f (col A j) * (col A j $ i))"
+    using assms(2) by (intro eq_vecI, simp_all) (meson mult.commute) 
+  finally show "A *\<^sub>v vec nc (\<lambda>i. f (col A i)) = 0\<^sub>v nr \<Longrightarrow> \<forall>v\<in>set (cols A). f v = 0" 
+    using assms(3)[of f] assms(2) by fastforce 
+qed
+
+end
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/Matrix_Vector_Extras.thy b/thys/Fishers_Inequality/Matrix_Vector_Extras.thy
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/Matrix_Vector_Extras.thy
@@ -0,0 +1,775 @@
+(* Title: Matrix_Vector_Extras.thy 
+   Author: Chelsea Edmonds
+*)
+section \<open> Matrix and Vector Additions \<close>
+
+theory Matrix_Vector_Extras imports Set_Multiset_Extras Jordan_Normal_Form.Matrix 
+Design_Theory.Multisets_Extras "Groebner_Bases.Macaulay_Matrix" "Polynomial_Factorization.Missing_List"
+begin
+
+
+subsection \<open>Vector Extras\<close>
+text \<open>For ease of use, a number of additions to the existing vector library as initially developed
+in the JNF AFP Entry, are given below\<close>
+
+text \<open>We define the concept of summing up elements of a vector \<close>
+
+definition (in comm_monoid_add) sum_vec :: "'a vec \<Rightarrow> 'a" where
+"sum_vec v \<equiv> sum (\<lambda> i . v $ i) {0..<dim_vec v}"
+
+lemma sum_vec_vNil[simp]: "sum_vec vNil = 0"
+  by (simp add: sum_vec_def)
+
+lemma sum_vec_vCons: "sum_vec (vCons a v) = a + sum_vec v"
+proof -
+  have 0: "a = (vCons a v) $ 0"
+    by simp 
+  have "sum_vec v = sum (\<lambda> i . v $ i) {0..<dim_vec v}" by (simp add: sum_vec_def)
+  also have "... = sum (\<lambda> i . (vCons a v) $ Suc i) {0..< dim_vec v}"
+    by force
+  also have "... = sum (\<lambda> i . (vCons a v) $ i) {Suc 0..< (Suc (dim_vec v))}"
+    by (metis sum.shift_bounds_Suc_ivl)  
+  finally have sum: "sum_vec v = sum (\<lambda> i . (vCons a v) $ i) {Suc 0..< dim_vec (vCons a v)}" by simp
+  have "sum_vec (vCons a v) = sum (\<lambda> i . (vCons a v) $ i){0..< dim_vec (vCons a v)}" 
+    by (simp add: sum_vec_def)
+  then have "sum_vec (vCons a v) = (vCons a v) $ 0 + sum (\<lambda> i . (vCons a v) $ i){Suc 0..< dim_vec (vCons a v)}"
+    by (metis dim_vec_vCons sum.atLeast_Suc_lessThan zero_less_Suc) 
+  thus ?thesis using sum 0 by simp
+qed
+
+lemma sum_vec_list: "sum_list (list_of_vec v) = sum_vec v"
+  by (induct v)(simp_all add: sum_vec_vCons)
+
+lemma sum_vec_mset: "sum_vec v = (\<Sum> x \<in># (mset (list_of_vec v)) . x)"
+  by (simp add: sum_vec_list)
+
+lemma dim_vec_vCons_ne_0: "dim_vec (vCons a v) > 0"
+  by (cases v) simp_all
+
+lemma sum_vec_vCons_lt: 
+  assumes "\<And> i. i < dim_vec (vCons a v) \<Longrightarrow> (vCons a v) $ i \<le> (n ::int)"
+  assumes "sum_vec v \<le> m"
+  shows "sum_vec (vCons a v) \<le> n + m"
+proof -
+  have split: "sum_vec (vCons a v) = a + sum_vec v" by (simp add: sum_vec_vCons)
+  have a: "(vCons a v) $ 0 = a" by simp
+  then have "0 < dim_vec (vCons a v)" using dim_vec_vCons_ne_0 by simp
+  then have "a \<le> n" using assms by (metis a) 
+  thus ?thesis using split assms
+    by (simp add: add_mono) 
+qed
+
+lemma sum_vec_one_zero: 
+  assumes "\<And> i. i < dim_vec (v :: int vec) \<Longrightarrow> v $ i \<le> (1 ::int)"
+  shows "sum_vec v \<le> dim_vec v"
+  using assms 
+proof (induct v)
+  case vNil
+  then show ?case by simp
+next
+  case (vCons a v)
+  then have "(\<And> i. i < dim_vec v \<Longrightarrow> v $ i \<le> (1 ::int))"
+    using vCons.prems by force
+  then have lt: "sum_vec v \<le> int (dim_vec v)" by (simp add: vCons.hyps)  
+  then show ?case using sum_vec_vCons_lt lt vCons.prems by simp
+qed
+
+text \<open>Definition to convert a vector to a multiset \<close>
+
+definition vec_mset:: "'a vec \<Rightarrow> 'a multiset" where
+"vec_mset v \<equiv> image_mset (vec_index v) (mset_set {..<dim_vec v})"
+
+lemma vec_elem_exists_mset: "(\<exists> i \<in> {..<dim_vec v}. v $ i = x) \<longleftrightarrow> x \<in># vec_mset v"
+  by (auto simp add: vec_mset_def)
+
+lemma mset_vec_same_size: "dim_vec v = size (vec_mset v)"
+  by (simp add: vec_mset_def)
+
+lemma mset_vec_eq_mset_list: "vec_mset v = mset (list_of_vec v)"
+  by (auto simp add: vec_mset_def)
+  (metis list_of_vec_map mset_map mset_set_upto_eq_mset_upto)
+
+lemma vec_mset_img_map: "image_mset f (mset (xs)) = vec_mset (map_vec f (vec_of_list xs))"
+  by (metis list_vec mset_map mset_vec_eq_mset_list vec_of_list_map)
+
+lemma vec_mset_vNil: "vec_mset vNil = {#}" 
+  by (simp add: vec_mset_def)
+
+lemma vec_mset_vCons: "vec_mset (vCons x v) = add_mset x (vec_mset v)"
+proof -
+  have "vec_mset (vCons x v) = mset (list_of_vec (vCons x v))"
+    by (simp add: mset_vec_eq_mset_list)
+  then have "mset (list_of_vec (vCons x v)) = add_mset x (mset (list_of_vec v))"
+    by simp 
+  thus ?thesis
+    by (metis mset_vec_eq_mset_list) 
+qed
+
+lemma vec_mset_set: "vec_set v = set_mset (vec_mset v)"
+  by (simp add: mset_vec_eq_mset_list set_list_of_vec)
+
+lemma vCons_set_contains_in: "a \<in> set\<^sub>v v \<Longrightarrow> set\<^sub>v (vCons a v) = set\<^sub>v v"
+  by (metis remdups_mset_singleton_sum set_mset_remdups_mset vec_mset_set vec_mset_vCons)
+
+lemma vCons_set_contains_add: "a \<notin> set\<^sub>v v \<Longrightarrow> set\<^sub>v (vCons a v) = set\<^sub>v v \<union> {a}"
+  using vec_mset_set vec_mset_vCons
+  by (metis Un_insert_right set_mset_add_mset_insert sup_bot_right) 
+
+lemma setv_vec_mset_not_in_iff: "a \<notin> set\<^sub>v v \<longleftrightarrow> a \<notin># vec_mset v"
+  by (simp add: vec_mset_set)
+
+text \<open>Abbreviation for counting occurrences of an element in a vector \<close>
+
+abbreviation "count_vec v a \<equiv> count (vec_mset v) a"
+
+lemma vec_count_lt_dim: "count_vec v a \<le> dim_vec v"
+  by (metis mset_vec_same_size order_refl set_count_size_min)
+
+lemma count_vec_empty: "dim_vec v = 0 \<Longrightarrow> count_vec v a = 0"
+  by (simp add: mset_vec_same_size)
+
+lemma count_vec_vNil: "count_vec vNil a = 0"
+  by (simp add: vec_mset_def)
+
+lemma count_vec_vCons: "count_vec (vCons aa v) a = (if (aa = a) then count_vec v a + 1 else count_vec v a)"
+  by(simp add: vec_mset_vCons)
+
+lemma elem_exists_count_min: "\<exists> i \<in>{..<dim_vec v}. v $ i = x \<Longrightarrow> count_vec v x \<ge> 1"
+  by (simp add: vec_elem_exists_mset)
+
+lemma count_vec_count_mset: "vec_mset v = image_mset f A \<Longrightarrow> count_vec v a = count (image_mset f A) a"
+  by (simp)
+
+lemma count_vec_alt_list: "count_vec v a = length (filter (\<lambda>y. a = y) (list_of_vec v))"
+  by (simp add: mset_vec_eq_mset_list) (metis count_mset)
+
+lemma count_vec_alt: "count_vec v x = card { i. v $ i = x \<and> i< dim_vec v}"
+proof -
+  have "count_vec v x = count (image_mset (($) v) (mset_set {..<dim_vec v})) x" by (simp add: vec_mset_def)
+  also have "... = size {#a \<in># (image_mset (($) v) (mset_set {..<dim_vec v})) . x = a#}"
+    by (simp add: filter_mset_eq)
+  also have "... = size {#a \<in># (mset_set {..<dim_vec v}) . x = (v $ a) #}"
+    by (simp add: filter_mset_image_mset)
+  finally have "count_vec v x = card {a \<in> {..<dim_vec v} . x = (v $ a)}" by simp
+  thus ?thesis by (smt (verit) Collect_cong lessThan_iff) 
+qed
+
+lemma count_vec_sum_ones: 
+  fixes v :: "'a :: {ring_1} vec"
+  assumes "\<And> i. i < dim_vec v \<Longrightarrow> v $ i = 1 \<or> v $ i = 0"
+  shows "of_nat (count_vec v 1) = sum_vec v"
+  using assms 
+proof (induct v)
+  case vNil 
+  then show ?case
+     by (simp add: vec_mset_vNil)  
+ next
+  case (vCons a v)
+  then have lim: "dim_vec (vCons a v) \<ge> 1"
+    by simp 
+  have "(\<And> i. i < dim_vec v \<Longrightarrow> v $ i = 1 \<or> v$ i = 0)"
+    using vCons.prems by force
+  then have hyp: "of_nat (count_vec v 1) = sum_vec v"
+    using vCons.hyps by blast 
+  have "sum (($) (vCons a v)) {0..<dim_vec (vCons a v)} = sum_vec (vCons a v)" 
+    by (simp add: sum_vec_def)
+  then have sv: "sum (($) (vCons a v)) {0..<dim_vec (vCons a v)} = sum_vec (v) + a" 
+    by (simp add: sum_vec_vCons)
+  then show ?case using count_vec_vCons dim_vec_vCons_ne_0 sum_vec_vCons vCons.prems
+    by (metis add.commute add_0 hyp of_nat_1 of_nat_add vec_index_vCons_0)
+qed
+
+lemma count_vec_two_elems: 
+  fixes v :: "'a :: {zero_neq_one} vec"
+  assumes "\<And> i. i < dim_vec v \<Longrightarrow> v $ i = 1 \<or> v $ i = 0"
+  shows "count_vec v 1 + count_vec v 0 = dim_vec v"
+proof -
+  have ss: "vec_set v \<subseteq> {0, 1}" using assms by (auto simp add: vec_set_def)
+  have "dim_vec v = size (vec_mset v)"
+    by (simp add: mset_vec_same_size) 
+  have "size (vec_mset v) = (\<Sum> x \<in> (vec_set v) . count (vec_mset v) x)"
+    by (simp add: vec_mset_set size_multiset_overloaded_eq) 
+  also have  "... = (\<Sum> x \<in> {0, 1} . count (vec_mset v) x)"
+    using size_count_mset_ss ss
+    by (metis calculation finite.emptyI finite.insertI vec_mset_set)
+  finally have "size (vec_mset v) = count (vec_mset v) 0 + count (vec_mset v) 1" by simp
+  thus ?thesis
+    by (simp add: \<open>dim_vec v = size (vec_mset v)\<close>) 
+qed
+
+lemma count_vec_sum_zeros: 
+  fixes v :: "'a :: {ring_1} vec"
+  assumes "\<And> i. i < dim_vec v \<Longrightarrow> v $ i = 1 \<or> v $ i = 0"
+  shows "of_nat (count_vec v 0) = of_nat (dim_vec v) - sum_vec v"
+  using count_vec_two_elems assms count_vec_sum_ones
+  by (metis add_diff_cancel_left' of_nat_add)  
+
+lemma count_vec_sum_ones_alt: 
+  fixes v :: "'a :: {ring_1} vec"
+  assumes "vec_set v \<subseteq> {0, 1}"
+  shows "of_nat (count_vec v 1) = sum_vec v"
+proof -
+  have "\<And> i. i < dim_vec v \<Longrightarrow> v $ i = 1 \<or> v $ i = 0" using assms
+    by (meson insertE singletonD subsetD vec_setI) 
+  thus ?thesis using count_vec_sum_ones 
+    by blast 
+qed
+
+lemma setv_not_in_count0_iff: "a \<notin> set\<^sub>v v \<longleftrightarrow> count_vec v a = 0"
+  using setv_vec_mset_not_in_iff
+  by (metis count_eq_zero_iff) 
+
+lemma sum_count_vec: 
+  assumes "finite (set\<^sub>v v)"
+  shows "(\<Sum> i \<in> set\<^sub>v v. count_vec v i) = dim_vec v"
+using assms proof (induct "v")
+  case vNil
+  then show ?case
+    by (simp add: count_vec_empty) 
+next
+  case (vCons a v)
+  then show ?case proof (cases "a \<in> set\<^sub>v v")
+    case True
+    have cv: "\<And> x. x \<in>(set\<^sub>v v) - {a} \<Longrightarrow> count_vec (vCons a v) x = count_vec v x" 
+      using count_vec_vCons by (metis DiffD2 singletonI)
+    then have "sum (count_vec (vCons a v)) (set\<^sub>v (vCons a v)) =  sum (count_vec (vCons a v)) (set\<^sub>v v)" 
+      using vCons_set_contains_in True by metis
+    also have "... = count_vec (vCons a v) a + sum (count_vec (vCons a v)) ((set\<^sub>v v) - {a})" 
+      using sum.remove True vCons.prems(1) by (metis vCons_set_contains_in) 
+    also have "... = count_vec v a + 1 + sum (count_vec v) ((set\<^sub>v v) - {a})" 
+      using cv count_vec_vCons by (metis sum.cong) 
+    also have "... = 1 + sum (count_vec v) ((set\<^sub>v v))"
+      using sum.remove add.commute vCons.prems vCons_set_contains_in True
+      by (metis (no_types, opaque_lifting) ab_semigroup_add_class.add_ac(1))
+    also have "... = 1 + dim_vec v" using vCons.hyps
+      by (metis True vCons.prems vCons_set_contains_in) 
+    finally show ?thesis by simp
+  next
+    case False
+    then have cv: "\<And> x. x \<in>(set\<^sub>v v) \<Longrightarrow> count_vec (vCons a v) x = count_vec v x" 
+      using count_vec_vCons by (metis) 
+    have f: "finite (set\<^sub>v v)" 
+      using vCons.prems False vCons_set_contains_add by (metis Un_infinite) 
+    have "sum (count_vec (vCons a v)) (set\<^sub>v (vCons a v)) = 
+        count_vec (vCons a v) a + sum (count_vec (vCons a v)) (set\<^sub>v v)" 
+      using False vCons_set_contains_add
+      by (metis Un_insert_right finite_Un sum.insert sup_bot_right vCons.prems ) 
+    also have "... = count_vec v a + 1 + sum (count_vec v) ((set\<^sub>v v) )" 
+      using cv count_vec_vCons by (metis sum.cong) 
+    also have "... = 1 + sum (count_vec v) ((set\<^sub>v v))" 
+      using False setv_not_in_count0_iff by (metis add_0)
+    finally show ?thesis using vCons.hyps f by simp
+  qed
+qed
+
+lemma sum_setv_subset_eq: 
+  assumes "finite A"
+  assumes "set\<^sub>v v \<subseteq> A"
+  shows "(\<Sum> i \<in> set\<^sub>v v. count_vec v i) = (\<Sum> i \<in> A. count_vec v i)"
+proof -
+  have ni: "\<And> x. x \<notin> set\<^sub>v v \<Longrightarrow> count_vec v x = 0"
+    by (simp add: setv_not_in_count0_iff) 
+  have "(\<Sum> i \<in> A. count_vec v i) = (\<Sum> i \<in> A - (set\<^sub>v v). count_vec v i) + (\<Sum> i \<in> (set\<^sub>v v). count_vec v i)" 
+    using sum.subset_diff assms by auto
+  then show ?thesis using ni
+    by simp 
+qed
+
+lemma sum_count_vec_subset:  "finite A \<Longrightarrow> set\<^sub>v v \<subseteq> A \<Longrightarrow> (\<Sum> i \<in> A. count_vec v i) = dim_vec v"
+  using sum_setv_subset_eq sum_count_vec finite_subset by metis 
+
+text \<open>An abbreviation for checking if an element is in a vector \<close>
+
+abbreviation vec_contains :: "'a \<Rightarrow> 'a vec \<Rightarrow> bool" (infix "\<in>$" 50)where 
+"a \<in>$ v \<equiv> a \<in> set\<^sub>v v"
+
+lemma vec_set_mset_contains_iff: "a \<in>$ v \<longleftrightarrow> a \<in># vec_mset v"
+  by (simp add: vec_mset_def vec_set_def)
+
+lemma vec_contains_count_gt1_iff: "a \<in>$ v \<longleftrightarrow> count_vec v a \<ge> 1"
+  by (simp add: vec_set_mset_contains_iff)
+
+lemma vec_contains_obtains_index: 
+  assumes "a \<in>$ v"
+  obtains i where "i < dim_vec v" and "v $ i = a"
+  by (metis assms vec_setE)
+
+lemma vec_count_eq_list_count: "count (mset xs) a = count_vec (vec_of_list xs) a"
+  by (simp add: list_vec mset_vec_eq_mset_list) 
+
+lemma vec_contains_col_elements_mat: 
+  assumes "j < dim_col M"
+  assumes "a \<in>$ col M j"
+  shows "a \<in> elements_mat M"
+proof -
+  have "dim_vec (col M j) = dim_row M" by simp
+  then obtain i where ilt: "i < dim_row M" and "(col M j) $ i = a" 
+    using vec_setE by (metis assms(2))
+  then have "M $$ (i, j) = a"
+    by (simp add: assms(1)) 
+  thus ?thesis using assms(1) ilt
+    by blast
+qed
+
+lemma vec_contains_row_elements_mat: 
+  assumes "i < dim_row M"
+  assumes "a \<in>$ row M i"
+  shows "a \<in> elements_mat M"
+proof -
+  have "dim_vec (row M i) = dim_col M" by simp
+  then obtain j where jlt: "j < dim_col M" and "(row M i) $ j = a" using vec_setE
+    by (metis assms(2))
+  then have "M $$ (i, j) = a"
+    by (simp add: assms(1)) 
+  thus ?thesis using assms(1) jlt
+    by blast
+qed
+
+lemma vec_contains_img: "a \<in>$ v \<Longrightarrow> f a \<in>$ (map_vec f v)"
+  by (metis index_map_vec(1) index_map_vec(2) vec_contains_obtains_index vec_setI)
+
+text \<open> The existing vector library contains the identity and zero vectors, but no definition 
+of a vector where all elements are 1, as defined below \<close>
+
+definition all_ones_vec ::  "nat \<Rightarrow> 'a :: {zero,one} vec" ("u\<^sub>v") where
+  "u\<^sub>v n \<equiv> vec n (\<lambda> i. 1)"
+
+lemma dim_vec_all_ones[simp]: "dim_vec (u\<^sub>v n) = n"
+  by (simp add: all_ones_vec_def)
+
+lemma all_ones_index [simp]: "i < n \<Longrightarrow> u\<^sub>v n $ i = 1"
+  by (simp add: all_ones_vec_def)
+
+lemma dim_vec_mult_vec_mat [simp]: "dim_vec (v \<^sub>v* A) = dim_col A"
+  unfolding mult_vec_mat_def by simp
+
+lemma all_ones_vec_smult[simp]: "i < n \<Longrightarrow> ((k :: ('a :: {one, zero, monoid_mult})) \<cdot>\<^sub>v (u\<^sub>v n)) $ i = k"
+  by (simp add: smult_vec_def)
+
+text \<open>Extra lemmas on existing vector operations \<close>
+
+lemma smult_scalar_prod_sum: 
+  fixes x :: "'a :: {comm_ring_1}" 
+  assumes "vx \<in> carrier_vec n"
+  assumes "vy \<in> carrier_vec n"
+  shows "(\<Sum> i \<in> {0..<n} .((x \<cdot>\<^sub>v vx) $ i) * ((y \<cdot>\<^sub>v vy) $ i)) = x * y * (vx \<bullet> vy)"
+proof -
+  have "\<And> i . i < n \<Longrightarrow> ((x \<cdot>\<^sub>v vx) $ i) * ((y \<cdot>\<^sub>v vy) $ i) = x * y * (vx $ i) * (vy $ i)" 
+    using assms by simp
+  then have "(\<Sum> i \<in> {0..<n} .((x \<cdot>\<^sub>v vx) $ i) * ((y \<cdot>\<^sub>v vy) $ i)) = 
+      (\<Sum> i \<in> {0..<n} .x * y * (vx $ i) * (vy $ i))" 
+    by simp
+  also have "... = x * y * (\<Sum> i \<in> {0..<n} . (vx $ i) * (vy $ i))"
+    using sum_distrib_left[of "x * y" "(\<lambda> i. (vx $ i) * (vy $ i))" "{0..<n}"]
+    by (metis (no_types, lifting) mult.assoc sum.cong) 
+  finally have "(\<Sum> i \<in> {0..<n} .((x \<cdot>\<^sub>v vx) $ i) * ((y \<cdot>\<^sub>v vy) $ i)) = x * y * (vx \<bullet> vy)" 
+    using scalar_prod_def assms by (metis carrier_vecD) 
+  thus ?thesis by simp
+qed
+
+lemma scalar_prod_double_sum_fn_vec:
+  fixes c :: "nat \<Rightarrow> ('a :: {comm_semiring_0})"
+  fixes f :: "nat \<Rightarrow> 'a vec"
+  assumes "\<And> j . j < k \<Longrightarrow> dim_vec (f j) = n"
+  shows "(vec n (\<lambda>i. \<Sum>j = 0..<k. c j * (f j) $ i)) \<bullet> (vec n (\<lambda>i. \<Sum>j = 0..<k. c j * (f j) $ i)) = 
+    (\<Sum> j1 \<in> {0..<k} . c j1 * c j1 * ((f j1) \<bullet> (f j1))) + 
+    (\<Sum> j1 \<in> {0..<k} . (\<Sum> j2 \<in> ({0..< k} - {j1}) . c j1 * c j2 * ((f j1) \<bullet> (f j2))))"
+proof -
+  have sum_simp: "\<And> j1 j2. (\<Sum>l \<in> {0..<n} . c j1 * (f j1) $ l * (c j2 * (f j2) $ l)) = 
+    c j1 * c j2 *(\<Sum>l \<in> {0..<n} .  (f j1) $ l * (f j2) $ l)"
+  proof -
+    fix j1 j2
+    have "(\<Sum>l \<in> {0..<n} . c j1 * (f j1) $ l * (c j2 * (f j2) $ l)) = 
+        (\<Sum>l \<in> {0..<n} . c j1  * c j2 * (f j1) $ l * (f j2) $ l)"
+      using mult.commute sum.cong
+      by (smt (z3) ab_semigroup_mult_class.mult_ac(1)) (* SLOW *)
+    then show "(\<Sum>l \<in> {0..<n} . c j1 * (f j1) $ l * (c j2 * (f j2) $ l)) = 
+        c j1 * c j2 *(\<Sum>l \<in> {0..<n} .  (f j1) $ l * (f j2) $ l)"
+      using sum_distrib_left[of " c j1 * c j2" "\<lambda> l. (f j1) $ l * (f j2) $ l" "{0..<n}"]
+      by (metis (no_types, lifting) mult.assoc sum.cong) 
+  qed
+  have "(vec n (\<lambda>i. \<Sum>j = 0..<k. c j * (f j) $ i)) \<bullet> (vec n (\<lambda>i. \<Sum>j = 0..<k. c j * (f j) $ i))
+       = (\<Sum> l = 0..<n. (\<Sum>j1 = 0..<k. c j1 * (f j1) $ l) * (\<Sum>j2 = 0..<k. c j2 * (f j2) $ l))"
+    unfolding scalar_prod_def by simp
+  also have "... = (\<Sum> l \<in> {0..<n} . (\<Sum> j1 \<in> {0..<k} . (\<Sum> j2 \<in> {0..< k}. c j1 * (f j1) $ l *  (c j2 * (f j2) $ l))))" 
+    by (metis (no_types) sum_product)
+  also have "... = (\<Sum> j1 \<in> {0..<k} . (\<Sum> j2 \<in> {0..<k} . (\<Sum>l \<in> {0..<n} . c j1 * (f j1) $ l * (c j2 * (f j2) $ l))))" 
+    using sum_reorder_triple[of "\<lambda> l j1 j2 .(c j1 * (f j1) $ l * (c j2 * (f j2) $ l))" "{0..<k}" "{0..<k}" "{0..<n}"] 
+    by simp
+  also have "... = (\<Sum> j1 \<in> {0..<k} . (\<Sum> j2 \<in> {0..<k} . c j1 * c j2 * (\<Sum>l \<in> {0..<n} . (f j1) $ l * (f j2) $ l)))" 
+    using sum_simp by simp
+  also have "... = (\<Sum> j1 \<in> {0..<k} . (\<Sum> j2 \<in> {0..<k} . c j1 * c j2 * ((f j1) \<bullet> (f j2))))" 
+    unfolding scalar_prod_def using dim_col assms by simp
+  finally show ?thesis
+    using double_sum_split_case by fastforce
+qed
+
+lemma vec_prod_zero: "(0\<^sub>v n) \<bullet> (0\<^sub>v n) = 0"
+  by simp
+
+lemma map_vec_compose: "map_vec f (map_vec g v) = map_vec (f \<circ> g) v"
+  by auto
+
+subsection \<open>Matrix Extras\<close>
+
+text \<open>As with vectors, the all ones mat definition defines the concept of a matrix where all 
+elements are 1 \<close>
+
+definition all_ones_mat :: "nat \<Rightarrow> 'a :: {zero,one} mat" ("J\<^sub>m") where
+  "J\<^sub>m n \<equiv> mat n n (\<lambda> (i,j). 1)"
+
+lemma all_ones_mat_index[simp]: "i < dim_row (J\<^sub>m n) \<Longrightarrow> j < dim_col (J\<^sub>m n) \<Longrightarrow> J\<^sub>m n $$ (i, j)= 1"
+  by (simp add: all_ones_mat_def)
+
+lemma all_ones_mat_dim_row[simp]: "dim_row (J\<^sub>m n) = n"
+  by (simp add: all_ones_mat_def)
+
+lemma all_ones_mat_dim_col[simp]: "dim_col (J\<^sub>m n) = n"
+  by (simp add: all_ones_mat_def)
+
+text \<open>Basic lemmas on existing matrix operations \<close>
+lemma index_mult_vec_mat[simp]: "j < dim_col A \<Longrightarrow> (v \<^sub>v* A) $ j = v \<bullet> col A j"
+  by (auto simp: mult_vec_mat_def)
+
+lemma transpose_mat_mult_entries: "i < dim_row A \<Longrightarrow> j < dim_row A \<Longrightarrow> 
+    (A * A\<^sup>T) $$ (i, j) = (\<Sum>k\<in> {0..<(dim_col A)}. (A $$ (i, k)) * (A $$ (j, k)))"
+  by (simp add: times_mat_def scalar_prod_def)
+
+lemma transpose_mat_elems: "elements_mat A = elements_mat A\<^sup>T"
+  apply (auto simp add: transpose_mat_def)
+   apply (metis elements_matD elements_matI index_transpose_mat(1) mat_carrier transpose_mat_def)
+  by fastforce
+
+lemma row_elems_subset_mat: "i < dim_row N \<Longrightarrow> vec_set (row N i) \<subseteq> elements_mat N"
+  by (auto simp add: vec_set_def elements_matI)
+
+lemma col_elems_subset_mat: "i < dim_col N \<Longrightarrow> vec_set (col N i) \<subseteq> elements_mat N"
+  by (auto simp add: vec_set_def elements_matI)
+
+lemma obtain_row_index: 
+  assumes "r \<in> set (rows M)"
+  obtains i where "row M i = r" and "i < dim_row M"
+  by (metis assms in_set_conv_nth length_rows nth_rows)
+
+lemma row_prop_cond: "(\<And> i. i < dim_row M \<Longrightarrow> P (row M i)) \<Longrightarrow> r \<in> set (rows M) \<Longrightarrow> P r"
+  using obtain_row_index by metis 
+
+lemma obtain_col_index: 
+  assumes "c \<in> set (cols M)"
+  obtains j where "col M j = c" and "j < dim_col M"
+  by (metis assms cols_length cols_nth obtain_set_list_item)
+
+lemma col_prop_cond: "(\<And> j. j < dim_col M \<Longrightarrow> P (col M j)) \<Longrightarrow> c \<in> set (cols M) \<Longrightarrow> P c"
+  using obtain_col_index by metis  
+
+text \<open> Lemmas on the @{term "map_mat"} definition \<close>
+
+lemma row_map_mat[simp]:
+  assumes "i < dim_row A" shows "row (map_mat f A) i = map_vec f (row A i)"
+  unfolding map_mat_def map_vec_def using assms by auto
+
+lemma map_vec_mat_rows: "map (map_vec f) (rows M) = rows ((map_mat f) M)"
+  by (simp add: map_nth_eq_conv) 
+
+lemma map_vec_mat_cols: "map (map_vec f) (cols M) = cols ((map_mat f) M)"
+  by (simp add: map_nth_eq_conv)
+
+lemma map_mat_compose: "map_mat f (map_mat g A) = map_mat (f \<circ> g) A"
+  by (auto)
+
+lemma map_mat_elements: "elements_mat (map_mat f A) = f ` (elements_mat A)"
+proof (auto)
+  fix x assume "x \<in> elements_mat (map_mat f A)"
+  then obtain i j where "i < dim_row (map_mat f A)" and "j < dim_col (map_mat f A)" and "(map_mat f A) $$ (i, j) = x"
+    by auto
+  then show "x \<in> f ` elements_mat A" by auto
+next
+  fix xa assume "xa \<in> elements_mat A" 
+  then obtain i j where "i < dim_row A" and "j < dim_col A" and "A $$ (i, j) = xa" by auto
+  then show "f xa \<in> elements_mat (map_mat f A)" by auto
+qed  
+
+text \<open> Reasoning on sets and multisets of matrix elements \<close>
+lemma set_cols_carrier: "A \<in> carrier_mat m n \<Longrightarrow> v \<in> set (cols A) \<Longrightarrow> v \<in> carrier_vec m"
+  by (auto simp: cols_def)
+
+lemma mset_cols_index_map:  "image_mset (\<lambda> j. col M j) (mset_set {0..< dim_col M}) = mset (cols M)"
+  by (simp add: cols_def)
+
+lemma mset_rows_index_map:  "image_mset (\<lambda> i. row M i) (mset_set {0..< dim_row M}) = mset (rows M)"
+  by (simp add: rows_def)
+
+lemma index_to_col_card_size_prop: 
+  assumes "i < dim_row M"
+  assumes "\<And> j. j < dim_col M \<Longrightarrow> P j \<longleftrightarrow> Q (col M j)" 
+  shows "card {j . j < dim_col M \<and> P j} = size {#c \<in># (mset (cols M)) . Q c #}"
+proof -
+  have "card {j . j < dim_col M \<and> P j} = size (mset_set({j \<in> {0..<dim_col M}.  P j}))"
+    by simp
+  also have "... = size (mset_set({j \<in> {0..<dim_col M}.  Q (col M j)}))"
+    using assms(2)
+    by (metis lessThan_atLeast0 lessThan_iff)
+  also have "... = size (image_mset (\<lambda> j. col M j)  {# j \<in># mset_set {0..< dim_col M} . Q (col M j) #})"
+    by simp
+  also have "... = size ({# c \<in># (image_mset (\<lambda> j. col M j) (mset_set {0..< dim_col M})) .  Q c #})"
+    using image_mset_filter_swap[of "(\<lambda> j. col M j)"  "Q" "(mset_set {0..< dim_col M})"] by simp
+  finally have "card {j . j < dim_col M \<and> P j} = size ({# c \<in># (mset (cols M)) .  Q c #})"
+    using mset_cols_index_map by metis  
+  thus ?thesis by simp
+qed
+
+lemma index_to_row_card_size_prop: 
+  assumes "j < dim_col M"
+  assumes "\<And> i. i < dim_row M \<Longrightarrow> P i \<longleftrightarrow> Q (row M i)" 
+  shows "card {i . i < dim_row M \<and> P i} = size {#r \<in># (mset (rows M)) . Q r #}"
+proof -
+  have "card {i . i < dim_row M \<and> P i} = size (mset_set({i \<in> {0..<dim_row M}.  P i}))"
+    by simp
+  also have "... = size (mset_set({i \<in> {0..<dim_row M}.  Q (row M i)}))"
+    using assms(2)
+    by (metis lessThan_atLeast0 lessThan_iff) 
+  also have "... = size (image_mset (\<lambda> i. row M i)  {# i \<in># mset_set {0..< dim_row M} . Q (row M i) #})"
+    by simp
+  also have "... = size ({# r \<in># (image_mset (\<lambda> i. row M i) (mset_set {0..< dim_row M})) .  Q r #})"
+    using image_mset_filter_swap[of "(\<lambda> j. row M j)"  "Q" "(mset_set {0..< dim_row M})"] by simp
+  finally have "card {j . j < dim_row M \<and> P j} = size ({# c \<in># (mset (rows M)) .  Q c #})"
+    using mset_rows_index_map by metis  
+  thus ?thesis by simp
+qed
+
+lemma setv_row_subset_mat_elems: 
+  assumes "v \<in> set (rows M)"
+  shows "set\<^sub>v v \<subseteq> elements_mat M" 
+proof (intro subsetI)
+  fix x assume "x \<in>$ v"
+  then obtain i where "v = row M i" and "i < dim_row M"
+    by (metis assms obtain_row_index) 
+  then show "x \<in> elements_mat M"
+    by (metis \<open>x \<in>$ v\<close> vec_contains_row_elements_mat) 
+qed
+
+lemma setv_col_subset_mat_elems: 
+  assumes "v \<in> set (cols M)"
+  shows "set\<^sub>v v \<subseteq> elements_mat M" 
+proof (intro subsetI)
+  fix x assume "x \<in>$ v"
+  then obtain i where "v = col M i" and "i < dim_col M"
+    by (metis assms obtain_col_index) 
+  then show "x \<in> elements_mat M"
+    by (metis \<open>x \<in>$ v\<close> vec_contains_col_elements_mat) 
+qed
+
+subsection \<open> Vector and Matrix Homomorphism \<close>
+
+text \<open>We extend on the existing lemmas on homomorphism mappings as applied to vectors and matrices \<close>
+
+context semiring_hom
+begin
+
+lemma  vec_hom_smult2: 
+  assumes "dim_vec v2 \<le> dim_vec v1"
+  shows "hom (v1 \<bullet> v2) = vec\<^sub>h v1 \<bullet> vec\<^sub>h v2"
+  unfolding scalar_prod_def using index_map_vec assms by (auto simp add: hom_distribs)
+
+end
+
+
+lemma map_vec_vCons: "vCons (f a) (map_vec f v) = map_vec f (vCons a v)"
+  by (intro eq_vecI, simp_all add: vec_index_vCons)
+          
+context inj_zero_hom
+begin
+
+lemma  vec_hom_zero_iff[simp]: "(map_vec hom x = 0\<^sub>v n) = (x = 0\<^sub>v n)"
+proof -
+  {
+    fix i
+    assume i: "i < n" "dim_vec x = n"
+    hence "map_vec hom x $ i = 0 \<longleftrightarrow> x $ i = 0"
+      using index_map_vec(1)[of i x] by simp
+  } note main = this
+  show ?thesis unfolding vec_eq_iff by (simp, insert main, auto)
+qed
+
+lemma  mat_hom_inj: "map_mat hom A = map_mat hom B \<Longrightarrow> A = B"
+  unfolding mat_eq_iff by auto
+
+lemma  vec_hom_inj: "map_vec hom v = map_vec hom w \<Longrightarrow> v = w"
+  unfolding vec_eq_iff by auto
+
+lemma  vec_hom_set_distinct_iff: 
+  fixes xs :: "'a vec list"
+  shows "distinct xs \<longleftrightarrow> distinct (map (map_vec hom) xs)"
+  using vec_hom_inj by (induct xs) (auto)
+
+lemma vec_hom_mset: "image_mset hom (vec_mset v) = vec_mset (map_vec hom v)"
+  apply (induction v)
+   apply (metis mset.simps(1) vec_mset_img_map vec_mset_vNil vec_of_list_Nil)
+  by (metis mset_vec_eq_mset_list vec_list vec_mset_img_map)
+
+lemma vec_hom_set: "hom ` set\<^sub>v v = set\<^sub>v (map_vec hom v)"
+proof (induct v)
+  case vNil
+  then show ?case by (metis image_mset_empty set_image_mset vec_hom_zero_iff vec_mset_set vec_mset_vNil zero_vec_zero)
+next
+  case (vCons a v)
+  have "hom ` set\<^sub>v (vCons a v) = hom ` ({a} \<union> set\<^sub>v v)"
+    by (metis Un_commute insert_absorb insert_is_Un vCons_set_contains_add vCons_set_contains_in) 
+  also have "... = {hom a} \<union> (hom ` (set\<^sub>v v))" by simp
+  also have "... = {hom a} \<union> (set\<^sub>v (map_vec hom v))" using vCons.hyps by simp
+  also have "... = set\<^sub>v (vCons (hom a) (map_vec hom v))"
+    by (metis Un_commute insert_absorb insert_is_Un vCons_set_contains_add vCons_set_contains_in) 
+  finally show ?case using map_vec_vCons
+    by metis 
+qed
+
+end
+
+subsection \<open> Zero One injections and homomorphisms \<close>
+
+text \<open>Define a locale to encapsulate when a function is injective on a certain set (i.e. not
+a universal homomorphism for the type\<close>
+locale injective_lim =
+  fixes A :: "'a set"
+  fixes f :: "'a \<Rightarrow> 'b" assumes injectivity_lim: "\<And>x y. x \<in> A \<Longrightarrow> y \<in> A \<Longrightarrow> f x = f y \<Longrightarrow> x = y"
+begin
+  lemma eq_iff[simp]: "x \<in> A \<Longrightarrow> y \<in> A \<Longrightarrow> f x = f y \<longleftrightarrow> x = y" using injectivity_lim by auto
+lemma inj_on_f: "inj_on f A" by (auto intro: inj_onI)
+
+end
+
+sublocale injective \<subseteq> injective_lim Univ
+  by(unfold_locales) simp
+
+context injective_lim
+begin
+
+lemma mat_hom_inj_lim: 
+  assumes "elements_mat M \<subseteq> A" and "elements_mat N \<subseteq> A"
+  shows "map_mat f M = map_mat f N \<Longrightarrow> M = N"
+  unfolding mat_eq_iff apply auto
+  using assms injectivity_lim by blast
+
+lemma vec_hom_inj_lim: assumes "set\<^sub>v v \<subseteq> A" "set\<^sub>v w \<subseteq> A"
+  shows "map_vec f v = map_vec f w \<Longrightarrow> v = w"
+  unfolding vec_eq_iff apply (auto)
+  using vec_setI in_mono assms injectivity_lim by metis 
+
+lemma lim_inj_hom_count_vec: 
+  assumes "set\<^sub>v v \<subseteq> A"
+  assumes "x \<in> A"
+  shows "count_vec v x = count_vec (map_vec f v) (f x)"
+using assms proof (induct v)
+  case vNil
+  have "(map_vec f vNil) = vNil" by auto
+  then show ?case
+    by (smt (verit) count_vec_vNil)
+next
+  case (vCons a v)
+  have 1: "map_vec f (vCons a v) = vCons (f a) (map_vec f v)"
+    by (simp add: map_vec_vCons) 
+  then show ?case proof (cases "a = x")
+    case True
+    have "count_vec (vCons a v) x = count_vec v x + 1"
+      by (simp add: True count_vec_vCons)
+    then show ?thesis using Un_subset_iff 1 count_vec_vCons vCons.hyps vCons.prems(1) 
+          vCons.prems(2) vCons_set_contains_add vCons_set_contains_in
+      by metis 
+  next
+    case False
+    then have "count_vec (vCons a v) x = count_vec v x"
+      by (simp add: count_vec_vCons)
+    then show ?thesis using "1" Un_empty_right Un_insert_right count_vec_vCons insert_absorb insert_subset 
+          vCons.hyps vCons.prems(1) vCons.prems(2) vCons_set_contains_add vCons_set_contains_in
+      by (metis (no_types, lifting) injectivity_lim)  
+  qed
+qed
+
+lemma vec_hom_lim_set_distinct_iff: 
+  fixes xs :: "'a vec list"
+  assumes "\<And> v . v \<in> set (xs) \<Longrightarrow> set\<^sub>v v \<subseteq> A"
+  shows "distinct xs \<longleftrightarrow> distinct (map (map_vec f) xs)"
+  using assms vec_hom_inj_lim by (induct xs, simp_all) (metis (no_types, lifting) image_iff) 
+
+lemma mat_rows_hom_lim_distinct_iff: 
+  assumes "elements_mat M \<subseteq> A"
+  shows "distinct (rows M) \<longleftrightarrow> distinct (map (map_vec f) (rows M))"
+  apply (intro vec_hom_lim_set_distinct_iff)
+  using setv_row_subset_mat_elems assms by blast 
+
+lemma mat_cols_hom_lim_distinct_iff: 
+  assumes "elements_mat M \<subseteq> A"
+  shows "distinct (cols M) \<longleftrightarrow> distinct (map (map_vec f) (cols M))"
+  apply (intro vec_hom_lim_set_distinct_iff)
+  using setv_col_subset_mat_elems assms by blast 
+
+end
+
+locale inj_on_01_hom = zero_hom + one_hom + injective_lim "{0, 1}" hom
+begin
+
+lemma inj_0_iff: "x \<in> {0, 1} \<Longrightarrow> hom x = 0 \<longleftrightarrow> x = 0"
+  by (metis hom_zero insertI1 local.eq_iff)
+
+lemma inj_1_iff: "x \<in> {0, 1} \<Longrightarrow> hom x = 1 \<longleftrightarrow> x = 1"
+  using inj_0_iff by fastforce
+  
+end
+
+context zero_neq_one
+begin
+
+definition of_zero_neq_one :: "'b :: {zero_neq_one} \<Rightarrow> 'a" where
+"of_zero_neq_one x \<equiv> if (x = 0) then 0 else 1"
+
+lemma of_zero_neq_one_1 [simp]: "of_zero_neq_one 1 = 1"
+  by (simp add: of_zero_neq_one_def)
+
+lemma of_zero_neq_one_0 [simp]:  "of_zero_neq_one 0 = 0"
+  by (simp add: of_zero_neq_one_def)
+
+lemma of_zero_neq_one_0_iff[iff]: "of_zero_neq_one x = 0 \<longleftrightarrow> x = 0"
+  by (simp add: of_zero_neq_one_def)
+
+lemma of_zero_neq_one_lim_eq: "x \<in> {0, 1} \<Longrightarrow> y \<in> {0, 1} \<Longrightarrow> of_zero_neq_one x = of_zero_neq_one y \<longleftrightarrow> x = y"
+  by (auto simp add: of_zero_neq_one_def)
+
+
+end
+
+interpretation of_zero_hom: zero_hom_0 of_zero_neq_one
+  by(unfold_locales) (simp_all)
+
+interpretation of_injective_lim: injective_lim "{0, 1}" of_zero_neq_one
+  by (unfold_locales)(simp_all add: of_zero_neq_one_lim_eq)
+
+interpretation of_inj_on_01_hom: inj_on_01_hom of_zero_neq_one
+  by (unfold_locales)(simp_all add: of_zero_neq_one_lim_eq)
+
+text \<open>We want the ability to transform any 0-1 vector or matrix to another @{typ "'c :: zero_neq_one"} type \<close>
+definition lift_01_vec :: "'b :: {zero_neq_one} vec \<Rightarrow> 'c :: {zero_neq_one} vec" where 
+"lift_01_vec v \<equiv> map_vec of_zero_neq_one v"
+
+lemma lift_01_vec_simp[simp]: "dim_vec (lift_01_vec v) = dim_vec v"
+"i < dim_vec v \<Longrightarrow> (lift_01_vec v) $ i = of_zero_neq_one (v $ i)"
+  by (simp_all add: lift_01_vec_def)
+
+lemma lift_01_vec_count: 
+  assumes "set\<^sub>v v \<subseteq> {0, 1}"
+  assumes "x \<in> {0, 1}"
+  shows "count_vec v x = count_vec (lift_01_vec v) (of_zero_neq_one x)"
+  using of_injective_lim.lim_inj_hom_count_vec
+  by (metis assms(1) assms(2) lift_01_vec_def)  
+
+definition lift_01_mat :: "'b :: {zero_neq_one} mat \<Rightarrow> 'c :: {zero_neq_one} mat" where 
+"lift_01_mat M \<equiv> map_mat of_zero_neq_one M"
+
+lemma lift_01_mat_simp[simp]: "dim_row (lift_01_mat M) = dim_row M"
+  "dim_col (lift_01_mat M) = dim_col M"
+  "i < dim_row M \<Longrightarrow> j < dim_col M \<Longrightarrow> (lift_01_mat M) $$ (i, j) = of_zero_neq_one (M $$ (i, j))"
+  by (simp_all add: lift_01_mat_def)
+
+lemma lift_01_mat_carrier: "lift_01_mat M \<in> carrier_mat (dim_row M) (dim_col M)"
+  using lift_01_mat_def by auto
+
+end
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/ROOT b/thys/Fishers_Inequality/ROOT
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/ROOT
@@ -0,0 +1,16 @@
+chapter AFP
+
+session Fishers_Inequality (AFP) = "Berlekamp_Zassenhaus" + 
+  options [timeout = 600]
+  sessions
+    Design_Theory
+    "HOL-Combinatorics"
+    Groebner_Bases
+    Polynomial_Factorization
+    "List-Index"
+    BenOr_Kozen_Reif
+  theories
+    Fishers_Inequality_Root
+  document_files
+    "root.bib"
+    "root.tex"
diff --git a/thys/Fishers_Inequality/Rank_Argument_General.thy b/thys/Fishers_Inequality/Rank_Argument_General.thy
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/Rank_Argument_General.thy
@@ -0,0 +1,443 @@
+(* Title: Rank_Argument_General.thy
+   Author: Chelsea Edmonds
+*)
+
+section \<open>Rank Argument - General \<close>
+text \<open>General lemmas to enable reasoning using the rank argument. This is described by Godsil 
+\cite{godsilToolsLinearAlgebra} and Bukh \cite{bukhAlgebraicMethodsCombinatoricsa}, both of whom 
+present it as a foundational technique \<close>
+theory Rank_Argument_General imports Dual_Systems Jordan_Normal_Form.Determinant
+Jordan_Normal_Form.DL_Rank Jordan_Normal_Form.Ring_Hom_Matrix BenOr_Kozen_Reif.More_Matrix
+begin
+
+subsection \<open>Row/Column Operations \<close>
+text \<open>Extensions to the existing elementary operations are made to enable reasoning on multiple 
+operations at once, similar to mathematical literature\<close>
+
+lemma index_mat_addrow_basic [simp]: 
+  "i < dim_row A \<Longrightarrow> j < dim_col A \<Longrightarrow> addrow a k l A $$ (i,j) = (if k = i then 
+    ( a * (A $$ (l,j)) + (A $$ (i,j))) else A $$ (i,j))"
+  "i < dim_row A \<Longrightarrow> j < dim_col A \<Longrightarrow> addrow a i l A $$ (i,j) = (a * (A $$ (l,j)) + (A $$ (i,j)))"
+  "i < dim_row A \<Longrightarrow> j < dim_col A \<Longrightarrow> k \<noteq> i \<Longrightarrow> addrow a k l A $$ (i,j) = A $$(i,j)"
+  "dim_row (addrow a k l A) = dim_row A" "dim_col (addrow a k l A) = dim_col A"
+  unfolding mat_addrow_def by auto
+
+text\<open>Function to add a column to multiple other columns \<close>
+fun add_col_to_multiple :: "'a :: semiring_1 \<Rightarrow> nat list \<Rightarrow> nat \<Rightarrow> 'a mat \<Rightarrow> 'a mat" where
+"add_col_to_multiple a [] l A = A" | 
+"add_col_to_multiple a (k # ks) l A = (addcol a k l (add_col_to_multiple a ks l A))"
+
+text \<open>Function to add a row to multiple other rows \<close>
+fun add_row_to_multiple :: "'a :: semiring_1 \<Rightarrow> nat list \<Rightarrow> nat \<Rightarrow> 'a mat \<Rightarrow> 'a mat" where
+"add_row_to_multiple a [] l A = A" | 
+"add_row_to_multiple a (k # ks) l A = (addrow a k l (add_row_to_multiple a ks l A))"
+
+text \<open>Function to add multiple rows to a single row \<close>
+fun add_multiple_rows :: "'a :: semiring_1 \<Rightarrow> nat \<Rightarrow> nat list \<Rightarrow> 'a mat \<Rightarrow> 'a mat" where
+"add_multiple_rows a k [] A = A" | 
+"add_multiple_rows a k (l # ls) A = (addrow a k l (add_multiple_rows a k ls A))"
+
+text \<open>Function to add multiple columns to a single col \<close>
+fun add_multiple_cols :: "'a :: semiring_1 \<Rightarrow> nat \<Rightarrow> nat list \<Rightarrow> 'a mat \<Rightarrow> 'a mat" where
+"add_multiple_cols a k [] A = A" | 
+"add_multiple_cols a k (l # ls) A = (addcol a k l (add_multiple_cols a k ls A))"
+
+text \<open>Basic lemmas on dimension and indexing of resulting matrix from above functions \<close>
+lemma add_multiple_rows_dim [simp]: 
+"dim_row (add_multiple_rows a k ls A) = dim_row A"
+"dim_col (add_multiple_rows a k ls A) = dim_col A"
+  by (induct ls) simp_all
+
+lemma add_multiple_rows_index_unchanged [simp]: 
+  "i < dim_row A \<Longrightarrow> j < dim_col A \<Longrightarrow> k \<noteq> i \<Longrightarrow> add_multiple_rows a k ls A $$ (i,j) = A $$(i,j)"
+  by (induct ls) (simp_all)
+
+lemma add_multiple_rows_index_eq: 
+  assumes "i < dim_row A" and "j < dim_col A" and "i \<notin> set ls" and "\<And> l . l \<in> set ls \<Longrightarrow> l < dim_row A"
+  shows "add_multiple_rows a i ls A $$ (i,j) = (\<Sum>l\<leftarrow>ls. a * A $$(l,j)) + A$$(i,j)"
+  using assms proof (induct ls)
+  case Nil
+  then show ?case by simp
+next
+  case (Cons aa ls)
+  then have ne: "i \<noteq> aa"
+    by auto 
+  have lt: "aa < dim_row A" using assms(1)
+    by (simp add: Cons.prems(4))
+  have "(add_multiple_rows a i (aa # ls) A) $$ (i, j) = 
+      (addrow a i aa (add_multiple_rows a i ls A)) $$ (i, j)" 
+    by simp
+  also have "... = a * add_multiple_rows a i ls A $$ (aa, j) + (add_multiple_rows a i ls A) $$ (i, j)" 
+    using assms(1) assms(2) index_mat_addrow_basic(2)[of "i" "(add_multiple_rows a i ls A)" "j" "a" "aa"] 
+    by simp
+  also have "... = a * A $$(aa, j) + (add_multiple_rows a i ls A) $$ (i, j)" 
+    using lt ne by (simp add: assms(2)) 
+  also have "... = a * A $$(aa, j) + (\<Sum>l\<leftarrow>ls. a * A $$ (l, j)) + A $$ (i, j)" 
+    using Cons.hyps assms(1) assms(2) Cons.prems(3) Cons.prems(4)
+    by (metis (mono_tags, lifting) ab_semigroup_add_class.add_ac(1) list.set_intros(2)) 
+  finally show "(add_multiple_rows a i (aa # ls) A) $$ (i, j) = 
+      (\<Sum>l\<leftarrow>(aa #ls). a * A $$ (l, j)) + A $$ (i, j)"
+    by simp 
+qed
+
+lemma add_multiple_rows_index_eq_bounds: 
+  assumes "i < dim_row A" and "j < dim_col A" and "i < low \<or> i \<ge> up" and "up \<le> dim_row A"
+  shows "add_multiple_rows a i [low..<up] A $$ (i,j) = (\<Sum>l=low..<up. a * A $$(l,j)) + A$$(i,j)"
+proof -
+  have notin: "i \<notin> set [low..<up]" using assms(3) by auto
+  have "\<And> l . l \<in> set [low..<up] \<Longrightarrow> l < dim_row A" using assms(4) by auto
+  thus ?thesis  using add_multiple_rows_index_eq[of i A j "[low..<up]"] 
+      sum_set_upt_eq_sum_list[of "\<lambda> l. a * A $$(l,j)" low up]  notin assms(1) assms(2) by simp
+qed
+
+lemma add_multiple_cols_dim [simp]: 
+  "dim_row (add_multiple_cols a k ls A) = dim_row A"
+  "dim_col (add_multiple_cols a k ls A) = dim_col A"
+  by (induct ls) simp_all
+
+lemma add_multiple_cols_index_unchanged [simp]: 
+  "i < dim_row A \<Longrightarrow> j < dim_col A \<Longrightarrow> k \<noteq> j \<Longrightarrow> add_multiple_cols a k ls A $$ (i,j) = A $$(i,j)"
+  by (induct ls) (simp_all)
+
+lemma add_multiple_cols_index_eq: 
+  assumes "i < dim_row A" and "j < dim_col A" and "j \<notin> set ls" and "\<And> l . l \<in> set ls \<Longrightarrow> l < dim_col A"
+  shows "add_multiple_cols a j ls A $$ (i,j) = (\<Sum>l\<leftarrow>ls. a * A $$(i,l)) + A$$(i,j)"
+  using assms
+proof (induct ls)
+  case Nil
+  then show ?case by simp
+next
+  case (Cons aa ls)
+  then have ne: "j \<noteq> aa"
+    by auto 
+  have lt: "aa < dim_col A" using assms
+    by (simp add: Cons.prems(4))
+  have "(add_multiple_cols a j (aa # ls) A) $$ (i, j) = (addcol a j aa (add_multiple_cols a j ls A)) $$ (i, j)" 
+    by simp
+  also have "... = a * add_multiple_cols a j ls A $$ (i, aa) + (add_multiple_cols a j ls A) $$ (i, j)" 
+    using assms index_mat_addcol by simp
+  also have "... = a * A $$(i, aa) + (add_multiple_cols a j ls A) $$ (i, j)" 
+    using lt ne by (simp add: assms(1))
+  also have "... = a * A $$(i, aa) + (\<Sum>l\<leftarrow>ls. a * A $$ (i, l)) + A $$ (i, j)" 
+    using Cons.hyps assms(1) assms(2)  Cons.prems(3) Cons.prems(4)
+    by (metis (mono_tags, lifting) ab_semigroup_add_class.add_ac(1)  list.set_intros(2)) 
+  finally show ?case by simp
+qed
+
+lemma add_multiple_cols_index_eq_bounds: 
+  assumes "i < dim_row A" and "j < dim_col A" and "j < low \<or> j \<ge> up" and "up \<le> dim_col A"
+  shows "add_multiple_cols a j [low..<up] A $$ (i,j) = (\<Sum>l=low..<up. a * A $$(i,l)) + A$$(i,j)"
+proof -
+  have notin: "j \<notin> set [low..<up]" using assms(3) by auto
+  have "\<And> l . l \<in> set [low..<up] \<Longrightarrow> l < dim_col A" using assms(4) by auto
+  thus ?thesis using add_multiple_cols_index_eq[of i A j "[low..<up]" a] 
+      sum_set_upt_eq_sum_list[of "\<lambda> l. a * A $$(i,l)" low up] notin assms(1) assms(2) by simp
+qed
+
+lemma add_row_to_multiple_dim [simp]: 
+  "dim_row (add_row_to_multiple a ks l A) = dim_row A"
+  "dim_col (add_row_to_multiple a ks l A) = dim_col A"
+  by (induct ks) simp_all
+
+lemma add_row_to_multiple_index_unchanged [simp]: 
+  "i < dim_row A \<Longrightarrow> j < dim_col A \<Longrightarrow> i \<notin> set ks \<Longrightarrow> add_row_to_multiple a ks l A $$ (i,j) = A $$(i,j)"
+  by (induct ks) simp_all
+
+lemma add_row_to_multiple_index_unchanged_bound: 
+  "i < dim_row A \<Longrightarrow> j < dim_col A \<Longrightarrow> i < low \<Longrightarrow> i \<ge> up \<Longrightarrow> 
+    add_row_to_multiple a [low..<up] l A $$ (i,j) = A $$(i,j)"
+  by simp
+
+lemma add_row_to_multiple_index_change: 
+  assumes "i < dim_row A" and "j < dim_col A" and "i \<in> set ks" and "distinct ks" and "l \<notin> set ks" 
+    and "l < dim_row A"
+  shows "add_row_to_multiple a ks l A $$ (i,j) = (a * A$$(l, j)) + A$$(i,j)"
+  using assms
+proof (induct ks)
+  case Nil
+  then show ?case by simp
+next
+  case (Cons aa ls)
+  then have lnotin: "l \<notin> set ls" using assms by simp
+  then show ?case 
+  proof (cases "i = aa")
+    case True
+    then have inotin: "i \<notin> set ls" using assms
+      using Cons.prems(4) by fastforce 
+    have "add_row_to_multiple a (aa # ls) l A $$ (i, j) = 
+        (addrow a aa l (add_row_to_multiple a ls l A)) $$ (i, j)" by simp
+    also have "... = (a * ((add_row_to_multiple a ls l A) $$ (l,j)) + 
+        ((add_row_to_multiple a ls l A) $$ (i,j)))"
+      using True assms(1) assms(2) by auto
+    also have "... = a* A $$ (l, j) + ((add_row_to_multiple a ls l A) $$ (i,j))" 
+      using assms lnotin by simp 
+    finally have "add_row_to_multiple a (aa # ls) l A $$ (i, j) = a* A $$ (l,j) + A $$ (i, j)" 
+      using inotin assms by simp
+    then show ?thesis by simp
+  next
+    case False
+    then have iin: "i \<in> set ls" using assms
+      by (meson Cons.prems(3) set_ConsD) 
+    have "add_row_to_multiple a (aa # ls) l A $$ (i, j) = (addrow a aa l (add_row_to_multiple a ls l A)) $$ (i, j)" 
+      by simp
+    also have "... =  ((add_row_to_multiple a ls l A) $$ (i,j))"
+      using False assms by auto
+    finally have "add_row_to_multiple a (aa # ls) l A $$ (i, j) =  a * A $$ (l, j) + A $$ (i, j)" 
+      using Cons.hyps by (metis Cons.prems(4) assms(1) assms(2) assms(6) distinct.simps(2) iin lnotin) 
+    then show ?thesis by simp
+  qed
+qed
+
+lemma add_row_to_multiple_index_change_bounds: 
+  assumes "i < dim_row A" and "j < dim_col A" and "i \<ge> low" and "i < up"  and "l < low \<or> l \<ge> up" 
+    and "l < dim_row A"
+  shows "add_row_to_multiple a [low..<up] l A $$ (i,j) = (a * A$$(l, j)) + A$$(i,j)"
+proof -
+  have d: "distinct [low..<up]" by simp
+  have iin: "i \<in> set [low..<up]" using assms by auto
+  have lnin: "l \<notin> set [low..<up]" using assms by auto
+  thus ?thesis 
+    using add_row_to_multiple_index_change d iin assms by blast
+qed
+
+
+lemma add_col_to_multiple_dim [simp]: 
+  "dim_row (add_col_to_multiple a ks l A) = dim_row A"
+  "dim_col (add_col_to_multiple a ks l A) = dim_col A"
+  by (induct ks) simp_all
+
+lemma add_col_to_multiple_index_unchanged [simp]: 
+  "i < dim_row A \<Longrightarrow> j < dim_col A \<Longrightarrow> j \<notin> set ks \<Longrightarrow> add_col_to_multiple a ks l A $$ (i,j) = A $$(i,j)"
+  by (induct ks) simp_all
+
+lemma add_col_to_multiple_index_unchanged_bound: 
+  "i < dim_row A \<Longrightarrow> j < dim_col A \<Longrightarrow> j < low \<Longrightarrow> j \<ge> up \<Longrightarrow> 
+    add_col_to_multiple a [low..<up] l A $$ (i,j) = A $$(i,j)"
+  by simp
+
+lemma add_col_to_multiple_index_change: 
+  assumes "i < dim_row A" and "j < dim_col A" and "j \<in> set ks" and "distinct ks" and "l \<notin> set ks" 
+    and "l < dim_col A"
+  shows "add_col_to_multiple a ks l A $$ (i,j) = (a * A$$(i, l)) + A$$(i,j)"
+  using assms
+proof (induct ks)
+  case Nil
+  then show ?case by simp
+next
+  case (Cons aa ls)
+  then have lnotin: "l \<notin> set ls" using assms by simp
+  then show ?case 
+  proof (cases "j = aa")
+    case True
+    then have inotin: "j \<notin> set ls" using assms
+      using Cons.prems(4) by fastforce 
+    have "add_col_to_multiple a (aa # ls) l A $$ (i, j) = 
+        (addcol a aa l (add_col_to_multiple a ls l A)) $$ (i, j)" by simp
+    also have "... = (a * ((add_col_to_multiple a ls l A) $$ (i,l)) + 
+        ((add_col_to_multiple a ls l A) $$ (i,j)))"
+      using True assms(1) assms(2) by auto
+    also have "... = a* A $$ (i, l) + ((add_col_to_multiple a ls l A) $$ (i,j))" 
+      using assms lnotin by simp 
+    finally have "add_col_to_multiple a (aa # ls) l A $$ (i, j) = a* A $$ (i,l) + A $$ (i, j)" 
+      using inotin assms by simp
+    then show ?thesis by simp
+  next
+    case False
+    then have iin: "j \<in> set ls" using assms
+      by (meson Cons.prems(3) set_ConsD) 
+    have "add_col_to_multiple a (aa # ls) l A $$ (i, j) = 
+        (addcol a aa l (add_col_to_multiple a ls l A)) $$ (i, j)" by simp
+    also have "... =  ((add_col_to_multiple a ls l A) $$ (i,j))"
+      using False assms by auto
+    finally have "add_col_to_multiple a (aa # ls) l A $$ (i, j) =  a * A $$ (i, l) + A $$ (i, j)" 
+      using Cons.hyps by (metis Cons.prems(4) assms(1) assms(2) assms(6) distinct.simps(2) iin lnotin) 
+    then show ?thesis by simp
+  qed
+qed
+
+lemma add_col_to_multiple_index_change_bounds: 
+  assumes "i < dim_row A" and "j < dim_col A" and "j \<ge> low" and "j < up"  and "l < low \<or> l \<ge> up" 
+    and "l < dim_col A"
+  shows "add_col_to_multiple a [low..<up] l A $$ (i,j) = (a * A$$(i, l)) + A$$(i,j)"
+proof -
+  have d: "distinct [low..<up]" by simp
+  have jin: "j \<in> set [low..<up]" using assms by auto
+  have lnin: "l \<notin> set [low..<up]" using assms by auto
+  thus ?thesis 
+    using add_col_to_multiple_index_change d jin assms by blast
+qed
+
+text \<open> Operations specifically on 1st row/column \<close>
+
+lemma add_first_row_to_multiple_index: 
+  assumes "i < dim_row M" and "j < dim_col M"
+  shows "i = 0 \<Longrightarrow> (add_row_to_multiple a [1..<dim_row M] 0 M) $$ (i, j) = M $$ (i, j)" 
+  and "i \<noteq> 0 \<Longrightarrow> (add_row_to_multiple a [1..<dim_row M] 0 M) $$ (i, j) = (a * M$$(0, j)) + M$$(i,j)"
+  using assms add_row_to_multiple_index_change_bounds[of i "M" j 1 "dim_row M" 0 "a"] by (simp,linarith)
+
+lemma add_all_cols_to_first:
+  assumes "i < dim_row (M)"
+  assumes "j < dim_col (M)"
+  shows "j \<noteq> 0 \<Longrightarrow> add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j)  = M $$ (i, j)" 
+  and "j = 0 \<Longrightarrow> add_multiple_cols 1 0 [1..<dim_col M] M $$ (i, j) = (\<Sum>l = 1..<dim_col M.  M $$(i,l)) + M$$(i,0)"
+  using assms add_multiple_cols_index_eq_bounds[of "i" "M" "j" "1" "dim_col M" "1"] assms by (simp_all)
+
+text \<open>Lemmas on the determinant of the matrix under extended row/column operations \<close>
+
+lemma add_row_to_multiple_carrier: 
+  "A \<in> carrier_mat n n \<Longrightarrow> add_row_to_multiple a ks l A \<in> carrier_mat n n"
+  by (metis add_row_to_multiple_dim(1) add_row_to_multiple_dim(2) carrier_matD(1) carrier_matD(2) carrier_matI)
+
+lemma add_col_to_multiple_carrier: 
+  "A \<in> carrier_mat n n \<Longrightarrow> add_col_to_multiple a ks l A \<in> carrier_mat n n"
+  by (metis add_col_to_multiple_dim carrier_matD(1) carrier_matD(2) carrier_matI)
+
+lemma add_multiple_rows_carrier: 
+  "A \<in> carrier_mat n n \<Longrightarrow> add_multiple_rows a k ls A \<in> carrier_mat n n"
+  by (metis add_multiple_rows_dim carrier_matD(1) carrier_matD(2) carrier_matI)
+
+lemma add_multiple_cols_carrier: 
+  "A \<in> carrier_mat n n \<Longrightarrow> add_multiple_cols a k ls A \<in> carrier_mat n n"
+  by (metis add_multiple_cols_dim carrier_matD(1) carrier_matD(2) carrier_matI)
+
+lemma add_row_to_multiple_det:
+  assumes "l \<notin> set ks" and "l < n" and "A \<in> carrier_mat n n"
+  shows "det (add_row_to_multiple a ks l A) = det A"
+  using assms
+proof (induct ks)
+  case Nil
+  then show ?case by simp
+next
+  case (Cons aa ks)
+  have ne: "aa \<noteq> l"
+    using Cons.prems(1) by auto 
+  have "det (add_row_to_multiple a (aa # ks) l A) = det (addrow a aa l (add_row_to_multiple a ks l A))" 
+    by simp
+  also have "... = det (add_row_to_multiple a ks l A)" 
+    by (meson det_addrow add_row_to_multiple_carrier ne assms)
+  finally have "det (add_row_to_multiple a (aa # ks) l A) = det A" 
+    using Cons.hyps assms by (metis Cons.prems(1) list.set_intros(2))
+  then show ?case by simp
+qed
+
+lemma add_col_to_multiple_det:
+  assumes "l \<notin> set ks" and "l < n" and "A \<in> carrier_mat n n"
+  shows "det (add_col_to_multiple a ks l A) = det A"
+  using assms
+proof (induct ks)
+  case Nil
+  then show ?case by simp
+next
+  case (Cons aa ks)
+  have ne: "aa \<noteq> l"
+    using Cons.prems(1) by auto 
+  have "det (add_col_to_multiple a (aa # ks) l A) = det (addcol a aa l (add_col_to_multiple a ks l A))" 
+    by simp
+  also have "... = det (add_col_to_multiple a ks l A)" 
+    by (meson det_addcol add_col_to_multiple_carrier ne assms)
+  finally have "det (add_col_to_multiple a (aa # ks) l A) = det A" 
+    using Cons.hyps assms by (metis Cons.prems(1) list.set_intros(2))
+  then show ?case by simp
+qed
+
+lemma add_multiple_cols_det:
+  assumes "k \<notin> set ls" and "\<And>l. l \<in> set ls \<Longrightarrow> l < n" and "A \<in> carrier_mat n n"
+  shows "det (add_multiple_cols a k ls A) = det A"
+  using assms
+proof (induct ls)
+  case Nil
+  then show ?case by simp
+next
+  case (Cons aa ls)
+  have ne: "aa \<noteq> k"
+    using Cons.prems(1) by auto 
+  have "det (add_multiple_cols a k (aa # ls) A) = det (addcol a k aa (add_multiple_cols a k ls A))" 
+    by simp
+  also have "... = det (add_multiple_cols a k ls A)" 
+    using det_addcol add_multiple_cols_carrier ne assms by (metis Cons.prems(2) list.set_intros(1)) 
+  finally have "det (add_multiple_cols a k (aa # ls) A) = det A" 
+    using Cons.hyps assms by (metis Cons.prems(1) Cons.prems(2) list.set_intros(2)) 
+  then show ?case by simp
+qed
+
+lemma add_multiple_rows_det:
+  assumes "k \<notin> set ls" and "\<And>l. l \<in> set ls \<Longrightarrow> l < n" and "A \<in> carrier_mat n n"
+  shows "det (add_multiple_rows a k ls A) = det A"
+  using assms
+proof (induct ls)
+  case Nil
+  then show ?case by simp
+next
+  case (Cons aa ls)
+  have ne: "aa \<noteq> k"
+    using Cons.prems(1) by auto 
+  have "det (add_multiple_rows a k (aa # ls) A) = det (addrow a k aa (add_multiple_rows a k ls A))" 
+    by simp
+  also have "... = det (add_multiple_rows a k ls A)" 
+    using det_addrow add_multiple_rows_carrier ne assms by (metis Cons.prems(2) list.set_intros(1)) 
+  finally have "det (add_multiple_rows a k (aa # ls) A) = det A" 
+    using Cons.hyps assms by (metis Cons.prems(1) Cons.prems(2) list.set_intros(2)) 
+  then show ?case by simp
+qed
+
+subsection \<open>Rank and Linear Independence\<close>
+
+abbreviation "rank v M \<equiv> vec_space.rank v M"
+
+text \<open>Basic lemma: the rank of the multiplication of two matrices will be less than the minimum
+of the individual ranks of those matrices. This directly follows from an existing lemmas in the 
+linear algebra library which show independently that the resulting matrices rank is less than either
+the right or left matrix rank in the product \<close>
+lemma rank_mat_mult_lt_min_rank_factor: 
+  fixes A :: "'a::{conjugatable_ordered_field} mat"
+  assumes "A \<in> carrier_mat n m"
+  assumes "B \<in> carrier_mat m nc" 
+  shows "rank n (A * B) \<le> min (rank n A) (rank m B)"
+proof -
+  have 1: "rank n (A * B) \<le> (rank n A)"
+    using assms(1) assms(2) vec_space.rank_mat_mul_right by blast 
+  have "rank n (A* B) \<le> rank m B" 
+    by (meson assms(1) assms(2) rank_mat_mul_left) 
+  thus ?thesis using 1 by simp
+qed
+
+text \<open>Rank Argument 1: Given two a $x \times y$ matrix $M$ where $MM^T$ has rank x, $x \le y$\<close>
+lemma rank_argument: 
+  fixes M :: "('c :: {conjugatable_ordered_field}) mat"
+  assumes "M \<in> carrier_mat x y"
+  assumes "vec_space.rank x (M* M\<^sup>T) = x"
+  shows "x \<le> y"
+proof -
+  let ?B = "(M * M\<^sup>T)"
+  have Mt_car: "M\<^sup>T \<in> carrier_mat y x" using assms by simp
+  have b_car: "?B \<in> carrier_mat x x"
+    using transpose_carrier_mat assms by simp
+  then have "rank x ?B \<le> min (rank x M) (rank y M\<^sup>T)" 
+    using rank_mat_mult_lt_min_rank_factor Mt_car b_car assms(1) by blast
+  thus ?thesis using le_trans vec_space.rank_le_nc 
+    by (metis assms(1) assms(2) min.bounded_iff)
+qed
+
+
+text \<open>Generalise the rank argument to use the determinant. If the determinant of the matrix
+is non-zero, than it's rank must be equal to $x$. This removes the need for someone to use
+facts on rank in their proofs. \<close>
+lemma rank_argument_det: 
+  fixes M :: "('c :: {conjugatable_ordered_field}) mat"
+  assumes "M \<in> carrier_mat x y"
+  assumes "det (M* M\<^sup>T) \<noteq> 0"
+  shows "x \<le> y"
+proof -
+  let ?B = "(M * M\<^sup>T)"
+  have Mt_car: "M\<^sup>T \<in> carrier_mat y x" using assms by simp
+  have b_car: "?B \<in> carrier_mat x x"
+    using transpose_carrier_mat assms by simp
+  then have b_rank: "vec_space.rank x ?B = x"
+    using vec_space.low_rank_det_zero assms(2) by blast
+  then have "rank x ?B \<le> min (rank x M) (rank y M\<^sup>T)" 
+    using rank_mat_mult_lt_min_rank_factor Mt_car b_car assms(1) by blast
+  thus ?thesis using le_trans vec_space.rank_le_nc 
+    by (metis assms(1) b_rank min.bounded_iff)
+qed
+
+end
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/Set_Multiset_Extras.thy b/thys/Fishers_Inequality/Set_Multiset_Extras.thy
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/Set_Multiset_Extras.thy
@@ -0,0 +1,283 @@
+(* Title: Set_Multiset_Extras.thy
+   Author: Chelsea Edmonds
+*)
+
+section \<open>Micellaneous Multset/Set Extras \<close>
+
+theory Set_Multiset_Extras imports Design_Theory.Multisets_Extras "HOL-Combinatorics.Multiset_Permutations"
+begin
+
+subsection \<open> Set extras \<close>
+text \<open> Minor set extras on cardinality and filtering \<close>
+lemma equal_card_inter_fin_eq_sets: "finite A \<Longrightarrow> finite B \<Longrightarrow> card A = card B \<Longrightarrow> 
+  card (A \<inter> B) = card A \<Longrightarrow> A = B"
+  by (metis Int_lower1 Int_lower2 card_subset_eq)
+
+lemma insert_filter_set_true: "P x \<Longrightarrow> {a \<in> (insert x A) . P a} = insert x {a \<in> A . P a}"
+  by auto
+
+lemma insert_filter_set_false: "\<not> P x \<Longrightarrow> {a \<in> (insert x A) . P a} = {a \<in> A . P a}"
+  by auto  
+
+
+subsection \<open>Multiset Extras \<close>
+text \<open> Minor multiset extras on size and element reasoning \<close> 
+
+lemma obtain_two_items_mset: 
+  assumes "size A > 1"
+  obtains x y where "x \<in># A" and "y \<in># A - {#x#}"
+proof -
+  obtain x where "x \<in># A"
+    by (metis assms gr_implies_not_zero multiset_nonemptyE size_empty) 
+  have "size (A - {#x#}) > 0"
+    by (metis \<open>x \<in># A\<close> assms insert_DiffM less_irrefl_nat nonempty_has_size size_single)
+  then obtain bl2 where "bl2 \<in># A - {#x#}"
+    by (metis less_not_refl multiset_nonemptyE size_empty)
+  thus ?thesis
+    using \<open>x \<in># A\<close> that by blast 
+qed
+
+lemma obtain_two_items_mset_filter: 
+  assumes "size {#a \<in># A . P a #} > 1"
+  obtains x y where "x \<in># A" and "y \<in># A - {#x#}" and "P x" and "P y"
+proof -
+  obtain x y where xin: "x \<in># {#a \<in># A . P a #}" and yin: "y \<in># {#a \<in># A . P a #} - {#x#}"
+    using obtain_two_items_mset assms by blast
+  then have xdets: "x \<in># A" "P x" by auto
+  then have yin2: "y \<in># {#a \<in># (A - {#x#}) . P a #}" using yin
+    by force 
+  then have "y \<in># (A - {#x#})" "P y"
+    by (metis multiset_partition union_iff) (meson yin2 filter_mset_eq_conv) 
+  thus ?thesis using xdets that by blast
+qed
+
+lemma size_count_mset_ss: 
+  assumes "finite B"
+  assumes "(set_mset A) \<subseteq> B"
+  shows "size A = (\<Sum> x \<in> B . count A x)"
+proof -
+  obtain C where cdef: "B - (set_mset A) = C" using assms
+    by simp
+  have fin: "finite (set_mset A)" using assms by auto
+  have un: "C \<union> (set_mset A) = B"
+    using Diff_partition \<open>B - set_mset A = C\<close> assms by blast 
+  have disj: "C \<inter> (set_mset A) = {}"
+    using \<open>B - set_mset A = C\<close> by auto 
+  have zero: "\<And> x . x\<in> C \<Longrightarrow> count A x = 0"
+    by (meson count_eq_zero_iff disj disjoint_iff_not_equal) 
+  then have "(\<Sum> x \<in> B . count A x) = (\<Sum> x \<in> (C \<union> set_mset A) . count A x)" using un by simp
+  also have "... = (\<Sum> x \<in> C . count A x) + (\<Sum> x \<in> (set_mset A) . count A x) " 
+    using disj fin assms cdef sum.subset_diff by (metis un) 
+  also have "... = (\<Sum> x \<in> (set_mset A) . count A x)" using zero by auto
+  finally have "(\<Sum> x \<in> B . count A x) = size A"
+    by (simp add: size_multiset_overloaded_eq)
+  thus ?thesis by simp
+qed
+
+lemma mset_list_by_index: "mset (xs) = image_mset (\<lambda> i . (xs ! i)) (mset_set {..<length xs})"
+  by (metis map_nth mset_map mset_set_upto_eq_mset_upto)
+
+lemma count_mset_split_image_filter: 
+  assumes "\<And> x. x \<in>#A \<Longrightarrow> a \<noteq> g x"
+  shows "count (image_mset (\<lambda>x. if P x then a else g x) A ) a = size (filter_mset P A)"
+  using image_mset_If image_mset_filter_swap size_image_mset 
+  by (smt (verit) assms count_size_set_repr filter_mset_cong) 
+
+lemma count_mset_split_image_filter_not: 
+  assumes "\<And> x. x \<in>#A \<Longrightarrow> b \<noteq> f x"
+  shows "count (image_mset (\<lambda>x. if P x then f x else b) A ) b = size (filter_mset (\<lambda> x. \<not> P x) A)"
+  using image_mset_If image_mset_filter_swap size_image_mset
+  by (smt (verit) assms count_size_set_repr filter_mset_cong) 
+
+lemma removeAll_size_lt: "size (removeAll_mset C M) \<le> size M"
+  by (simp add: size_mset_mono)
+
+lemma mset_image_eq_filter_eq: "A = image_mset f B \<Longrightarrow> 
+  filter_mset P A = (image_mset f (filter_mset (\<lambda> x. P (f x)) B))"
+  by (simp add: filter_mset_image_mset)
+
+subsection \<open>Permutation on Sets and Multisets \<close>
+
+lemma elem_permutation_of_set_empty_iff: "finite A \<Longrightarrow> xs \<in> permutations_of_set A \<Longrightarrow> 
+    xs = [] \<longleftrightarrow> A = {}"
+  using permutations_of_setD(1) by fastforce
+
+lemma elem_permutation_of_mset_empty_iff: "xs \<in> permutations_of_multiset A \<Longrightarrow> xs = [] \<longleftrightarrow> A = {#}"
+  using permutations_of_multisetD by fastforce
+
+subsection \<open> Lists \<close>
+text \<open>Further lemmas on the relationship between lists and multisets \<close>
+
+lemma count_distinct_mset_list_index: "i1 < length xs \<Longrightarrow> i2 < length xs \<Longrightarrow> i1 \<noteq> i2 \<Longrightarrow>
+    distinct_mset (mset xs) \<Longrightarrow> xs ! i1 \<noteq> xs ! i2"
+  by (simp add:  nth_eq_iff_index_eq) 
+
+lemma index_remove1_mset_ne: 
+  assumes "x \<in># (mset xs)"
+  assumes "y \<in># remove1_mset x (mset xs)"
+  assumes "xs ! j1 = x"
+  assumes "j1 < length xs"
+  obtains j2 where "xs ! j2 = y" and "j2 < length xs" and "j1 \<noteq> j2"
+proof (cases "x = y")
+  case True
+  then have "count (mset xs) x \<ge> 2"
+    using assms(2) count_eq_zero_iff by fastforce 
+  then have crm: "count (remove1_mset x (mset xs)) x \<ge> 1"
+    by (metis True assms(2) count_greater_eq_one_iff)  
+  obtain ys zs where xseq: "xs = ys @ (x # zs)" and yseq: "ys = take j1 xs" and zseq: "zs = drop (Suc j1) xs"
+    using  assms(1) assms(3) id_take_nth_drop in_mset_conv_nth assms(4) by blast 
+  have "mset xs = mset ys + mset (x # zs)"
+    by (simp add: xseq)
+  then have "remove1_mset x (mset xs) = mset (ys) + mset (zs)"
+    using assms by simp  
+  then have "y \<in># (mset ys + mset zs)" using crm
+    using True \<open>remove1_mset x (mset xs) = mset ys + mset zs\<close> assms(2) by presburger 
+  then have yinor: "y \<in># mset ys \<or> y \<in># mset zs" by simp
+  then show ?thesis proof (cases "y \<in># mset ys")
+    case True
+    then obtain j2 where yeq: "ys ! j2 = y" and j2lt: "j2 < length ys"
+      by (meson in_mset_conv_nth)
+    then have 1: "xs ! j2 = y" using yseq by simp 
+    have "j2 < j1" using yseq j2lt by simp
+    then show ?thesis using that 1 j2lt xseq by simp
+  next
+    case False
+    then have "y \<in># mset zs" using yinor by simp
+    then obtain j2 where zsy: "zs ! j2 = y" and j2lt: "j2 < length zs"
+      by (meson in_mset_conv_nth) 
+    then have 1: "xs ! ((Suc j1) + j2) = y" using zseq zsy assms(4) by simp
+    have "length xs = (Suc j1) + length zs" using zseq xseq
+      by (metis Suc_diff_Suc add_Suc_shift add_diff_inverse_nat assms(4) length_drop less_imp_not_less) 
+    then have 2: "(Suc j1) + j2 < length xs" using j2lt by simp
+    then show ?thesis using 1 that by simp
+  qed
+next
+  case False
+  then show ?thesis
+    by (metis that assms(2) assms(3) in_diffD in_mset_conv_nth) 
+qed
+
+lemma count_list_mset: "count_list xs x = count (mset xs) x"
+proof (induct xs)
+  case Nil
+  then show ?case by simp
+next
+  case (Cons a xs)
+  then show ?case proof (cases "a = x")
+    case True
+    have mset_add_split: "count (mset (a # xs)) x = count (add_mset a (mset xs)) x"
+      by simp
+    then have "count (mset (a # xs)) x = count (mset xs) x + 1"
+      by (metis True Suc_eq_plus1 count_add_mset) 
+    then show ?thesis using True Cons.hyps by simp
+  next
+    case False
+    then show ?thesis using Cons.hyps by simp
+  qed
+qed
+
+lemma count_min_2_indices_lt: 
+  assumes "i1 < i2"
+  assumes "xs ! i1 = x"
+  assumes "xs ! i2 = x"
+  assumes "i1 < length xs" "i2 < length xs"
+  shows "count (mset xs) x \<ge> 2"
+proof -
+  obtain xs1 xs2 where xse: "xs = xs1 @ xs2" and xs1: "xs1 = take i2 xs" and xs2: "xs2 = drop i2 xs"
+    by simp
+  have "i1 < length xs1" using assms length_take
+    by (simp add: assms(4) \<open>xs1 = take i2 xs\<close>) 
+  then have xs1in:  "xs ! i1 \<in># mset xs1"
+    by (simp add: nth_append xse) 
+  have "i2 \<ge> length xs1" using assms length_take xs1 by simp
+  then have xs2in: "xs ! i2 \<in># mset xs2" using xse nth_append
+    by (metis (no_types, lifting) assms(5) in_mset_conv_nth leD leI take_all_iff take_append)
+  have "count (mset xs) x = count ((mset xs1) + (mset xs2)) x"
+    by (simp add: xse) 
+  then have "count (mset xs) x = count (mset xs1) x + count (mset xs2) x" by simp
+  thus ?thesis using xs1in xs2in
+    by (metis add_mono assms(2) assms(3) count_greater_eq_one_iff nat_1_add_1) 
+qed
+
+lemma count_min_2_indices: "i1 \<noteq> i2 \<Longrightarrow> xs ! i1 = x \<Longrightarrow> xs ! i2 = x \<Longrightarrow> i1 < length xs \<Longrightarrow> 
+  i2 < length xs \<Longrightarrow> count (mset xs) x \<ge> 2"
+  apply (cases "i1 < i2", simp add: count_min_2_indices_lt)
+  by (metis count_min_2_indices_lt linorder_cases) 
+
+lemma obtain_set_list_item: 
+  assumes "x \<in> set xs"
+  obtains i where "i < length xs" and "xs ! i = x"
+  by (meson assms in_set_conv_nth)
+
+subsection \<open>Summation Rules\<close>
+
+text \<open> Some lemmas to make it simpler to work with double and triple summations \<close>
+context comm_monoid_add
+begin
+
+lemma sum_reorder_triple: "(\<Sum> l \<in> A . (\<Sum> i \<in> B . (\<Sum> j \<in> C . g l i j))) = 
+  (\<Sum> i \<in> B . (\<Sum> j \<in> C . (\<Sum> l \<in> A . g l i j)))"
+proof -
+  have "(\<Sum> l \<in> A . (\<Sum> i \<in> B . (\<Sum> j \<in> C . g l i j))) = (\<Sum>i \<in> B . (\<Sum> l \<in> A  . (\<Sum> j \<in> C . g l i j)))"
+    using sum.swap[of "(\<lambda> l i . (\<Sum> j \<in> C . g l i j))" "B" "A"] by simp
+  also have "...  = (\<Sum>i \<in> B . (\<Sum> j \<in> C . (\<Sum>l \<in> A . g l i j)))" using sum.swap by metis
+  finally show ?thesis by simp
+qed
+
+lemma double_sum_mult_hom: 
+  fixes k :: "'b :: {comm_ring_1}"
+  shows "(\<Sum> i \<in> A . (\<Sum> j \<in> g i . k * (f i j))) = k* (\<Sum> i \<in> A . (\<Sum> j \<in> g i . f i j))"
+  by (metis (mono_tags, lifting) comm_monoid_add_class.sum.cong sum_distrib_left)
+
+lemma double_sum_split_case: 
+  assumes "finite A"
+  shows "(\<Sum> i \<in> A . (\<Sum> j \<in> A . f i j)) = (\<Sum> i \<in> A . (f i i)) + (\<Sum> i \<in> A . (\<Sum> j \<in> (A - {i}) . f i j))" 
+proof -
+  have "\<And> i. i \<in> A \<Longrightarrow> (\<Sum> j \<in> A . f i j) = f i i + (\<Sum> j \<in> (A - {i}) . f i j)" 
+    using sum.remove assms by metis 
+  then show ?thesis by (simp add: sum.distrib) 
+qed
+               
+lemma double_sum_split_case2: "(\<Sum> i \<in> A . (\<Sum> j \<in> A . g i j)) = 
+  (\<Sum> i \<in> A . (g i i)) + (\<Sum> i \<in> A . (\<Sum> j \<in> {a \<in> A . a \<noteq> i} . g i j)) " 
+proof - 
+  have "\<And> i. A = {a \<in> A . a = i} \<union> {a \<in> A . a \<noteq> i}" by auto
+  then have part: "\<And> i. i \<in> A \<Longrightarrow> A = {i} \<union> {a \<in> A . a \<noteq> i}" by auto
+  have empt:"\<And> i. {i} \<inter> {a \<in> A . a \<noteq> i} = {}"
+    by simp 
+  then have "(\<Sum> i \<in> A . (\<Sum> j \<in> A . g i j)) = 
+    (\<Sum> i \<in> A . ((\<Sum> j \<in> {i} . g i j) + (\<Sum> j \<in> {a \<in> A . a \<noteq> i} . g i j)))" using part
+    by (smt (verit) finite_Un local.sum.cong local.sum.infinite local.sum.union_disjoint) 
+  also have "... = (\<Sum> i \<in> A . ((\<Sum> j \<in> {i} . g i j))) + (\<Sum> i \<in> A . (\<Sum> j \<in> {a \<in> A . a \<noteq> i} . g i j))"
+    by (simp add: local.sum.distrib) 
+  finally show ?thesis by simp
+qed
+
+end
+
+context comm_ring_1
+begin
+
+lemma double_sum_split_case_square: 
+  assumes "finite A"
+  shows "(\<Sum> i \<in> A . f i )^2 = (\<Sum> i \<in> A . (f i * f i)) + (\<Sum> i \<in> A . (\<Sum> j \<in> (A - {i}) . f i * f j))" 
+proof -
+  have "(\<Sum> i \<in> A . f i )^2 = (\<Sum> i \<in> A . f i) * (\<Sum> i \<in> A . f i)"
+    using power2_eq_square by blast
+  then have "(\<Sum> i \<in> A . f i) * (\<Sum> i \<in> A . f i) = (\<Sum> i \<in> A . f i) * (\<Sum> j \<in> A . f j)" by simp
+  also have 1: "... = (\<Sum> i \<in> A . f i * (\<Sum> j \<in> A . f j))" using sum_distrib_right by simp
+  also have 2: "... = (\<Sum> i \<in> A .  (\<Sum> j \<in> A . f i * f j))" using sum_distrib_left by metis 
+  finally have "(\<Sum> i \<in> A . f i) * (\<Sum> i \<in> A . f i) = 
+    (\<Sum> i \<in> A . (f i * f i)) + (\<Sum> i \<in> A . (\<Sum> j \<in> (A - {i}) . f i * f j))" 
+    using assms double_sum_split_case[of "A" "\<lambda> i j . f i * f j"] 1 2 by presburger 
+  then show ?thesis
+    using power2_eq_square by presburger 
+qed
+
+lemma double_sum_split_square_diff:  "finite {0..<x} \<Longrightarrow> 
+  (\<Sum> i \<in> {0..<x} . (\<Sum> j \<in> ({0..< x} - {i}) . c i * c j)) = 
+  (\<Sum> i \<in> {0..<x} . c i)^2 - (\<Sum> i \<in> {0..<x} . c i * c i)"
+  using double_sum_split_case_square[of "{0..<x}" "\<lambda> i. c i"] by fastforce
+
+end
+end
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/Vector_Matrix_Mod.thy b/thys/Fishers_Inequality/Vector_Matrix_Mod.thy
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/Vector_Matrix_Mod.thy
@@ -0,0 +1,533 @@
+(* Title: Vector_Matrix_Mod.thy
+   Author: Chelsea Edmonds
+*)
+
+section \<open> Matrices/Vectors mod x \<close>
+text \<open> This section formalises operations and properties mod some integer x on integer matrices and 
+vectors. Much of this file was no longer needed for fishers once the generic idea of lifting a 0-1 matrix
+was introduced, however it is left as an example for future work on matrices mod n, beyond 0-1 matrices  \<close>
+theory Vector_Matrix_Mod imports Matrix_Vector_Extras
+Berlekamp_Zassenhaus.Finite_Field Berlekamp_Zassenhaus.More_Missing_Multiset  
+begin
+
+text \<open>Simple abbreviations for main mapping functions \<close>
+abbreviation to_int_mat :: "'a :: finite mod_ring mat \<Rightarrow> int mat" where
+  "to_int_mat \<equiv> map_mat to_int_mod_ring"
+
+abbreviation to_int_vec :: "'a :: finite mod_ring vec \<Rightarrow> int vec" where
+"to_int_vec \<equiv> map_vec to_int_mod_ring"
+
+interpretation of_int_mod_ring_hom_sr: semiring_hom of_int_mod_ring
+proof (unfold_locales)
+  show "\<And>x y. of_int_mod_ring (x + y) = of_int_mod_ring x + of_int_mod_ring y"
+    by (transfer,presburger)
+  show "of_int_mod_ring 1 = 1" by (metis of_int_hom.hom_one of_int_of_int_mod_ring)
+  show "\<And>x y. of_int_mod_ring (x * y) = of_int_mod_ring x * of_int_mod_ring y"
+    by (transfer, simp add: mod_mult_eq) 
+qed
+
+text \<open>NOTE: The context directly below is copied from Matrix Vector Extras, as for some reason 
+they can't be used locally if not? Ideally remove in future if possible \<close>
+
+context inj_zero_hom
+begin
+
+lemma  vec_hom_zero_iff[simp]: "(map_vec hom x = 0\<^sub>v n) = (x = 0\<^sub>v n)"
+proof -
+  {
+    fix i
+    assume i: "i < n" "dim_vec x = n"
+    hence "map_vec hom x $ i = 0 \<longleftrightarrow> x $ i = 0"
+      using index_map_vec(1)[of i x] by simp
+  } note main = this
+  show ?thesis unfolding vec_eq_iff by (simp, insert main, auto)
+qed
+
+lemma  mat_hom_inj: "map_mat hom A = map_mat hom B \<Longrightarrow> A = B"
+  unfolding mat_eq_iff by auto
+
+lemma  vec_hom_inj: "map_vec hom v = map_vec hom w \<Longrightarrow> v = w"
+  unfolding vec_eq_iff by auto
+
+lemma  vec_hom_set_distinct_iff: 
+  fixes xs :: "'a vec list"
+  shows "distinct xs \<longleftrightarrow> distinct (map (map_vec hom) xs)"
+  using vec_hom_inj by (induct xs) (auto)
+end
+
+subsection \<open> Basic Mod Context \<close>
+
+locale mat_mod = fixes m :: int
+assumes non_triv_m: "m > 1"
+begin 
+
+text \<open>First define the mod operations on vectors \<close>
+definition vec_mod :: "int vec \<Rightarrow> int vec" where
+"vec_mod v \<equiv> map_vec (\<lambda> x . x mod m) v"
+
+(* Parse tree ambiguity is caused by bad definitions in the MPoly theory files. Issue raised
+on Isabelle Mailing List *)
+
+lemma vec_mod_dim[simp]: "dim_vec (vec_mod v) = dim_vec v"
+  using vec_mod_def by simp
+
+lemma vec_mod_index[simp]: "i < dim_vec v \<Longrightarrow> (vec_mod v) $ i = (v $ i) mod m"
+  using vec_mod_def by simp
+
+lemma vec_mod_index_same[simp]: "i < dim_vec v \<Longrightarrow> v $ i < m \<Longrightarrow> v $ i \<ge> 0 \<Longrightarrow> (vec_mod v) $ i = v $ i"
+  by simp
+
+lemma vec_setI2: "i < dim_vec v \<Longrightarrow> v $ i \<in> set\<^sub>v v"
+  by (simp add: vec_setI) 
+
+lemma vec_mod_eq: "set\<^sub>v v \<subseteq> {0..<m} \<Longrightarrow> vec_mod v = v"
+  apply (intro eq_vecI, simp_all)
+  using vec_setI2 vec_mod_index_same by (metis atLeastLessThan_iff subset_iff zmod_trivial_iff) 
+
+lemma vec_mod_set_vec_same:"set\<^sub>v v \<subseteq> {0..<m} \<Longrightarrow> set\<^sub>v (vec_mod v) = set\<^sub>v v"
+  using vec_mod_eq by auto
+
+text \<open>Define the mod operation on matrices \<close>
+
+definition mat_mod :: "int mat \<Rightarrow> int mat"  where 
+"mat_mod M \<equiv> map_mat (\<lambda> x. x mod m) M"
+
+lemma mat_mod_dim[simp]: "dim_row (mat_mod M) = dim_row M" "dim_col (mat_mod M) = dim_col M"
+  using mat_mod_def by simp_all
+
+lemma mat_mod_index [simp]:  "i < dim_row M \<Longrightarrow> j < dim_col M \<Longrightarrow> (mat_mod M) $$ (i, j) = (M $$ (i, j)) mod m"
+  by(simp add: mat_mod_def)
+
+lemma mat_mod_index_same[simp]: "i < dim_row M \<Longrightarrow> j < dim_col M \<Longrightarrow> M $$ (i, j) < m \<Longrightarrow> 
+    M $$ (i, j) \<ge> 0 \<Longrightarrow> mat_mod M $$ (i, j) = M $$ (i, j)"
+  by (simp add: mat_mod_def)
+
+lemma elements_matI2: "i < dim_row A \<Longrightarrow> j < dim_col A \<Longrightarrow> A $$ (i, j) \<in> elements_mat A"
+  by auto
+
+lemma mat_mod_elements_in: 
+  assumes "x \<in> elements_mat M"
+  shows "x mod m \<in> elements_mat (mat_mod M)"
+proof - 
+  obtain i j where "M $$ (i, j) = x" and ilt: "i < dim_row M" and jlt: "j < dim_col M" using assms by auto
+  then have "mat_mod M $$ (i, j) = x mod m" by simp
+  thus ?thesis using ilt jlt
+    by (metis elements_matI2 mat_mod_dim(1) mat_mod_dim(2)) 
+qed
+
+lemma mat_mod_elements_map: 
+  assumes "x \<in> elements_mat M"
+  shows "elements_mat (mat_mod M) = (\<lambda> x. x mod m) ` (elements_mat M)"
+proof (auto simp add: mat_mod_elements_in)
+  fix x assume "x \<in> elements_mat (local.mat_mod M)"
+  then obtain i j where "(mat_mod M) $$ (i, j) = x" and "i < dim_row (mat_mod M)" and "j < dim_col (mat_mod M)" by auto
+  then show "x \<in> (\<lambda>x. x mod m) ` elements_mat M"
+    by auto  
+qed
+
+lemma mat_mod_eq_cond:
+  assumes "elements_mat M \<subseteq> {0..<m}"
+  shows "mat_mod M = M"
+proof (intro eq_matI, simp_all)
+  fix i j assume "i < dim_row M" "j < dim_col M"
+  then have "M $$ (i, j) \<in> {0..<m}"
+    using assms elements_matI2 by blast 
+  then show "M $$ (i, j) mod m = M $$ (i, j)"
+    by (simp) 
+qed
+
+lemma mat_mod_eq_elements_cond: "elements_mat M \<subseteq> {0..<m} \<Longrightarrow> elements_mat (mat_mod M) = elements_mat M"
+  using mat_mod_eq_cond by auto
+
+lemma mat_mod_vec_mod_row:  "i < dim_row A \<Longrightarrow> row (mat_mod A) i = vec_mod (row A i)"
+  unfolding mat_mod_def vec_mod_def by (simp) 
+
+lemma mat_mod_vec_mod_col:  "j < dim_col A \<Longrightarrow> col (mat_mod A) j = vec_mod (col A j)"
+  unfolding mat_mod_def vec_mod_def by (simp) 
+
+lemma count_vec_mod_eq: "set\<^sub>v v \<subseteq> {0..<m} \<Longrightarrow> count_vec v x = count_vec (vec_mod v) x"
+  using vec_mod_eq by (simp) 
+
+lemma elems_mat_setv_row_0m: "i < dim_row M \<Longrightarrow> elements_mat M \<subseteq> {0..<m} \<Longrightarrow> set\<^sub>v (row M i) \<subseteq> {0..<m}"
+  by (metis row_elems_subset_mat subset_trans)
+
+lemma elems_mat_setv_col_0m: "j < dim_col M \<Longrightarrow> elements_mat M \<subseteq> {0..<m} \<Longrightarrow> set\<^sub>v (col M j) \<subseteq> {0..<m}"
+  by (metis col_elems_subset_mat subset_trans)
+
+lemma mat_mod_count_row_eq:  "i < dim_row M \<Longrightarrow> elements_mat M \<subseteq> {0..<m} \<Longrightarrow> 
+    count_vec (row (mat_mod M) i) x = count_vec (row M i) x"
+  using count_vec_mod_eq mat_mod_vec_mod_row elems_mat_setv_row_0m by simp
+
+lemma mat_mod_count_col_eq: "j < dim_col M \<Longrightarrow> elements_mat M \<subseteq> {0..<m} \<Longrightarrow> 
+    count_vec (col (mat_mod M) j) x = count_vec (col M j) x"
+  using count_vec_mod_eq mat_mod_vec_mod_col elems_mat_setv_col_0m by simp
+
+lemma mod_mat_one: "mat_mod (1\<^sub>m n) = (1\<^sub>m n)"
+  by (intro eq_matI, simp_all add: mat_mod_def non_triv_m)
+
+lemma mod_mat_zero: "mat_mod (0\<^sub>m nr nc) = (0\<^sub>m nr nc)"
+  by (intro eq_matI, simp_all add: mat_mod_def non_triv_m)
+
+lemma vec_mod_unit: "vec_mod (unit_vec n i) = (unit_vec n i)"
+  by (intro eq_vecI, simp_all add: unit_vec_def vec_mod_def non_triv_m)
+
+lemma vec_mod_zero: "vec_mod (0\<^sub>v n) = (0\<^sub>v n)"
+  by (intro eq_vecI, simp_all add: non_triv_m)
+
+lemma mat_mod_cond_iff: "elements_mat M \<subseteq> {0..<m} \<Longrightarrow> P M \<longleftrightarrow> P (mat_mod M)"
+  by (simp add: mat_mod_eq_cond)
+
+end
+
+subsection \<open>Mod Type \<close>
+text \<open> The below locale takes lemmas from the Poly Mod Finite Field theory in the Berlekamp Zassenhaus
+AFP entry, however has removed any excess material on polynomials mod, and only included the general 
+factors. Ideally, this could be used as the base locale for both in the future \<close>
+
+locale mod_type =
+  fixes m :: int and ty :: "'a :: nontriv itself"
+  assumes m: "m = CARD('a)"
+begin
+
+lemma m1: "m > 1" using nontriv[where 'a = 'a] by (auto simp:m)
+
+definition M :: "int \<Rightarrow> int" where "M x = x mod m" 
+
+lemma M_0[simp]: "M 0 = 0"
+  by (auto simp add: M_def)
+
+lemma M_M[simp]: "M (M x) = M x"
+  by (auto simp add: M_def)
+
+lemma M_plus[simp]: "M (M x + y) = M (x + y)" "M (x + M y) = M (x + y)"
+  by (auto simp add: M_def mod_simps)
+  
+lemma M_minus[simp]: "M (M x - y) = M (x - y)" "M (x - M y) = M (x - y)" 
+  by (auto simp add: M_def mod_simps)
+
+lemma M_times[simp]: "M (M x * y) = M (x * y)" "M (x * M y) = M (x * y)"
+  by (auto simp add: M_def mod_simps)
+
+lemma M_1[simp]: "M 1 = 1" unfolding M_def
+  using m1 by auto
+
+lemma M_sum: "M (sum (\<lambda> x. M (f x)) A) = M (sum f A)"
+proof (induct A rule: infinite_finite_induct) 
+  case (insert x A)
+  from insert(1-2) have "M (\<Sum>x\<in>insert x A. M (f x)) = M (f x + M ((\<Sum>x\<in>A. M (f x))))" by simp
+  also have "M ((\<Sum>x\<in>A. M (f x))) = M ((\<Sum>x\<in>A. f x))" using insert by simp
+  finally show ?case using insert by simp
+qed auto
+
+definition inv_M :: "int \<Rightarrow> int" where
+  "inv_M x = (if x + x \<le> m then x else x - m)" 
+
+lemma M_inv_M_id[simp]: "M (inv_M x) = M x" 
+  unfolding inv_M_def M_def by simp
+
+definition M_Rel :: "int \<Rightarrow> 'a mod_ring \<Rightarrow> bool"
+  where "M_Rel x x' \<equiv> (M x = to_int_mod_ring x')"
+
+lemma to_int_mod_ring_plus: "to_int_mod_ring ((x :: 'a mod_ring) + y) = M (to_int_mod_ring x + to_int_mod_ring y)"
+  unfolding M_def using m by (transfer, auto)
+
+lemma to_int_mod_ring_times: "to_int_mod_ring ((x :: 'a mod_ring) * y) = M (to_int_mod_ring x * to_int_mod_ring y)"
+  unfolding M_def using m by (transfer, auto)
+
+lemma eq_M_Rel[transfer_rule]: "(M_Rel ===> M_Rel ===> (=)) (\<lambda> x y. M x = M y) (=)"
+  unfolding M_Rel_def rel_fun_def by auto
+
+lemma one_M_Rel[transfer_rule]: "M_Rel 1 1"
+  unfolding M_Rel_def M_def
+  unfolding m by auto
+
+lemma zero_M_Rel[transfer_rule]: "M_Rel 0 0"
+  unfolding M_Rel_def M_def 
+  unfolding m by auto
+
+lemma M_to_int_mod_ring: "M (to_int_mod_ring (x :: 'a mod_ring)) = to_int_mod_ring x"
+  unfolding M_def unfolding m by (transfer, auto)
+
+
+lemma right_total_M_Rel[transfer_rule]: "right_total M_Rel"
+  unfolding right_total_def M_Rel_def using M_to_int_mod_ring by blast
+
+lemma left_total_M_Rel[transfer_rule]: "left_total M_Rel"
+  unfolding left_total_def M_Rel_def[abs_def] 
+proof
+  fix x
+  show "\<exists> x' :: 'a mod_ring. M x = to_int_mod_ring x'"  unfolding M_def unfolding m
+    by (rule exI[of _ "of_int x"], transfer, simp)
+qed
+
+lemma bi_total_M_Rel[transfer_rule]: "bi_total M_Rel" 
+  using right_total_M_Rel left_total_M_Rel by (metis bi_totalI)
+
+lemma to_int_mod_ring_of_int_M: "to_int_mod_ring (of_int x :: 'a mod_ring) = M x" unfolding M_def
+  unfolding m by transfer auto
+
+lemma UNIV_M_Rel[transfer_rule]: "rel_set M_Rel {0..<m} UNIV"
+  unfolding rel_set_def M_Rel_def[abs_def] M_def 
+  by (auto simp: M_def m, goal_cases, metis to_int_mod_ring_of_int_mod_ring, (transfer, auto)+)
+
+end
+
+subsection \<open> Mat mod type \<close>
+text \<open> Define a context to work on matrices and vectors of type @{typ "'a mod_ring"} \<close>
+
+locale mat_mod_type = mat_mod + mod_type
+begin
+
+lemma to_int_mod_ring_plus: "to_int_mod_ring ((x :: 'a mod_ring) + y) = (to_int_mod_ring x + to_int_mod_ring y) mod m"
+   using m by (transfer, auto)
+
+lemma to_int_mod_ring_times: "to_int_mod_ring ((x :: 'a mod_ring) * y) = (to_int_mod_ring x * to_int_mod_ring y) mod m"
+  using m by (transfer, auto)
+
+text \<open> Set up transfer relation for matrices and vectors \<close>
+definition MM_Rel :: "int mat \<Rightarrow> 'a mod_ring mat \<Rightarrow> bool"
+  where "MM_Rel f f' \<equiv> (mat_mod f = to_int_mat f')"
+
+definition MV_Rel :: "int vec \<Rightarrow> 'a mod_ring vec \<Rightarrow> bool"
+  where "MV_Rel v v' \<equiv> (vec_mod v = to_int_vec v')"
+
+lemma to_int_mat_index[simp]: "i < dim_row N \<Longrightarrow> j < dim_col N \<Longrightarrow> (to_int_mat N $$ (i, j)) = to_int_mod_ring (N $$ (i, j))"
+  by simp
+
+lemma to_int_vec_index[simp]: "i < dim_vec v  \<Longrightarrow> (to_int_vec v $i) = to_int_mod_ring (v $i)"
+  by simp
+
+lemma eq_dim_row_MM_Rel[transfer_rule]: "(MM_Rel ===> (=)) dim_row dim_row "
+  by (metis (mono_tags) MM_Rel_def index_map_mat(2) mat_mod_dim(1) rel_funI)
+
+lemma lt_dim_row_MM_Rel[transfer_rule]: "(MM_Rel ===> (=) ===> (=)) (\<lambda> M i. i < dim_row M) (\<lambda> M i. i < dim_row M)"
+  using eq_dim_row_MM_Rel unfolding MM_Rel_def rel_fun_def by auto
+
+lemma eq_dim_col_MM_Rel[transfer_rule]: "(MM_Rel ===> (=)) dim_col dim_col "
+  unfolding MM_Rel_def rel_fun_def
+  by (metis index_map_mat(3) mat_mod_dim(2)) 
+
+lemma lt_dim_col_MM_Rel[transfer_rule]: "(MM_Rel ===> (=) ===> (=)) (\<lambda> M j. j < dim_col M) (\<lambda> M j. j < dim_col M)"
+  using eq_dim_col_MM_Rel unfolding MM_Rel_def rel_fun_def by auto
+
+lemma eq_dim_vec_MV_Rel[transfer_rule]: "(MV_Rel ===> (=)) dim_vec dim_vec"
+  unfolding MV_Rel_def rel_fun_def using index_map_vec(2) vec_mod_dim by metis
+
+lemma lt_dim_vec_MV_Rel[transfer_rule]: "(MV_Rel ===> (=) ===> (=)) (\<lambda> v j. j < dim_vec v) (\<lambda> v j. j < dim_vec v)"
+  unfolding MV_Rel_def rel_fun_def using index_map_vec(2) vec_mod_dim by metis
+
+lemma eq_MM_Rel[transfer_rule]: "(MM_Rel ===> MM_Rel ===> (=)) (\<lambda> f f' . mat_mod f = mat_mod f') (=) "
+  unfolding MM_Rel_def rel_fun_def using to_int_mod_ring_hom.mat_hom_inj by (auto)
+
+lemma eq_MV_Rel[transfer_rule]: "(MV_Rel ===> MV_Rel ===> (=)) (\<lambda> v v' . vec_mod v = vec_mod v') (=) " 
+  unfolding MV_Rel_def rel_fun_def using to_int_mod_ring_hom.vec_hom_inj by auto
+
+
+lemma index_MV_Rel[transfer_rule]: "(MV_Rel ===> (=) ===> M_Rel) 
+    (\<lambda> v i. if i < dim_vec v then v $ i else 0) (\<lambda> v i. if i < dim_vec v then v $ i else 0)"
+  using lt_dim_vec_MV_Rel unfolding MV_Rel_def M_Rel_def M_def rel_fun_def 
+  by (simp, metis to_int_vec_index vec_mod_index)
+
+lemma index_MM_Rel[transfer_rule]: "(MM_Rel ===> (=) ===> (=) ===> M_Rel) 
+    (\<lambda> M i j. if (i < dim_row M \<and> j < dim_col M) then M $$ (i, j) else 0)
+   (\<lambda> M i j. if (i < dim_row M \<and> j < dim_col M) then M $$ (i, j) else 0)"
+  using lt_dim_row_MM_Rel lt_dim_col_MM_Rel unfolding  M_Rel_def M_def rel_fun_def 
+  by (simp, metis mat_mod_index to_int_mat_index MM_Rel_def)
+
+lemma index_MM_Rel_explicit: 
+  assumes "MM_Rel N N'"
+  assumes "i < dim_row N" "j < dim_col N"
+  shows "(N $$ (i, j)) mod m = to_int_mod_ring (N' $$ (i, j))"
+proof -
+  have eq: "(to_int_mat N') $$ (i, j) = to_int_mod_ring (N' $$ (i, j))"
+    by (metis MM_Rel_def assms(1) assms(2) assms(3) index_map_mat mat_mod.mat_mod_dim mat_mod_axioms) 
+  have "mat_mod N = to_int_mat N'" using assms by (simp add: MM_Rel_def)
+  then have "(mat_mod N) $$ (i, j) = (to_int_mat N') $$ (i, j)"
+    by simp 
+  thus ?thesis using mat_mod_index eq
+    using assms(2) assms(3) by auto 
+qed
+
+lemma one_MV_Rel[transfer_rule]: "MV_Rel (unit_vec n i) (unit_vec n i)"
+  unfolding MV_Rel_def vec_mod_unit non_triv_m unit_vec_def 
+  by (intro eq_vecI, simp_all add: non_triv_m)
+
+lemma one_MM_Rel[transfer_rule]: "MM_Rel (1\<^sub>m n) (1\<^sub>m n)"
+  unfolding MM_Rel_def mod_mat_one
+  by (intro eq_matI, simp_all)
+
+lemma zero_MM_Rel[transfer_rule]: "MM_Rel (0\<^sub>m nr nc) (0\<^sub>m nr nc)"
+  unfolding MM_Rel_def
+  by (intro eq_matI, simp_all)
+
+lemma zero_MV_Rel[transfer_rule]: "MV_Rel (0\<^sub>v n) (0\<^sub>v n)"
+  unfolding MV_Rel_def by (intro eq_vecI, simp_all)
+
+lemma right_unique_MV_Rel[transfer_rule]: "right_unique MV_Rel"
+  unfolding right_unique_def MV_Rel_def 
+  using to_int_mod_ring_hom.vec_hom_inj by auto
+
+lemma right_unique_MM_Rel[transfer_rule]: "right_unique MM_Rel"
+  unfolding right_unique_def MM_Rel_def 
+  using to_int_mod_ring_hom.mat_hom_inj by auto
+
+lemma mod_to_int_mod_ring: "(to_int_mod_ring (x :: 'a mod_ring)) mod m = to_int_mod_ring x"
+  unfolding m by (transfer, auto)
+
+lemma mat_mod_to_int_mat: "mat_mod (to_int_mat (N :: 'a mod_ring mat)) = to_int_mat N"
+  using mod_to_int_mod_ring by (intro eq_matI, simp_all)
+
+lemma vec_mod_to_int_vec: "vec_mod (to_int_vec (v :: 'a mod_ring vec)) = to_int_vec v"
+  using mod_to_int_mod_ring by (intro eq_vecI, simp_all)
+
+lemma right_total_MM_Rel[transfer_rule]: "right_total MM_Rel"
+  unfolding right_total_def MM_Rel_def
+proof
+  fix M :: "'a mod_ring mat"
+  show "\<exists>x. mat_mod x = to_int_mat M"
+    by (intro exI[of _ "to_int_mat M"], simp add: mat_mod_to_int_mat)
+qed
+
+lemma right_total_MV_Rel[transfer_rule]: "right_total MV_Rel"
+  unfolding right_total_def MV_Rel_def
+proof
+  fix v :: "'a mod_ring vec"
+  show "\<exists>x. vec_mod x = to_int_vec v"
+    by (intro exI[of _ "to_int_vec v"], simp add: vec_mod_to_int_vec)
+qed
+
+lemma to_int_mod_ring_of_int_mod: "to_int_mod_ring (of_int x :: 'a mod_ring) = x mod m"
+  unfolding m by transfer auto
+
+lemma vec_mod_v_representative: "vec_mod v = to_int_vec (map_vec of_int v :: 'a mod_ring vec)"
+  unfolding mat_mod_def by (auto simp: to_int_mod_ring_of_int_mod)
+
+lemma mat_mod_N_representative: "mat_mod N = to_int_mat (map_mat of_int N :: 'a mod_ring mat)"
+  unfolding mat_mod_def by (auto simp: to_int_mod_ring_of_int_mod)
+
+lemma left_total_MV_Rel[transfer_rule]: "left_total MV_Rel"
+  unfolding left_total_def MV_Rel_def[abs_def] using vec_mod_v_representative by blast
+
+lemma left_total_MM_Rel[transfer_rule]: "left_total MM_Rel"
+  unfolding left_total_def MM_Rel_def[abs_def] using mat_mod_N_representative by blast
+
+lemma bi_total_MV_Rel[transfer_rule]: "bi_total MV_Rel"
+  using right_total_MV_Rel left_total_MV_Rel by (metis bi_totalI)
+
+lemma bi_total_MM_Rel[transfer_rule]: "bi_total MM_Rel"
+  using right_total_MM_Rel left_total_MM_Rel by (metis bi_totalI)
+
+lemma domain_MV_rel[transfer_domain_rule]: "Domainp MV_Rel = (\<lambda> f. True)"
+proof
+  fix v :: "int vec"
+  show "Domainp MV_Rel v = True" unfolding MV_Rel_def[abs_def] Domainp.simps
+    by (auto simp: vec_mod_v_representative)
+qed
+
+lemma domain_MM_rel[transfer_domain_rule]: "Domainp MM_Rel = (\<lambda> f. True)"
+proof
+  fix N :: "int mat"
+  show "Domainp MM_Rel N = True" unfolding MM_Rel_def[abs_def] Domainp.simps
+    by (auto simp: mat_mod_N_representative)
+qed
+
+lemma mem_MV_Rel[transfer_rule]: 
+  "(MV_Rel ===> rel_set MV_Rel ===> (=)) (\<lambda> x Y. \<exists>y \<in> Y. vec_mod x = vec_mod y) (\<in>)"
+proof (intro rel_funI iffI)
+  fix x y X Y assume xy: "MV_Rel x y" and XY: "rel_set MV_Rel X Y"
+  { assume "\<exists>x' \<in> X. vec_mod x = vec_mod x'"
+    then obtain x' where x'X: "x' \<in> X" and xx': "vec_mod x = vec_mod x'" by auto
+    with xy have x'y: "MV_Rel x' y" by (auto simp: MV_Rel_def)
+    from rel_setD1[OF XY x'X] obtain y' where "MV_Rel x' y'" and "y' \<in> Y" by auto
+    with x'y
+     show "y \<in> Y" using to_int_mod_ring_hom.vec_hom_inj by (auto simp: MV_Rel_def)
+  }
+  assume "y \<in> Y"
+  from rel_setD2[OF XY this] obtain x' where x'X: "x' \<in> X" and x'y: "MV_Rel x' y" by auto
+  from xy x'y have "vec_mod x = vec_mod x'" by (auto simp: MV_Rel_def)
+  with x'X show "\<exists>x' \<in> X. vec_mod x = vec_mod x'" by auto
+qed
+
+lemma mem_MM_Rel[transfer_rule]: 
+  "(MM_Rel ===> rel_set MM_Rel ===> (=)) (\<lambda> x Y. \<exists>y \<in> Y. mat_mod x = mat_mod y) (\<in>)"
+proof (intro rel_funI iffI)
+  fix x y X Y assume xy: "MM_Rel x y" and XY: "rel_set MM_Rel X Y"
+  { assume "\<exists>x' \<in> X. mat_mod x = mat_mod x'"
+    then obtain x' where x'X: "x' \<in> X" and xx': "mat_mod x = mat_mod x'" by auto
+    with xy have x'y: "MM_Rel x' y" by (auto simp: MM_Rel_def)
+    from rel_setD1[OF XY x'X] obtain y' where "MM_Rel x' y'" and "y' \<in> Y" by auto
+    with x'y
+     show "y \<in> Y" using to_int_mod_ring_hom.mat_hom_inj by (auto simp: MM_Rel_def)
+  }
+  assume "y \<in> Y"
+  from rel_setD2[OF XY this] obtain x' where x'X: "x' \<in> X" and x'y: "MM_Rel x' y" by auto
+  from xy x'y have "mat_mod x = mat_mod x'" by (auto simp: MM_Rel_def)
+  with x'X show "\<exists>x' \<in> X. mat_mod x = mat_mod x'" by auto
+qed
+
+lemma conversep_MM_Rel_OO_MM_Rel [simp]: "MM_Rel\<inverse>\<inverse> OO MM_Rel = (=)"
+  using mat_mod_to_int_mat apply (intro ext, auto simp: OO_def MM_Rel_def)
+  using to_int_mod_ring_hom.mat_hom_inj by auto 
+
+lemma MM_Rel_OO_conversep_MM_Rel [simp]: "MM_Rel OO MM_Rel\<inverse>\<inverse> = (\<lambda> M M' . mat_mod M = mat_mod M')"
+  by (intro ext, auto simp: OO_def MM_Rel_def mat_mod_N_representative)
+
+lemma conversep_MM_Rel_OO_eq_m [simp]: "MM_Rel\<inverse>\<inverse> OO (\<lambda> M M' . mat_mod M = mat_mod M') = MM_Rel\<inverse>\<inverse>"
+  by (intro ext, auto simp: OO_def MM_Rel_def)
+
+lemma eq_m_OO_MM_Rel [simp]: "(\<lambda> M M' . mat_mod M = mat_mod M') OO MM_Rel = MM_Rel"
+  by (intro ext, auto simp: OO_def MM_Rel_def)
+
+lemma eq_mset_MM_Rel [transfer_rule]: 
+  "(rel_mset MM_Rel ===> rel_mset MM_Rel ===> (=)) (rel_mset (\<lambda> M M' . mat_mod M = mat_mod M')) (=)"
+proof (intro rel_funI iffI)
+  fix A B X Y
+  assume AX: "rel_mset MM_Rel A X" and BY: "rel_mset MM_Rel B Y"
+  {
+    assume AB: "rel_mset (\<lambda> M M' . mat_mod M = mat_mod M') A B"
+    from AX have "rel_mset MM_Rel\<inverse>\<inverse> X A" by (simp add: multiset.rel_flip)
+    note rel_mset_OO[OF this AB]
+    note rel_mset_OO[OF this BY]
+    then show "X = Y" by (simp add: multiset.rel_eq)
+  }
+  assume "X = Y"
+  with BY have "rel_mset MM_Rel\<inverse>\<inverse> X B" by (simp add: multiset.rel_flip)
+  from rel_mset_OO[OF AX this]
+  show "rel_mset (\<lambda> M M' . mat_mod M = mat_mod M') A B" by simp
+qed
+
+lemma vec_mset_MV_Rel[transfer_rule]: 
+  "(MV_Rel  ===> (=)) (\<lambda> v. vec_mset (vec_mod v)) (\<lambda> v. image_mset (to_int_mod_ring) (vec_mset v))"
+  unfolding MV_Rel_def rel_fun_def 
+proof (intro allI impI subset_antisym subsetI)
+  fix x :: "int vec" fix  y :: "'a mod_ring vec"
+  assume assm: "vec_mod x = to_int_vec y"
+  have "image_mset to_int_mod_ring (vec_mset y) = vec_mset (to_int_vec y)"
+    using inj_zero_hom.vec_hom_mset to_int_mod_ring_hom.inj_zero_hom_axioms by auto 
+  then show " vec_mset (vec_mod x) = image_mset to_int_mod_ring (vec_mset y)" using assm by simp
+qed
+
+lemma vec_count_MV_Rel_direct: 
+  assumes "MV_Rel v1 v2"
+  shows "count_vec v2 i = count_vec (vec_mod v1) (to_int_mod_ring i)"
+proof-
+  have eq_vecs: "to_int_vec v2 = vec_mod v1" using assms unfolding MV_Rel_def by simp
+  have "count_vec v2 i = count (vec_mset v2) i" by simp
+  also have 1: "... = count (image_mset to_int_mod_ring (vec_mset v2)) (to_int_mod_ring i)"  
+    using count_image_mset_inj by (metis to_int_mod_ring_hom.inj_f) 
+  also have 2: "... = count (vec_mset (vec_mod v1)) (to_int_mod_ring i)" using assms
+    by (simp add: eq_vecs inj_zero_hom.vec_hom_mset to_int_mod_ring_hom.inj_zero_hom_axioms) 
+  finally show "count_vec v2 i = count_vec (vec_mod v1) (to_int_mod_ring i)"
+    by (simp add: 1 2 ) 
+qed
+
+lemma MM_Rel_MV_Rel_row: "MM_Rel A B \<Longrightarrow> i < dim_row A \<Longrightarrow> MV_Rel (row A i) (row B i)"
+  unfolding MM_Rel_def MV_Rel_def
+  by (metis index_map_mat(2) mat_mod_dim(1) mat_mod_vec_mod_row row_map_mat) 
+
+lemma MM_Rel_MV_Rel_col:  "MM_Rel A B \<Longrightarrow> j < dim_col A \<Longrightarrow> MV_Rel (col A j) (col B j)"
+  unfolding MM_Rel_def MV_Rel_def 
+  using  index_map_mat(3) mat_mod_dim(2) mat_mod_vec_mod_col col_map_mat by (metis) 
+
+end
+end
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/document/root.bib b/thys/Fishers_Inequality/document/root.bib
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/document/root.bib
@@ -0,0 +1,103 @@
+@book{cameronCombinatoricsTopicsTechniques1994,
+	abstract = {Cambridge Core - Algorithmics, Complexity, Computer Algebra, Computational Geometry - Combinatorics -  by Peter J. Cameron},
+	address = {{Cambridge}},
+	author = {Cameron, Peter J.},
+	file = {C\:\\Users\\cledm\\Zotero\\storage\\V9GWRW39\\951A2163C96B61B09140F054E021A9FE.html},
+	isbn = {978-0-521-45133-8 978-0-511-80388-8 978-0-521-45761-3},
+	language = {en},
+	month = oct,
+	note = {\url{/core/books/combinatorics/951A2163C96B61B09140F054E021A9FE}},
+	publisher = {{Cambridge University Press}},
+	shorttitle = {Combinatorics},
+	title = {Combinatorics: {{Topics}}, {{Techniques}}, {{Algorithms}}},
+	year = {1994}}
+
+@book{colbournHandbookCombinatorialDesigns2007,
+	author = {Colbourn, C. J and Dinitz, Jeffrey H.},
+	date-modified = {2021-03-22 15:57:21 +0000},
+	edition = {2nd},
+	file = {C\:\\Users\\cledm\\Zotero\\storage\\ALJQH3YJ\\C. J Colbourn_Dinitz_2007_Handbook of combinatorial designs - edited by Charles J.pdf},
+	isbn = {978-1-58488-506-1},
+	keywords = {Combinatorial designs and configurations},
+	language = {eng},
+	lccn = {QA166.25 .H363 2007},
+	publisher = {{Chapman \& Hall/CRC}},
+	title = {Handbook of Combinatorial Designs / Edited by {{Charles J}}. {{Colbourn}}, {{Jeffrey H}}. {{Dinitz}}.},
+	year = {2007}}
+
+@book{stinsonCombinatorialDesignsConstructions2004,
+	abstract = {Created to teach students many of the most important techniques used for constructing combinatorial designs, this is an ideal textbook for advanced undergraduate and graduate courses in combinatorial design theory. The text features clear explanations of basic designs, such as Steiner and Kirkman triple systems, mutual orthogonal Latin squares, finite projective and affine planes, and Steiner quadruple systems. In these settings, the student will master various construction techniques, both classic and modern, and will be well-prepared to construct a vast array of combinatorial designs. Design theory offers a progressive approach to the subject, with carefully ordered results. It begins with simple constructions that gradually increase in complexity. Each design has a construction that contains new ideas or that reinforces and builds upon similar ideas previously introduced. A new text/reference covering all apsects of modern combinatorial design theory. Graduates and professionals in computer science, applied mathematics, combinatorics, and applied statistics will find the book an essential resource.},
+	annotation = {https://www.springer.com/gp/book/9780387954875},
+	author = {Stinson, Douglas},
+	date-modified = {2021-03-22 16:11:11 +0000},
+	file = {C\:\\Users\\cledm\\Zotero\\storage\\WN767Z98\\Stinson_2004_Combinatorial Designs.pdf;C\:\\Users\\cledm\\Zotero\\storage\\FYAWHUHN\\9780387954875.html},
+	isbn = {978-0-387-95487-5},
+	language = {en},
+	publisher = {Springer},
+	shorttitle = {Combinatorial {{Designs}}},
+	title = {Combinatorial {{Designs}}: {{Constructions}} and {{Analysis}}},
+	year = {2004}}
+
+@misc{HerkeLectureNotes2016,
+	author = {Sara Herke},
+	title = {MATH3301 Lecture Notes in Combinatorial Design Theory},
+	month = {July},
+	year = {2016},
+	publisher = {University of Queensland}
+	}
+
+@incollection{godsilToolsLinearAlgebra,
+  title = {Tools from {{Linear Algebra}}},
+  booktitle = {Handbook of {{Combinatorics}}},
+  author = {Godsil, C. D.},
+  editor = {Graham RL, Gr{\"o}tschel M, Lov{\'a}sz L},
+  volume = {2},
+  publisher = {{Elsevier}},
+  address = {{Amsterdam}},
+  langid = {english},
+  file = {C\:\\Users\\cledm\\Zotero\\storage\\J9WN7TIC\\Godsil - Chapter 31 Tools from Linear Algebra.pdf}
+}
+
+@misc{bukhAlgebraicMethodsCombinatoricsa,
+  title = {Lecture Notes in Algebraic {{Methods}} in {{Combinatorics}}: {{Rank}} Argument},
+  author = {Bukh, Boris},
+  year = {2014},
+  publisher ={Carnegie Mellon University},
+  url = {http://www.borisbukh.org/AlgMethods14/rank_notes.pdf},
+  langid = {english},
+  file = {C\:\\Users\\cledm\\Zotero\\storage\\9FWFUJ85\\Bukh - Algebraic Methods in Combinatorics Rank argument.pdf}
+}
+@book{juknaExtremalCombinatorics2011,
+  title = {Extremal {{Combinatorics}}},
+  author = {Jukna, Stasys},
+  year = {2011},
+  series = {Texts in {{Theoretical Computer Science}}. {{An EATCS Series}}},
+  publisher = {{Springer Berlin Heidelberg}},
+  address = {{Berlin, Heidelberg}},
+  isbn = {978-3-642-17363-9 978-3-642-17364-6},
+  langid = {english},
+  file = {C\:\\Users\\cledm\\Zotero\\storage\\BV8FFARY\\Jukna - 2011 - Extremal Combinatorics.pdf}
+}
+
+@article{fisherExaminationDifferentPossible1940a,
+  title = {An {{Examination}} of the {{Different Possible Solutions}} of a {{Problem}} in {{Incomplete Blocks}}},
+  author = {Fisher, R. A.},
+  year = {1940},
+  journal = {Annals of Eugenics},
+  volume = {10},
+  number = {1},
+  pages = {52--75},
+  issn = {2050-1439},
+  langid = {english},
+  annotation = {\_eprint: https://onlinelibrary.wiley.com/doi/pdf/10.1111/j.1469-1809.1940.tb02237.x},
+  file = {C\:\\Users\\cledm\\Zotero\\storage\\V3PM5T83\\Fisher_1940_An Examination of the Different Possible Solutions of a Problem in Incomplete.pdf;C\:\\Users\\cledm\\Zotero\\storage\\TTXKNKWU\\j.1469-1809.1940.tb02237.html}
+}
+
+@book{babaiLINEARALGEBRAMETHODS1988,
+  title = {Linear Algebra Methods in Combinatorics},
+  author = {Babai, L\'{a}szl\'{o} and Frankl, P\'{e}ter},
+  year = {2020},
+  edition = {2.1},
+  langid = {english},
+  file = {C\:\\Users\\cledm\\Zotero\\storage\\WXLVYMME\\Babai and Frankl - 1988 - LINEAR ALGEBRA METHODS IN COMBINATORICS.pdf}
+}
\ No newline at end of file
diff --git a/thys/Fishers_Inequality/document/root.tex b/thys/Fishers_Inequality/document/root.tex
new file mode 100644
--- /dev/null
+++ b/thys/Fishers_Inequality/document/root.tex
@@ -0,0 +1,30 @@
+\documentclass[11pt,a4paper]{article}
+\usepackage{isabelle,isabellesym}
+
+% this should be the last package used
+\usepackage{pdfsetup}
+
+% urls in roman style, theory text in math-similar italics
+\urlstyle{rm}
+\isabellestyle{it}
+
+
+\begin{document}
+
+\title{Fisher's Inequality: Linear Algebraic Proof Techniques for Combinatorics}
+\author{Chelsea Edmonds and Lawrence C. Paulson}
+\maketitle
+
+\begin{abstract}
+  Linear algebraic techniques are powerful, yet often underrated tools in combinatorial proofs. This formalisation provides a library including matrix representations of incidence set systems, general formal proof techniques for the rank argument and linear bound argument, and finally a formalisation of a number of variations of the well-known Fisher's inequality. We build on our prior work formalising combinatorial design theory using a locale-centric approach, including extensions such as constant intersect designs and dual incidence systems. In addition to Fisher's inequality, we also formalise proofs on other incidence system properties using the incidence matrix representation, such as design existence, dual system relationships and incidence system isomorphisms. This formalisation is presented in the paper "Formalising Fisher's Inequality: Formal Linear Algebraic Techniques in Combinatorics", accepted to ITP 2022.
+\end{abstract}
+
+\tableofcontents
+
+% include generated text of all theories
+\input{session}
+
+\bibliographystyle{abbrv}
+\bibliography{root}
+
+\end{document}
diff --git a/thys/ROOTS b/thys/ROOTS
--- a/thys/ROOTS
+++ b/thys/ROOTS
@@ -1,676 +1,677 @@
 ADS_Functor
 AI_Planning_Languages_Semantics
 AODV
 AVL-Trees
 AWN
 Abortable_Linearizable_Modules
 Abs_Int_ITP2012
 Abstract-Hoare-Logics
 Abstract-Rewriting
 Abstract_Completeness
 Abstract_Soundness
 Ackermanns_not_PR
 Actuarial_Mathematics
 Adaptive_State_Counting
 Affine_Arithmetic
 Aggregation_Algebras
 Akra_Bazzi
 Algebraic_Numbers
 Algebraic_VCs
 Allen_Calculus
 Amicable_Numbers
 Amortized_Complexity
 AnselmGod
 Applicative_Lifting
 Approximation_Algorithms
 Architectural_Design_Patterns
 Aristotles_Assertoric_Syllogistic
 Arith_Prog_Rel_Primes
 ArrowImpossibilityGS
 Attack_Trees
 Auto2_HOL
 Auto2_Imperative_HOL
 AutoFocus-Stream
 Automated_Stateful_Protocol_Verification
 Automatic_Refinement
 AxiomaticCategoryTheory
 BDD
 BD_Security_Compositional
 BNF_CC
 BNF_Operations
 BTree
 Banach_Steinhaus
 Belief_Revision
 Bell_Numbers_Spivey
 BenOr_Kozen_Reif
 Berlekamp_Zassenhaus
 Bernoulli
 Bertrands_Postulate
 Bicategory
 BinarySearchTree
 Binding_Syntax_Theory
 Binomial-Heaps
 Binomial-Queues
 BirdKMP
 Blue_Eyes
 Bondy
 Boolean_Expression_Checkers
 Bounded_Deducibility_Security
 Buchi_Complementation
 Budan_Fourier
 Buffons_Needle
 Buildings
 BytecodeLogicJmlTypes
 C2KA_DistributedSystems
 CAVA_Automata
 CAVA_LTL_Modelchecker
 CCS
 CISC-Kernel
 CRDT
 CSP_RefTK
 CYK
 CZH_Elementary_Categories
 CZH_Foundations
 CZH_Universal_Constructions
 CakeML
 CakeML_Codegen
 Call_Arity
 Card_Equiv_Relations
 Card_Multisets
 Card_Number_Partitions
 Card_Partitions
 Cartan_FP
 Case_Labeling
 Catalan_Numbers
 Category
 Category2
 Category3
 Cauchy
 Cayley_Hamilton
 Certification_Monads
 Chandy_Lamport
 Chord_Segments
 Circus
 Clean
 ClockSynchInst
 Closest_Pair_Points
 CoCon
 CoSMeDis
 CoSMed
 CofGroups
 Coinductive
 Coinductive_Languages
 Collections
 Combinatorics_Words
 Combinatorics_Words_Graph_Lemma
 Combinatorics_Words_Lyndon
 Comparison_Sort_Lower_Bound
 Compiling-Exceptions-Correctly
 Complete_Non_Orders
 Completeness
 Complex_Bounded_Operators
 Complex_Geometry
 Complx
 ComponentDependencies
 ConcurrentGC
 ConcurrentIMP
 Concurrent_Ref_Alg
 Concurrent_Revisions
 Conditional_Simplification
 Conditional_Transfer_Rule
 Consensus_Refined
 Constructive_Cryptography
 Constructive_Cryptography_CM
 Constructor_Funs
 Containers
 CoreC++
 Core_DOM
 Core_SC_DOM
 Correctness_Algebras
 Cotangent_PFD_Formula
 Count_Complex_Roots
 CryptHOL
 CryptoBasedCompositionalProperties
 Cubic_Quartic_Equations
 DFS_Framework
 DOM_Components
 DPT-SAT-Solver
 DataRefinementIBP
 Datatype_Order_Generator
 Decl_Sem_Fun_PL
 Decreasing-Diagrams
 Decreasing-Diagrams-II
 Dedekind_Real
 Deep_Learning
 Delta_System_Lemma
 Density_Compiler
 Dependent_SIFUM_Refinement
 Dependent_SIFUM_Type_Systems
 Depth-First-Search
 Derangements
 Deriving
 Descartes_Sign_Rule
 Design_Theory
 Dict_Construction
 Differential_Dynamic_Logic
 Differential_Game_Logic
 Dijkstra_Shortest_Path
 Diophantine_Eqns_Lin_Hom
 Dirichlet_L
 Dirichlet_Series
 DiscretePricing
 Discrete_Summation
 DiskPaxos
 Dominance_CHK
 DynamicArchitectures
 Dynamic_Tables
 E_Transcendental
 Echelon_Form
 EdmondsKarp_Maxflow
 Efficient-Mergesort
 Elliptic_Curves_Group_Law
 Encodability_Process_Calculi
 Epistemic_Logic
 Equivalence_Relation_Enumeration
 Ergodic_Theory
 Error_Function
 Euler_MacLaurin
 Euler_Partition
 Eval_FO
 Example-Submission
 Extended_Finite_State_Machine_Inference
 Extended_Finite_State_Machines
 FFT
 FLP
 FOL-Fitting
 FOL_Axiomatic
 FOL_Harrison
 FOL_Seq_Calc1
 FOL_Seq_Calc2
 FOL_Seq_Calc3
 Factor_Algebraic_Polynomial
 Factored_Transition_System_Bounding
 Falling_Factorial_Sum
 Farkas
 FeatherweightJava
 Featherweight_OCL
 Fermat3_4
 FileRefinement
 FinFun
 Finger-Trees
 Finite-Map-Extras
 Finite_Automata_HF
 Finitely_Generated_Abelian_Groups
 First_Order_Terms
 First_Welfare_Theorem
 Fishburn_Impossibility
 Fisher_Yates
+Fishers_Inequality
 Flow_Networks
 Floyd_Warshall
 Flyspeck-Tame
 FocusStreamsCaseStudies
 Forcing
 Formal_Puiseux_Series
 Formal_SSA
 Formula_Derivatives
 Foundation_of_geometry
 Fourier
 FO_Theory_Rewriting
 Free-Boolean-Algebra
 Free-Groups
 Frequency_Moments
 Fresh_Identifiers
 FunWithFunctions
 FunWithTilings
 Functional-Automata
 Functional_Ordered_Resolution_Prover
 Furstenberg_Topology
 GPU_Kernel_PL
 Gabow_SCC
 GaleStewart_Games
 Gale_Shapley
 Game_Based_Crypto
 Gauss-Jordan-Elim-Fun
 Gauss_Jordan
 Gauss_Sums
 Gaussian_Integers
 GenClock
 General-Triangle
 Generalized_Counting_Sort
 Generic_Deriving
 Generic_Join
 GewirthPGCProof
 Girth_Chromatic
 GoedelGod
 Goedel_HFSet_Semantic
 Goedel_HFSet_Semanticless
 Goedel_Incompleteness
 Goodstein_Lambda
 GraphMarkingIBP
 Graph_Saturation
 Graph_Theory
 Green
 Groebner_Bases
 Groebner_Macaulay
 Gromov_Hyperbolicity
 Grothendieck_Schemes
 Group-Ring-Module
 HOL-CSP
 HOLCF-Prelude
 HRB-Slicing
 Hahn_Jordan_Decomposition
 Heard_Of
 Hello_World
 HereditarilyFinite
 Hermite
 Hermite_Lindemann
 Hidden_Markov_Models
 Higher_Order_Terms
 Hoare_Time
 Hood_Melville_Queue
 HotelKeyCards
 Huffman
 Hybrid_Logic
 Hybrid_Multi_Lane_Spatial_Logic
 Hybrid_Systems_VCs
 HyperCTL
 Hyperdual
 IEEE_Floating_Point
 IFC_Tracking
 IMAP-CRDT
 IMO2019
 IMP2
 IMP2_Binary_Heap
 IMP_Compiler
 IP_Addresses
 Imperative_Insertion_Sort
 Impossible_Geometry
 Incompleteness
 Incredible_Proof_Machine
 Independence_CH
 Inductive_Confidentiality
 Inductive_Inference
 InfPathElimination
 InformationFlowSlicing
 InformationFlowSlicing_Inter
 Integration
 Interpolation_Polynomials_HOL_Algebra
 Interpreter_Optimizations
 Interval_Arithmetic_Word32
 Intro_Dest_Elim
 Iptables_Semantics
 Irrational_Series_Erdos_Straus
 Irrationality_J_Hancl
 Irrationals_From_THEBOOK
 IsaGeoCoq
 Isabelle_C
 Isabelle_Marries_Dirac
 Isabelle_Meta_Model
 Jacobson_Basic_Algebra
 Jinja
 JinjaDCI
 JinjaThreads
 JiveDataStoreModel
 Jordan_Hoelder
 Jordan_Normal_Form
 KAD
 KAT_and_DRA
 KBPs
 KD_Tree
 Key_Agreement_Strong_Adversaries
 Kleene_Algebra
 Knights_Tour
 Knot_Theory
 Knuth_Bendix_Order
 Knuth_Morris_Pratt
 Koenigsberg_Friendship
 Kruskal
 Kuratowski_Closure_Complement
 LLL_Basis_Reduction
 LLL_Factorization
 LOFT
 LTL
 LTL_Master_Theorem
 LTL_Normal_Form
 LTL_to_DRA
 LTL_to_GBA
 Lam-ml-Normalization
 LambdaAuth
 LambdaMu
 Lambda_Free_EPO
 Lambda_Free_KBOs
 Lambda_Free_RPOs
 Lambert_W
 Landau_Symbols
 Laplace_Transform
 Latin_Square
 LatticeProperties
 Launchbury
 Laws_of_Large_Numbers
 Lazy-Lists-II
 Lazy_Case
 Lehmer
 Lifting_Definition_Option
 Lifting_the_Exponent
 LightweightJava
 LinearQuantifierElim
 Linear_Inequalities
 Linear_Programming
 Linear_Recurrences
 Liouville_Numbers
 List-Index
 List-Infinite
 List_Interleaving
 List_Inversions
 List_Update
 LocalLexing
 Localization_Ring
 Locally-Nameless-Sigma
 Logging_Independent_Anonymity
 Lowe_Ontological_Argument
 Lower_Semicontinuous
 Lp
 LP_Duality
 Lucas_Theorem
 MDP-Algorithms
 MDP-Rewards
 MFMC_Countable
 MFODL_Monitor_Optimized
 MFOTL_Monitor
 MSO_Regex_Equivalence
 Markov_Models
 Marriage
 Mason_Stothers
 Matrices_for_ODEs
 Matrix
 Matrix_Tensor
 Matroids
 Max-Card-Matching
 Median_Method
 Median_Of_Medians_Selection
 Menger
 Mereology
 Mersenne_Primes
 Metalogic_ProofChecker
 MiniML
 MiniSail
 Minimal_SSA
 Minkowskis_Theorem
 Minsky_Machines
 Modal_Logics_for_NTS
 Modular_Assembly_Kit_Security
 Modular_arithmetic_LLL_and_HNF_algorithms
 Monad_Memo_DP
 Monad_Normalisation
 MonoBoolTranAlgebra
 MonoidalCategory
 Monomorphic_Monad
 MuchAdoAboutTwo
 Multiset_Ordering_NPC
 Multi_Party_Computation
 Multirelations
 Myhill-Nerode
 Name_Carrying_Type_Inference
 Nash_Williams
 Nat-Interval-Logic
 Native_Word
 Nested_Multisets_Ordinals
 Network_Security_Policy_Verification
 Neumann_Morgenstern_Utility
 No_FTL_observers
 Nominal2
 Noninterference_CSP
 Noninterference_Concurrent_Composition
 Noninterference_Generic_Unwinding
 Noninterference_Inductive_Unwinding
 Noninterference_Ipurge_Unwinding
 Noninterference_Sequential_Composition
 NormByEval
 Nullstellensatz
 Octonions
 OpSets
 Open_Induction
 Optics
 Optimal_BST
 Orbit_Stabiliser
 Order_Lattice_Props
 Ordered_Resolution_Prover
 Ordinal
 Ordinal_Partitions
 Ordinals_and_Cardinals
 Ordinary_Differential_Equations
 PAC_Checker
 PAL
 PCF
 PLM
 POPLmark-deBruijn
 PSemigroupsConvolution
 Padic_Ints
 Pairing_Heap
 Paraconsistency
 Parity_Game
 Partial_Function_MR
 Partial_Order_Reduction
 Password_Authentication_Protocol
 Pell
 Perfect-Number-Thm
 Perron_Frobenius
 Physical_Quantities
 Pi_Calculus
 Pi_Transcendental
 Planarity_Certificates
 Poincare_Bendixson
 Poincare_Disc
 Polynomial_Factorization
 Polynomial_Interpolation
 Polynomials
 Pop_Refinement
 Posix-Lexing
 Possibilistic_Noninterference
 Power_Sum_Polynomials
 Pratt_Certificate
 Prefix_Free_Code_Combinators
 Presburger-Automata
 Prim_Dijkstra_Simple
 Prime_Distribution_Elementary
 Prime_Harmonic_Series
 Prime_Number_Theorem
 Priority_Queue_Braun
 Priority_Search_Trees
 Probabilistic_Noninterference
 Probabilistic_Prime_Tests
 Probabilistic_System_Zoo
 Probabilistic_Timed_Automata
 Probabilistic_While
 Program-Conflict-Analysis
 Progress_Tracking
 Projective_Geometry
 Projective_Measurements
 Promela
 Proof_Strategy_Language
 PropResPI
 Propositional_Proof_Systems
 Prpu_Maxflow
 PseudoHoops
 Psi_Calculi
 Ptolemys_Theorem
 Public_Announcement_Logic
 QHLProver
 QR_Decomposition
 Quantales
 Quasi_Borel_Spaces
 Quaternions
 Quick_Sort_Cost
 RIPEMD-160-SPARK
 ROBDD
 RSAPSS
 Ramsey-Infinite
 Random_BSTs
 Random_Graph_Subgraph_Threshold
 Randomised_BSTs
 Randomised_Social_Choice
 Rank_Nullity_Theorem
 Real_Impl
 Real_Power
 Recursion-Addition
 Recursion-Theory-I
 Refine_Imperative_HOL
 Refine_Monadic
 RefinementReactive
 Regex_Equivalence
 Registers
 Regression_Test_Selection
 Regular-Sets
 Regular_Algebras
 Regular_Tree_Relations
 Relation_Algebra
 Relational-Incorrectness-Logic
 Relational_Disjoint_Set_Forests
 Relational_Forests
 Relational_Method
 Relational_Minimum_Spanning_Trees
 Relational_Paths
 Rep_Fin_Groups
 ResiduatedTransitionSystem
 Residuated_Lattices
 Resolution_FOL
 Rewriting_Z
 Ribbon_Proofs
 Robbins-Conjecture
 Robinson_Arithmetic
 Root_Balanced_Tree
 Roth_Arithmetic_Progressions
 Routing
 Roy_Floyd_Warshall
 SATSolverVerification
 SC_DOM_Components
 SDS_Impossibility
 SIFPL
 SIFUM_Type_Systems
 SPARCv8
 Safe_Distance
 Safe_OCL
 Saturation_Framework
 Saturation_Framework_Extensions
 Schutz_Spacetime
 Secondary_Sylow
 Security_Protocol_Refinement
 Selection_Heap_Sort
 SenSocialChoice
 Separata
 Separation_Algebra
 Separation_Logic_Imperative_HOL
 SequentInvertibility
 Shadow_DOM
 Shadow_SC_DOM
 Shivers-CFA
 ShortestPath
 Show
 Sigma_Commit_Crypto
 Signature_Groebner
 Simpl
 Simple_Firewall
 Simplex
 Simplicial_complexes_and_boolean_functions
 SimplifiedOntologicalArgument
 Skew_Heap
 Skip_Lists
 Slicing
 Sliding_Window_Algorithm
 Smith_Normal_Form
 Smooth_Manifolds
 Sort_Encodings
 Source_Coding_Theorem
 SpecCheck
 Special_Function_Bounds
 Splay_Tree
 Sqrt_Babylonian
 Stable_Matching
 Statecharts
 Stateful_Protocol_Composition_and_Typing
 Stellar_Quorums
 Stern_Brocot
 Stewart_Apollonius
 Stirling_Formula
 Stochastic_Matrices
 Stone_Algebras
 Stone_Kleene_Relation_Algebras
 Stone_Relation_Algebras
 Store_Buffer_Reduction
 Stream-Fusion
 Stream_Fusion_Code
 Strong_Security
 Sturm_Sequences
 Sturm_Tarski
 Stuttering_Equivalence
 Subresultants
 Subset_Boolean_Algebras
 SumSquares
 Sunflowers
 SuperCalc
 Surprise_Paradox
 Symmetric_Polynomials
 Syntax_Independent_Logic
 Szemeredi_Regularity
 Szpilrajn
 TESL_Language
 TLA
 Tail_Recursive_Functions
 Tarskis_Geometry
 Taylor_Models
 Three_Circles
 Timed_Automata
 Topological_Semantics
 Topology
 TortoiseHare
 Transcendence_Series_Hancl_Rucki
 Transformer_Semantics
 Transition_Systems_and_Automata
 Transitive-Closure
 Transitive-Closure-II
 Transitive_Models
 Treaps
 Tree-Automata
 Tree_Decomposition
 Triangle
 Trie
 Twelvefold_Way
 Tycon
 Types_Tableaus_and_Goedels_God
 Types_To_Sets_Extension
 UPF
 UPF_Firewall
 UTP
 Universal_Hash_Families
 Universal_Turing_Machine
 UpDown_Scheme
 Valuation
 Van_Emde_Boas_Trees
 Van_der_Waerden
 VectorSpace
 VeriComp
 Verified-Prover
 Verified_SAT_Based_AI_Planning
 VerifyThis2018
 VerifyThis2019
 Vickrey_Clarke_Groves
 Virtual_Substitution
 VolpanoSmith
 VYDRA_MDL
 WHATandWHERE_Security
 WOOT_Strong_Eventual_Consistency
 WebAssembly
 Weight_Balanced_Trees
 Weighted_Path_Order
 Well_Quasi_Orders
 Wetzels_Problem
 Winding_Number_Eval
 Word_Lib
 WorkerWrapper
 X86_Semantics
 XML
 Youngs_Inequality
 ZFC_in_HOL
 Zeta_3_Irrational
 Zeta_Function
 pGCL