diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Binary_Relation_Functions.thy b/thys/Transport/HOL_Basics/Binary_Relations/Binary_Relation_Functions.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Binary_Relation_Functions.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Binary_Relation_Functions.thy
@@ -1,283 +1,292 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 section \<open>Binary Relations\<close>
 subsection \<open>Basic Functions\<close>
 theory Binary_Relation_Functions
   imports
     HOL_Basics_Base
 begin
 
 paragraph \<open>Summary\<close>
 text \<open>Basic functions on binary relations.\<close>
 
 definition "rel_comp R S x y \<equiv> \<exists>z. R x z \<and> S z y"
 
 bundle rel_comp_syntax begin notation rel_comp (infixl "\<circ>\<circ>" 55) end
 bundle no_rel_comp_syntax begin no_notation rel_comp (infixl "\<circ>\<circ>" 55) end
 unbundle rel_comp_syntax
 
 lemma rel_compI [intro]:
   assumes "R x y"
   and "S y z"
   shows "(R \<circ>\<circ> S) x z"
   using assms unfolding rel_comp_def by blast
 
 lemma rel_compE [elim]:
   assumes "(R \<circ>\<circ> S) x y"
   obtains z where "R x z" "S z y"
   using assms unfolding rel_comp_def by blast
 
 lemma rel_comp_assoc: "R \<circ>\<circ> (S \<circ>\<circ> T) = (R \<circ>\<circ> S) \<circ>\<circ> T"
   by (intro ext) blast
 
 definition rel_inv :: "('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> 'b \<Rightarrow> 'a \<Rightarrow> bool"
   where "rel_inv R x y \<equiv> R y x"
 
 bundle rel_inv_syntax begin notation rel_inv ("(_\<inverse>)" [1000]) end
 bundle no_rel_inv_syntax begin no_notation rel_inv ("(_\<inverse>)" [1000]) end
 unbundle rel_inv_syntax
 
 lemma rel_invI [intro]:
   assumes "R x y"
   shows "R\<inverse> y x"
   using assms unfolding rel_inv_def .
 
 lemma rel_invD [dest]:
   assumes "R\<inverse> x y"
   shows "R y x"
   using assms unfolding rel_inv_def .
 
 lemma rel_inv_iff_rel [simp]: "R\<inverse> x y \<longleftrightarrow> R y x"
   by blast
 
 lemma rel_inv_comp_eq [simp]: "(R \<circ>\<circ> S)\<inverse> = S\<inverse> \<circ>\<circ> R\<inverse>"
   by (intro ext) blast
 
 lemma rel_inv_inv_eq_self [simp]: "R\<inverse>\<inverse> = R"
   by blast
 
 lemma rel_inv_eq_iff_eq [iff]: "R\<inverse> = S\<inverse> \<longleftrightarrow> R = S"
   by (blast dest: fun_cong)
 
 definition "in_dom R x \<equiv> \<exists>y. R x y"
 
 lemma in_domI [intro]:
   assumes "R x y"
   shows "in_dom R x"
   using assms unfolding in_dom_def by blast
 
 lemma in_domE [elim]:
   assumes "in_dom R x"
   obtains y where "R x y"
   using assms unfolding in_dom_def by blast
 
 lemma in_dom_if_in_dom_rel_comp:
   assumes "in_dom (R \<circ>\<circ> S) x"
   shows "in_dom R x"
   using assms by blast
 
 definition "in_codom R y \<equiv> \<exists>x. R x y"
 
 lemma in_codomI [intro]:
   assumes "R x y"
   shows "in_codom R y"
   using assms unfolding in_codom_def by blast
 
 lemma in_codomE [elim]:
   assumes "in_codom R y"
   obtains x where "R x y"
   using assms unfolding in_codom_def by blast
 
 lemma in_codom_if_in_codom_rel_comp:
   assumes "in_codom (R \<circ>\<circ> S) y"
   shows "in_codom S y"
   using assms by blast
 
 lemma in_codom_rel_inv_eq_in_dom [simp]: "in_codom (R\<inverse>) = in_dom R"
   by (intro ext) blast
 
 lemma in_dom_rel_inv_eq_in_codom [simp]: "in_dom (R\<inverse>) = in_codom R"
   by (intro ext) blast
 
 definition "in_field R x \<equiv> in_dom R x \<or> in_codom R x"
 
 lemma in_field_if_in_dom:
   assumes "in_dom R x"
   shows "in_field R x"
   unfolding in_field_def using assms by blast
 
 lemma in_field_if_in_codom:
   assumes "in_codom R x"
   shows "in_field R x"
   unfolding in_field_def using assms by blast
 
 lemma in_fieldE [elim]:
   assumes "in_field R x"
   obtains (in_dom) x' where "R x x'" | (in_codom) x' where "R x' x"
   using assms unfolding in_field_def by blast
 
 lemma in_fieldE':
   assumes "in_field R x"
   obtains (in_dom) "in_dom R x" | (in_codom) "in_codom R x"
   using assms by blast
 
 lemma in_fieldI [intro]:
   assumes "R x y"
   shows "in_field R x" "in_field R y"
   using assms by (auto intro: in_field_if_in_dom in_field_if_in_codom)
 
 lemma in_field_iff_in_dom_or_in_codom:
   "in_field L x \<longleftrightarrow> in_dom L x \<or> in_codom L x"
   by blast
 
 lemma in_field_rel_inv_eq [simp]: "in_field R\<inverse> = in_field R"
   by (intro ext) auto
 
 lemma in_field_compE [elim]:
   assumes "in_field (R \<circ>\<circ> S) x"
   obtains (in_dom) "in_dom R x" | (in_codom) "in_codom S x"
   using assms by blast
 
 lemma in_field_eq_in_dom_if_in_codom_eq_in_dom:
   assumes "in_codom R = in_dom R"
   shows "in_field R = in_dom R"
   using assms by (intro ext) (auto elim: in_fieldE')
 
 definition "rel_if B R x y \<equiv> B \<longrightarrow> R x y"
 
 bundle rel_if_syntax begin notation (output) rel_if (infixl "\<longrightarrow>" 50) end
 bundle no_rel_if_syntax begin no_notation (output) rel_if (infixl "\<longrightarrow>" 50) end
 unbundle rel_if_syntax
 
 lemma rel_if_eq_rel_if_pred [simp]:
   assumes "B"
   shows "(rel_if B R) = R"
   unfolding rel_if_def using assms by blast
 
 lemma rel_if_eq_top_if_not_pred [simp]:
   assumes "\<not>B"
   shows "(rel_if B R) = (\<lambda>_ _. True)"
   unfolding rel_if_def using assms by blast
 
 lemma rel_if_if_impI [intro]:
   assumes "B \<Longrightarrow> R x y"
   shows "(rel_if B R) x y"
   unfolding rel_if_def using assms by blast
 
 lemma rel_ifE [elim]:
   assumes "(rel_if B R) x y"
   obtains "\<not>B" | "B" "R x y"
   using assms unfolding rel_if_def by blast
 
 lemma rel_ifD:
   assumes "(rel_if B R) x y"
   and "B"
   shows "R x y"
   using assms by blast
 
-consts restrict_left :: "('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> 'c \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> bool"
-
-definition "restrict_right R P \<equiv> (restrict_left R\<inverse> P)\<inverse>"
+consts restrict_left :: "'a \<Rightarrow> 'b \<Rightarrow> 'a"
+consts restrict_right :: "'a \<Rightarrow> 'b \<Rightarrow> 'a"
 
 overloading
-  restrict_left_pred \<equiv> "restrict_left :: ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> bool"
+  bin_rel_restrict_left_pred \<equiv>
+    "restrict_left :: ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> bool"
+  bin_rel_restrict_right_pred \<equiv>
+    "restrict_right :: ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> bool"
 begin
-  definition "restrict_left_pred R P x y \<equiv> P x \<and> R x y"
+  definition "bin_rel_restrict_left_pred R P x y \<equiv> P x \<and> R x y"
+  definition "bin_rel_restrict_right_pred R P x y \<equiv> P y \<and> R x y"
 end
 
 bundle restrict_syntax
 begin
 notation restrict_left ("(_)\<restriction>(\<^bsub>_\<^esub>)" [1000])
 notation restrict_right ("(_)\<upharpoonleft>(\<^bsub>_\<^esub>)" [1000])
 end
 bundle no_restrict_syntax
 begin
 no_notation restrict_left ("(_)\<restriction>(\<^bsub>_\<^esub>)" [1000])
 no_notation restrict_right ("(_)\<upharpoonleft>(\<^bsub>_\<^esub>)" [1000])
 end
 unbundle restrict_syntax
 
-lemma restrict_leftI [intro]:
+lemma bin_rel_restrict_leftI [intro]:
   assumes "R x y"
   and "P x"
   shows "R\<restriction>\<^bsub>P\<^esub> x y"
-  using assms unfolding restrict_left_pred_def by blast
+  using assms unfolding bin_rel_restrict_left_pred_def by blast
 
-lemma restrict_leftE [elim]:
+lemma bin_rel_restrict_leftE [elim]:
   assumes "R\<restriction>\<^bsub>P\<^esub> x y"
   obtains "P x" "R x y"
-  using assms unfolding restrict_left_pred_def by blast
-
-lemma restrict_right_eq: "R\<upharpoonleft>\<^bsub>P\<^esub> = ((R\<inverse>)\<restriction>\<^bsub>P\<^esub>)\<inverse>"
-  unfolding restrict_right_def ..
+  using assms unfolding bin_rel_restrict_left_pred_def by blast
 
-lemma rel_inv_restrict_right_rel_inv_eq_restrict_left [simp]: "((R\<inverse>)\<upharpoonleft>\<^bsub>P\<^esub>)\<inverse> = R\<restriction>\<^bsub>P\<^esub>"
-  by (simp add: restrict_right_eq)
-
-lemma restrict_right_iff_restrict_left: "R\<upharpoonleft>\<^bsub>P\<^esub> x y = (R\<inverse>)\<restriction>\<^bsub>P\<^esub> y x"
-  unfolding restrict_right_eq by simp
-
-lemma restrict_rightI [intro]:
+lemma bin_rel_restrict_rightI [intro]:
   assumes "R x y"
   and "P y"
   shows "R\<upharpoonleft>\<^bsub>P\<^esub> x y"
-  using assms by (auto iff: restrict_right_iff_restrict_left)
+  using assms unfolding bin_rel_restrict_right_pred_def by blast
 
-lemma restrict_rightE [elim]:
+lemma bin_rel_restrict_rightE [elim]:
   assumes "R\<upharpoonleft>\<^bsub>P\<^esub> x y"
   obtains "P y" "R x y"
-  using assms by (auto iff: restrict_right_iff_restrict_left)
+  using assms unfolding bin_rel_restrict_right_pred_def by blast
 
-lemma rel_inv_restrict_left_inv_restrict_left_eq:
+context
+  fixes R :: "'a \<Rightarrow> 'b \<Rightarrow> bool"
+begin
+
+lemma bin_rel_restrict_right_eq: "R\<upharpoonleft>\<^bsub>P :: 'b \<Rightarrow> bool\<^esub> = ((R\<inverse>)\<restriction>\<^bsub>P\<^esub>)\<inverse>"
+  by blast
+
+lemma rel_inv_restrict_right_rel_inv_eq_restrict_left [simp]: "((R\<inverse>)\<upharpoonleft>\<^bsub>P :: 'a \<Rightarrow> bool\<^esub>)\<inverse> = R\<restriction>\<^bsub>P\<^esub>"
+  by blast
+
+lemma bin_rel_restrict_right_iff_restrict_left: "R\<upharpoonleft>\<^bsub>P :: 'b \<Rightarrow> bool\<^esub> x y \<longleftrightarrow> (R\<inverse>)\<restriction>\<^bsub>P\<^esub> y x"
+  unfolding bin_rel_restrict_right_eq by simp
+
+end
+
+lemma rel_inv_bin_rel_restrict_left_inv_bin_rel_restrict_left_eq:
   fixes R :: "'a \<Rightarrow> 'b \<Rightarrow> bool" and P :: "'a \<Rightarrow> bool" and Q :: "'b \<Rightarrow> bool"
   shows "(((R\<restriction>\<^bsub>P\<^esub>)\<inverse>)\<restriction>\<^bsub>Q\<^esub>)\<inverse> = (((R\<inverse>)\<restriction>\<^bsub>Q\<^esub>)\<inverse>)\<restriction>\<^bsub>P\<^esub>"
-  by (intro ext iffI restrict_leftI rel_invI) auto
+  by (intro ext iffI bin_rel_restrict_leftI rel_invI) auto
 
-lemma restrict_left_right_eq_restrict_right_left:
+lemma bin_rel_restrict_left_right_eq_restrict_right_left:
   fixes R :: "'a \<Rightarrow> 'b \<Rightarrow> bool" and P :: "'a \<Rightarrow> bool" and Q :: "'b \<Rightarrow> bool"
   shows "R\<restriction>\<^bsub>P\<^esub>\<upharpoonleft>\<^bsub>Q\<^esub> = R\<upharpoonleft>\<^bsub>Q\<^esub>\<restriction>\<^bsub>P\<^esub>"
-  unfolding restrict_right_eq
-  by (fact rel_inv_restrict_left_inv_restrict_left_eq)
+  unfolding bin_rel_restrict_right_eq
+  by (fact rel_inv_bin_rel_restrict_left_inv_bin_rel_restrict_left_eq)
 
-lemma in_dom_restrict_leftI [intro]:
+lemma in_dom_bin_rel_restrict_leftI [intro]:
   assumes "R x y"
   and "P x"
   shows "in_dom R\<restriction>\<^bsub>P\<^esub> x"
   using assms by blast
 
-lemma in_dom_restrict_left_if_in_dom:
+lemma in_dom_bin_rel_restrict_left_if_in_dom:
   assumes "in_dom R x"
   and "P x"
   shows "in_dom R\<restriction>\<^bsub>P\<^esub> x"
   using assms by blast
 
-lemma in_dom_restrict_leftE [elim]:
+lemma in_dom_bin_rel_restrict_leftE [elim]:
   assumes "in_dom R\<restriction>\<^bsub>P\<^esub> x"
   obtains y where "P x" "R x y"
   using assms by blast
 
-lemma in_codom_restrict_leftI [intro]:
+lemma in_codom_bin_rel_restrict_leftI [intro]:
   assumes "R x y"
   and "P x"
   shows "in_codom R\<restriction>\<^bsub>P\<^esub> y"
   using assms by blast
 
-lemma in_codom_restrict_leftE [elim]:
+lemma in_codom_bin_rel_restrict_leftE [elim]:
   assumes "in_codom R\<restriction>\<^bsub>P\<^esub> y"
   obtains x where "P x" "R x y"
   using assms by blast
 
 definition "rel_bimap f g (R :: 'a \<Rightarrow> 'b \<Rightarrow> bool) x y \<equiv> R (f x) (g y)"
 
 lemma rel_bimap_eq [simp]: "rel_bimap f g R x y = R (f x) (g y)"
   unfolding rel_bimap_def by simp
 
 definition "rel_map f R \<equiv> rel_bimap f f R"
 
 lemma rel_bimap_self_eq_rel_map [simp]: "rel_bimap f f R = rel_map f R"
   unfolding rel_map_def by simp
 
 lemma rel_map_eq [simp]: "rel_map f R x y = R (f x) (f y)"
   by (simp only: rel_bimap_self_eq_rel_map[symmetric] rel_bimap_eq)
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Binary_Relations_Lattice.thy b/thys/Transport/HOL_Basics/Binary_Relations/Binary_Relations_Lattice.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Binary_Relations_Lattice.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Binary_Relations_Lattice.thy
@@ -1,90 +1,92 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Lattice\<close>
 theory Binary_Relations_Lattice
   imports
     Binary_Relations_Order_Base
     HOL.Boolean_Algebras
 begin
 
 paragraph \<open>Summary\<close>
 text \<open>Basic results about the lattice structure on binary relations.\<close>
 
 lemma rel_infI [intro]:
   assumes "R x y"
   and "S x y"
   shows "(R \<sqinter> S) x y"
   using assms by (rule inf2I)
 
 lemma rel_infE [elim]:
   assumes "(R \<sqinter> S) x y"
   obtains "R x y" "S x y"
   using assms by (rule inf2E)
 
 lemma rel_infD:
   assumes "(R \<sqinter> S) x y"
   shows "R x y" and "S x y"
   using assms by auto
 
 lemma in_dom_rel_infI [intro]:
   assumes "R x y"
   and "S x y"
   shows "in_dom (R \<sqinter> S) x"
   using assms by blast
 
 lemma in_dom_rel_infE [elim]:
   assumes "in_dom (R \<sqinter> S) x"
   obtains y where "R x y" "S x y"
   using assms by blast
 
 lemma in_codom_rel_infI [intro]:
   assumes "R x y"
   and "S x y"
   shows "in_codom (R \<sqinter> S) y"
   using assms by blast
 
 lemma in_codom_rel_infE [elim]:
   assumes "in_codom (R \<sqinter> S) y"
   obtains x where "R x y" "S x y"
   using assms by blast
 
 lemma in_field_eq_in_dom_sup_in_codom: "in_field L = (in_dom L \<squnion> in_codom L)"
   by (intro ext) (simp add: in_field_iff_in_dom_or_in_codom)
 
-lemma in_dom_restrict_left_eq [simp]: "in_dom R\<restriction>\<^bsub>P\<^esub> = (in_dom R \<sqinter> P)"
-  by (intro ext) auto
-
-lemma in_codom_restrict_left_eq [simp]: "in_codom R\<upharpoonleft>\<^bsub>P\<^esub> = (in_codom R \<sqinter> P)"
+lemma in_dom_bin_rel_restrict_left_eq [simp]: "in_dom R\<restriction>\<^bsub>P\<^esub> = (in_dom R \<sqinter> P)"
   by (intro ext) auto
 
-lemma restrict_left_restrict_left_eq [simp]:
-  fixes R :: "'a \<Rightarrow> _" and P Q :: "'a \<Rightarrow> bool"
+lemma in_codom_bin_rel_restrict_left_eq [simp]: "in_codom R\<upharpoonleft>\<^bsub>P\<^esub> = (in_codom R \<sqinter> P)"
+  by (intro ext) auto
+
+lemma bin_rel_restrict_left_restrict_left_eq [simp]:
+  fixes R :: "'a \<Rightarrow> 'b \<Rightarrow> bool" and P Q :: "'a \<Rightarrow> bool"
   shows "R\<restriction>\<^bsub>P\<^esub>\<restriction>\<^bsub>Q\<^esub> = R\<restriction>\<^bsub>P\<^esub> \<sqinter> R\<restriction>\<^bsub>Q\<^esub>"
-  by (intro ext iffI restrict_leftI) auto
+  by (intro ext iffI bin_rel_restrict_leftI) auto
 
-lemma restrict_left_restrict_right_eq [simp]:
+lemma bin_rel_restrict_left_restrict_right_eq [simp]:
   fixes R :: "'a \<Rightarrow> 'b \<Rightarrow> bool" and P :: "'a \<Rightarrow> bool" and Q :: "'b \<Rightarrow> bool"
   shows "R\<restriction>\<^bsub>P\<^esub>\<upharpoonleft>\<^bsub>Q\<^esub> = R\<restriction>\<^bsub>P\<^esub> \<sqinter> R\<upharpoonleft>\<^bsub>Q\<^esub>"
-  by (intro ext iffI restrict_leftI restrict_rightI) auto
+  by (intro ext iffI bin_rel_restrict_leftI bin_rel_restrict_rightI) auto
 
-lemma restrict_right_restrict_left_eq [simp]:
+lemma bin_rel_restrict_right_restrict_left_eq [simp]:
   fixes R :: "'a \<Rightarrow> 'b \<Rightarrow> bool" and P :: "'b \<Rightarrow> bool" and Q :: "'a \<Rightarrow> bool"
   shows "R\<upharpoonleft>\<^bsub>P\<^esub>\<restriction>\<^bsub>Q\<^esub> = R\<upharpoonleft>\<^bsub>P\<^esub> \<sqinter> R\<restriction>\<^bsub>Q\<^esub>"
-  by (intro ext iffI restrict_leftI restrict_rightI) auto
+  by (intro ext iffI bin_rel_restrict_leftI bin_rel_restrict_rightI) auto
 
-lemma restrict_right_restrict_right_eq [simp]:
+lemma bin_rel_restrict_right_restrict_right_eq [simp]:
   fixes R :: "'a \<Rightarrow> 'b \<Rightarrow> bool" and P Q :: "'b \<Rightarrow> bool"
   shows "R\<upharpoonleft>\<^bsub>P\<^esub>\<upharpoonleft>\<^bsub>Q\<^esub> = R\<upharpoonleft>\<^bsub>P\<^esub> \<sqinter> R\<upharpoonleft>\<^bsub>Q\<^esub>"
   by (intro ext iffI) auto
 
-lemma restrict_left_sup_eq [simp]: "(R :: 'a \<Rightarrow> _)\<restriction>\<^bsub>((P :: 'a \<Rightarrow> bool) \<squnion> Q)\<^esub> = R\<restriction>\<^bsub>P\<^esub> \<squnion> R\<restriction>\<^bsub>Q\<^esub> "
-  by (intro antisym le_relI) (auto elim!: restrict_leftE)
+lemma bin_rel_restrict_left_sup_eq [simp]:
+  "(R :: 'a \<Rightarrow> 'b \<Rightarrow> bool)\<restriction>\<^bsub>((P :: 'a \<Rightarrow> bool) \<squnion> Q)\<^esub> = R\<restriction>\<^bsub>P\<^esub> \<squnion> R\<restriction>\<^bsub>Q\<^esub> "
+  by (intro antisym le_relI) (auto elim!: bin_rel_restrict_leftE)
 
-lemma restrict_left_inf_eq [simp]: "(R :: 'a \<Rightarrow> _)\<restriction>\<^bsub>((P :: 'a \<Rightarrow> bool) \<sqinter> Q)\<^esub> = R\<restriction>\<^bsub>P\<^esub> \<sqinter> R\<restriction>\<^bsub>Q\<^esub> "
-  by (intro antisym le_relI) (auto elim!: restrict_leftE)
+lemma bin_rel_restrict_left_inf_eq [simp]:
+  "(R :: 'a \<Rightarrow> 'b \<Rightarrow> bool)\<restriction>\<^bsub>((P :: 'a \<Rightarrow> bool) \<sqinter> Q)\<^esub> = R\<restriction>\<^bsub>P\<^esub> \<sqinter> R\<restriction>\<^bsub>Q\<^esub> "
+  by (intro antisym le_relI) (auto elim!: bin_rel_restrict_leftE)
 
 lemma inf_rel_bimap_and_eq_restrict_left_restrict_right:
   "R \<sqinter> (rel_bimap P Q (\<and>)) = R\<restriction>\<^bsub>P\<^esub>\<upharpoonleft>\<^bsub>Q\<^esub>"
   by (intro ext) auto
 
 
 end
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Order/Binary_Relations_Order_Base.thy b/thys/Transport/HOL_Basics/Binary_Relations/Order/Binary_Relations_Order_Base.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Order/Binary_Relations_Order_Base.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Order/Binary_Relations_Order_Base.thy
@@ -1,33 +1,42 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Order\<close>
 theory Binary_Relations_Order_Base
   imports
     Binary_Relation_Functions
     HOL.Orderings
 begin
 
 lemma le_relI [intro]:
   assumes "\<And>x y. R x y \<Longrightarrow> S x y"
   shows "R \<le> S"
   using assms by (rule predicate2I)
 
 lemma le_relD [dest]:
   assumes "R \<le> S"
   and "R x y"
   shows "S x y"
   using assms by (rule predicate2D)
 
 lemma le_relE:
   assumes "R \<le> S"
   and "R x y"
   obtains "S x y"
   using assms by blast
 
 lemma rel_inv_le_rel_inv_iff [iff]: "R\<inverse> \<le> S\<inverse> \<longleftrightarrow> R \<le> S"
   by blast
 
-lemma restrict_left_top_eq [simp]: "(R :: 'a \<Rightarrow> _)\<restriction>\<^bsub>(\<top> :: 'a \<Rightarrow> bool)\<^esub> = R"
+lemma bin_rel_restrict_left_le_self: "(R :: 'a \<Rightarrow> 'b \<Rightarrow> bool)\<restriction>\<^bsub>(P :: 'a \<Rightarrow> bool)\<^esub> \<le> R"
+  by blast
+
+lemma bin_rel_restrict_right_le_self: "(R :: 'a \<Rightarrow> 'b \<Rightarrow> bool)\<upharpoonleft>\<^bsub>(P :: 'b \<Rightarrow> bool)\<^esub> \<le> R"
+  by blast
+
+lemma bin_rel_restrict_left_top_eq [simp]: "(R :: 'a \<Rightarrow> 'b \<Rightarrow> bool)\<restriction>\<^bsub>(\<top> :: 'a \<Rightarrow> bool)\<^esub> = R"
+  by (intro ext) auto
+
+lemma bin_rel_restrict_right_top_eq [simp]: "(R :: 'a \<Rightarrow> 'b \<Rightarrow> bool)\<upharpoonleft>\<^bsub>(\<top> :: 'b \<Rightarrow> bool)\<^esub> = R"
   by (intro ext) auto
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Antisymmetric.thy b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Antisymmetric.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Antisymmetric.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Antisymmetric.thy
@@ -1,65 +1,65 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Antisymmetric\<close>
 theory Binary_Relations_Antisymmetric
   imports
     Binary_Relation_Functions
     HOL_Syntax_Bundles_Lattices
 begin
 
 consts antisymmetric_on :: "'a \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool"
 
 overloading
   antisymmetric_on_pred \<equiv> "antisymmetric_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "antisymmetric_on_pred P R \<equiv> \<forall>x y. P x \<and> P y \<and> R x y \<and> R y x \<longrightarrow> x = y"
 end
 
 lemma antisymmetric_onI [intro]:
   assumes "\<And>x y. P x \<Longrightarrow> P y \<Longrightarrow> R x y \<Longrightarrow> R y x \<Longrightarrow> x = y"
   shows "antisymmetric_on P R"
   unfolding antisymmetric_on_pred_def using assms by blast
 
 lemma antisymmetric_onD:
   assumes "antisymmetric_on P R"
   and "P x" "P y"
   and "R x y" "R y x"
   shows "x = y"
   using assms unfolding antisymmetric_on_pred_def by blast
 
-definition "antisymmetric (R :: 'a \<Rightarrow> _) \<equiv> antisymmetric_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(antisymmetric :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> antisymmetric_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma antisymmetric_eq_antisymmetric_on:
-  "antisymmetric (R :: 'a \<Rightarrow> _) = antisymmetric_on (\<top> :: 'a \<Rightarrow> bool) R"
+  "(antisymmetric :: ('a \<Rightarrow> _) \<Rightarrow> _) = antisymmetric_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding antisymmetric_def ..
 
 lemma antisymmetricI [intro]:
   assumes "\<And>x y. R x y \<Longrightarrow> R y x \<Longrightarrow> x = y"
   shows "antisymmetric R"
   unfolding antisymmetric_eq_antisymmetric_on using assms
   by (intro antisymmetric_onI)
 
 lemma antisymmetricD:
   assumes "antisymmetric R"
   and "R x y" "R y x"
   shows "x = y"
   using assms unfolding antisymmetric_eq_antisymmetric_on
   by (auto dest: antisymmetric_onD)
 
 lemma antisymmetric_on_if_antisymmetric:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "antisymmetric R"
   shows "antisymmetric_on P R"
   using assms by (intro antisymmetric_onI) (blast dest: antisymmetricD)
 
 lemma antisymmetric_if_antisymmetric_on_in_field:
   assumes "antisymmetric_on (in_field R) R"
   shows "antisymmetric R"
   using assms by (intro antisymmetricI) (blast dest: antisymmetric_onD)
 
 corollary antisymmetric_on_in_field_iff_antisymmetric [simp]:
   "antisymmetric_on (in_field R) R \<longleftrightarrow> antisymmetric R"
   using antisymmetric_if_antisymmetric_on_in_field antisymmetric_on_if_antisymmetric
   by blast
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Injective.thy b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Injective.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Injective.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Injective.thy
@@ -1,106 +1,106 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Injective\<close>
 theory Binary_Relations_Injective
   imports
     Binary_Relation_Functions
     HOL_Syntax_Bundles_Lattices
     ML_Unification.ML_Unification_HOL_Setup
 begin
 
 consts rel_injective_on :: "'a \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow> bool"
 
 overloading
   rel_injective_on_pred \<equiv> "rel_injective_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "rel_injective_on_pred P R \<equiv> \<forall>x x' y. P x \<and> P x' \<and> R x y \<and> R x' y \<longrightarrow> x = x'"
 end
 
 lemma rel_injective_onI [intro]:
   assumes "\<And>x x' y. P x \<Longrightarrow> P x' \<Longrightarrow> R x y \<Longrightarrow> R x' y \<Longrightarrow> x = x'"
   shows "rel_injective_on P R"
   unfolding rel_injective_on_pred_def using assms by blast
 
 lemma rel_injective_onD:
   assumes "rel_injective_on P R"
   and "P x" "P x'"
   and "R x y" "R x' y"
   shows "x = x'"
   using assms unfolding rel_injective_on_pred_def by blast
 
 consts rel_injective_at :: "'a \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow> bool"
 
 overloading
   rel_injective_at_pred \<equiv> "rel_injective_at :: ('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "rel_injective_at_pred P R \<equiv> \<forall>x x' y. P y \<and> R x y \<and> R x' y \<longrightarrow> x = x'"
 end
 
 lemma rel_injective_atI [intro]:
   assumes "\<And>x x' y. P y \<Longrightarrow> R x y \<Longrightarrow> R x' y \<Longrightarrow> x = x'"
   shows "rel_injective_at P R"
   unfolding rel_injective_at_pred_def using assms by blast
 
 lemma rel_injective_atD:
   assumes "rel_injective_at P R"
   and "P y"
   and "R x y" "R x' y"
   shows "x = x'"
   using assms unfolding rel_injective_at_pred_def by blast
 
 
-definition "rel_injective (R :: 'a \<Rightarrow> _) \<equiv> rel_injective_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(rel_injective :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> rel_injective_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma rel_injective_eq_rel_injective_on:
-  "rel_injective (R :: 'a \<Rightarrow> _) = rel_injective_on (\<top> :: 'a \<Rightarrow> bool) R"
+  "(rel_injective :: ('a \<Rightarrow> _) \<Rightarrow> _) = rel_injective_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding rel_injective_def ..
 
 lemma rel_injectiveI [intro]:
   assumes "\<And>x x' y. R x y \<Longrightarrow> R x' y \<Longrightarrow> x = x'"
   shows "rel_injective R"
   unfolding rel_injective_eq_rel_injective_on using assms by blast
 
 lemma rel_injectiveD:
   assumes "rel_injective R"
   and "R x y" "R x' y"
   shows "x = x'"
   using assms unfolding rel_injective_eq_rel_injective_on
   by (auto dest: rel_injective_onD)
 
 lemma rel_injective_eq_rel_injective_at:
   "rel_injective (R :: 'a \<Rightarrow> 'b \<Rightarrow> bool) = rel_injective_at (\<top> :: 'b \<Rightarrow> bool) R"
   by (intro iffI rel_injectiveI) (auto dest: rel_injective_atD rel_injectiveD)
 
 lemma rel_injective_on_if_rel_injective:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "rel_injective R"
   shows "rel_injective_on P R"
   using assms by (blast dest: rel_injectiveD)
 
 lemma rel_injective_at_if_rel_injective:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'b \<Rightarrow> 'a \<Rightarrow> bool"
   assumes "rel_injective R"
   shows "rel_injective_at P R"
   using assms by (blast dest: rel_injectiveD)
 
 lemma rel_injective_if_rel_injective_on_in_dom:
   assumes "rel_injective_on (in_dom R) R"
   shows "rel_injective R"
   using assms by (blast dest: rel_injective_onD)
 
 lemma rel_injective_if_rel_injective_at_in_codom:
   assumes "rel_injective_at (in_codom R) R"
   shows "rel_injective R"
   using assms by (blast dest: rel_injective_atD)
 
 corollary rel_injective_on_in_dom_iff_rel_injective [simp]:
   "rel_injective_on (in_dom R) R \<longleftrightarrow> rel_injective R"
   using rel_injective_if_rel_injective_on_in_dom rel_injective_on_if_rel_injective
   by blast
 
 corollary rel_injective_at_in_codom_iff_rel_injective [iff]:
   "rel_injective_at (in_codom R) R \<longleftrightarrow> rel_injective R"
   using rel_injective_if_rel_injective_at_in_codom rel_injective_at_if_rel_injective
   by blast
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Irreflexive.thy b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Irreflexive.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Irreflexive.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Irreflexive.thy
@@ -1,51 +1,51 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Irreflexive\<close>
 theory Binary_Relations_Irreflexive
   imports
     Binary_Relation_Functions
     HOL_Syntax_Bundles_Lattices
 begin
 
 consts irreflexive_on :: "'a \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool"
 
 overloading
   irreflexive_on_pred \<equiv> "irreflexive_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "irreflexive_on_pred P R \<equiv> \<forall>x. P x \<longrightarrow> \<not>(R x x)"
 end
 
 lemma irreflexive_onI [intro]:
   assumes "\<And>x. P x \<Longrightarrow> \<not>(R x x)"
   shows "irreflexive_on P R"
   using assms unfolding irreflexive_on_pred_def by blast
 
 lemma irreflexive_onD [dest]:
   assumes "irreflexive_on P R"
   and "P x"
   shows "\<not>(R x x)"
   using assms unfolding irreflexive_on_pred_def by blast
 
-definition "irreflexive (R :: 'a \<Rightarrow> _) \<equiv> irreflexive_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(irreflexive :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> irreflexive_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma irreflexive_eq_irreflexive_on:
-  "irreflexive (R :: 'a \<Rightarrow> _) = irreflexive_on (\<top> :: 'a \<Rightarrow> bool) R"
+  "(irreflexive :: ('a \<Rightarrow> _) \<Rightarrow> _) = irreflexive_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding irreflexive_def ..
 
 lemma irreflexiveI [intro]:
   assumes "\<And>x. \<not>(R x x)"
   shows "irreflexive R"
   unfolding irreflexive_eq_irreflexive_on using assms by (intro irreflexive_onI)
 
 lemma irreflexiveD:
   assumes "irreflexive R"
   shows "\<not>(R x x)"
   using assms unfolding irreflexive_eq_irreflexive_on by auto
 
 lemma irreflexive_on_if_irreflexive:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "irreflexive R"
   shows "irreflexive_on P R"
   using assms by (intro irreflexive_onI) (blast dest: irreflexiveD)
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Left_Total.thy b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Left_Total.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Left_Total.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Left_Total.thy
@@ -1,62 +1,61 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Left Total\<close>
 theory Binary_Relations_Left_Total
   imports
     Binary_Relation_Functions
     HOL_Syntax_Bundles_Lattices
 begin
 
 consts left_total_on :: "'a \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow> bool"
 
 overloading
   left_total_on_pred \<equiv> "left_total_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "left_total_on_pred P R \<equiv> \<forall>x. P x \<longrightarrow> in_dom R x"
 end
 
 lemma left_total_onI [intro]:
   assumes "\<And>x. P x \<Longrightarrow> in_dom R x"
   shows "left_total_on P R"
   unfolding left_total_on_pred_def using assms by blast
 
 lemma left_total_onE [elim]:
   assumes "left_total_on P R"
   and "P x"
   obtains y where "R x y"
   using assms unfolding left_total_on_pred_def by blast
 
 lemma in_dom_if_left_total_on:
   assumes "left_total_on P R"
   and "P x"
   shows "in_dom R x"
   using assms by blast
 
-definition "left_total (R :: 'a \<Rightarrow> _) \<equiv> left_total_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(left_total :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> left_total_on (\<top> :: 'a \<Rightarrow> bool)"
 
-lemma left_total_eq_left_total_on:
-  "left_total (R :: 'a \<Rightarrow> _) = left_total_on (\<top> :: 'a \<Rightarrow> bool) R"
+lemma left_total_eq_left_total_on: "(left_total :: ('a \<Rightarrow> _) \<Rightarrow> _) = left_total_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding left_total_def ..
 
 lemma left_totalI [intro]:
   assumes "\<And>x. in_dom R x"
   shows "left_total R"
   unfolding left_total_eq_left_total_on using assms by (intro left_total_onI)
 
 lemma left_totalE:
   assumes "left_total R"
   obtains y where "R x y"
   using assms unfolding left_total_eq_left_total_on by (blast intro: top1I)
 
 lemma in_dom_if_left_total:
   assumes "left_total R"
   shows "in_dom R x"
   using assms by (blast elim: left_totalE)
 
 lemma left_total_on_if_left_total:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "left_total R"
   shows "left_total_on P R"
   using assms by (intro left_total_onI) (blast dest: in_dom_if_left_total)
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Reflexive.thy b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Reflexive.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Reflexive.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Reflexive.thy
@@ -1,105 +1,104 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Reflexive\<close>
 theory Binary_Relations_Reflexive
   imports
     Functions_Monotone
 begin
 
 consts reflexive_on :: "'a \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool"
 
 overloading
   reflexive_on_pred \<equiv> "reflexive_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "reflexive_on_pred P R \<equiv> \<forall>x. P x \<longrightarrow> R x x"
 end
 
 lemma reflexive_onI [intro]:
   assumes "\<And>x. P x \<Longrightarrow> R x x"
   shows "reflexive_on P R"
   using assms unfolding reflexive_on_pred_def by blast
 
 lemma reflexive_onD [dest]:
   assumes "reflexive_on P R"
   and "P x"
   shows "R x x"
   using assms unfolding reflexive_on_pred_def by blast
 
 lemma le_in_dom_if_reflexive_on:
   assumes "reflexive_on P R"
   shows "P \<le> in_dom R"
   using assms by blast
 
 lemma le_in_codom_if_reflexive_on:
   assumes "reflexive_on P R"
   shows "P \<le> in_codom R"
   using assms by blast
 
 lemma in_codom_eq_in_dom_if_reflexive_on_in_field:
   assumes "reflexive_on (in_field R) R"
   shows "in_codom R = in_dom R"
   using assms by blast
 
 lemma reflexive_on_rel_inv_iff_reflexive_on [iff]:
   "reflexive_on P R\<inverse> \<longleftrightarrow> reflexive_on (P :: 'a \<Rightarrow> bool) (R :: 'a \<Rightarrow> _)"
   by blast
 
 lemma antimono_reflexive_on [iff]:
   "antimono (\<lambda>(P :: 'a \<Rightarrow> bool). reflexive_on P (R :: 'a \<Rightarrow> _))"
   by (intro antimonoI) auto
 
 lemma reflexive_on_if_le_pred_if_reflexive_on:
   fixes P P' :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "reflexive_on P R"
   and "P' \<le> P"
   shows "reflexive_on P' R"
   using assms by blast
 
 lemma reflexive_on_sup_eq [simp]:
   "(reflexive_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> _) \<Rightarrow> _) ((P :: 'a \<Rightarrow> bool) \<squnion> Q)
   = reflexive_on P \<sqinter> reflexive_on Q"
   by (intro ext iffI reflexive_onI)
     (auto intro: reflexive_on_if_le_pred_if_reflexive_on)
 
-lemma reflexive_on_iff_eq_restrict_left_le:
+lemma reflexive_on_iff_eq_restrict_le:
   "reflexive_on (P :: 'a \<Rightarrow> bool) (R :: 'a \<Rightarrow> _) \<longleftrightarrow> ((=)\<restriction>\<^bsub>P\<^esub> \<le> R)"
   by blast
 
-definition "reflexive (R :: 'a \<Rightarrow> _) \<equiv> reflexive_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(reflexive :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> reflexive_on (\<top> :: 'a \<Rightarrow> bool)"
 
-lemma reflexive_eq_reflexive_on:
-  "reflexive (R :: 'a \<Rightarrow> _) = reflexive_on (\<top> :: 'a \<Rightarrow> bool) R"
+lemma reflexive_eq_reflexive_on: "(reflexive :: ('a \<Rightarrow> _) \<Rightarrow> _) = reflexive_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding reflexive_def ..
 
 lemma reflexiveI [intro]:
   assumes "\<And>x. R x x"
   shows "reflexive R"
   unfolding reflexive_eq_reflexive_on using assms by (intro reflexive_onI)
 
 lemma reflexiveD:
   assumes "reflexive R"
   shows "R x x"
   using assms unfolding reflexive_eq_reflexive_on by (blast intro: top1I)
 
 lemma reflexive_on_if_reflexive:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "reflexive R"
   shows "reflexive_on P R"
   using assms by (intro reflexive_onI) (blast dest: reflexiveD)
 
 lemma reflexive_rel_inv_iff_reflexive [iff]:
   "reflexive R\<inverse> \<longleftrightarrow> reflexive R"
   by (blast dest: reflexiveD)
 
 lemma reflexive_iff_eq_le: "reflexive R \<longleftrightarrow> ((=) \<le> R)"
-  unfolding reflexive_eq_reflexive_on reflexive_on_iff_eq_restrict_left_le
+  unfolding reflexive_eq_reflexive_on reflexive_on_iff_eq_restrict_le
   by simp
 
 paragraph \<open>Instantiations\<close>
 
 lemma reflexive_eq: "reflexive (=)"
   by (rule reflexiveI) (rule refl)
 
 lemma reflexive_top: "reflexive \<top>"
   by (rule reflexiveI) auto
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Right_Unique.thy b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Right_Unique.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Right_Unique.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Right_Unique.thy
@@ -1,136 +1,136 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Right Unique\<close>
 theory Binary_Relations_Right_Unique
   imports
     Binary_Relations_Injective
     HOL_Syntax_Bundles_Lattices
 begin
 
 consts right_unique_on :: "'a \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow> bool"
 
 overloading
   right_unique_on_pred \<equiv> "right_unique_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "right_unique_on_pred P R \<equiv> \<forall>x y y'. P x \<and> R x y \<and> R x y' \<longrightarrow> y = y'"
 end
 
 lemma right_unique_onI [intro]:
   assumes "\<And>x y y'. P x \<Longrightarrow> R x y \<Longrightarrow> R x y' \<Longrightarrow> y = y'"
   shows "right_unique_on P R"
   using assms unfolding right_unique_on_pred_def by blast
 
 lemma right_unique_onD:
   assumes "right_unique_on P R"
   and "P x"
   and "R x y" "R x y'"
   shows "y = y'"
   using assms unfolding right_unique_on_pred_def by blast
 
 consts right_unique_at :: "'a \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow> bool"
 
 overloading
   right_unique_at_pred \<equiv> "right_unique_at :: ('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "right_unique_at_pred P R \<equiv> \<forall>x y y'. P y \<and> P y' \<and> R x y \<and> R x y' \<longrightarrow> y = y'"
 end
 
 lemma right_unique_atI [intro]:
   assumes "\<And>x y y'. P y \<Longrightarrow> P y' \<Longrightarrow> R x y \<Longrightarrow> R x y' \<Longrightarrow> y = y'"
   shows "right_unique_at P R"
   using assms unfolding right_unique_at_pred_def by blast
 
 lemma right_unique_atD:
   assumes "right_unique_at P R"
   and "P y"
   and "P y'"
   and "R x y" "R x y'"
   shows "y = y'"
   using assms unfolding right_unique_at_pred_def by blast
 
 lemma right_unique_at_rel_inv_iff_rel_injective_on [iff]:
   "right_unique_at (P :: 'a \<Rightarrow> bool) (R\<inverse> :: 'b \<Rightarrow> 'a \<Rightarrow> bool) \<longleftrightarrow> rel_injective_on P R"
   by (blast dest: right_unique_atD rel_injective_onD)
 
 lemma rel_injective_on_rel_inv_iff_right_unique_at [iff]:
   "rel_injective_on (P :: 'a \<Rightarrow> bool) (R\<inverse> :: 'a \<Rightarrow> 'b \<Rightarrow> bool) \<longleftrightarrow> right_unique_at P R"
   by (blast dest: right_unique_atD rel_injective_onD)
 
 lemma right_unique_on_rel_inv_iff_rel_injective_at [iff]:
   "right_unique_on (P :: 'a \<Rightarrow> bool) (R\<inverse> :: 'a \<Rightarrow> 'b \<Rightarrow> bool) \<longleftrightarrow> rel_injective_at P R"
   by (blast dest: right_unique_onD rel_injective_atD)
 
 lemma rel_injective_at_rel_inv_iff_right_unique_on [iff]:
   "rel_injective_at (P :: 'b \<Rightarrow> bool) (R\<inverse> :: 'a \<Rightarrow> 'b \<Rightarrow> bool) \<longleftrightarrow> right_unique_on P R"
   by (blast dest: right_unique_onD rel_injective_atD)
 
 
-definition "right_unique (R :: 'a \<Rightarrow> _) \<equiv> right_unique_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(right_unique :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> right_unique_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma right_unique_eq_right_unique_on:
-  "right_unique (R :: 'a \<Rightarrow> _) = right_unique_on (\<top> :: 'a \<Rightarrow> bool) R"
+  "(right_unique :: ('a \<Rightarrow> _) \<Rightarrow> _) = right_unique_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding right_unique_def ..
 
 lemma right_uniqueI [intro]:
   assumes "\<And>x y y'. R x y \<Longrightarrow> R x y' \<Longrightarrow> y = y'"
   shows "right_unique R"
   unfolding right_unique_eq_right_unique_on using assms by blast
 
 lemma right_uniqueD:
   assumes "right_unique R"
   and "R x y" "R x y'"
   shows "y = y'"
   using assms unfolding right_unique_eq_right_unique_on
   by (auto dest: right_unique_onD)
 
 lemma right_unique_eq_right_unique_at:
   "right_unique (R :: 'a \<Rightarrow> 'b \<Rightarrow> bool) = right_unique_at (\<top> :: 'b \<Rightarrow> bool) R"
   by (intro iffI right_uniqueI) (auto dest: right_unique_atD right_uniqueD)
 
 lemma right_unique_on_if_right_unique:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "right_unique R"
   shows "right_unique_on P R"
   using assms by (blast dest: right_uniqueD)
 
 lemma right_unique_at_if_right_unique:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'b \<Rightarrow> 'a \<Rightarrow> bool"
   assumes "right_unique R"
   shows "right_unique_at P R"
   using assms by (blast dest: right_uniqueD)
 
 lemma right_unique_if_right_unique_on_in_dom:
   assumes "right_unique_on (in_dom R) R"
   shows "right_unique R"
   using assms by (blast dest: right_unique_onD)
 
 lemma right_unique_if_right_unique_at_in_codom:
   assumes "right_unique_at (in_codom R) R"
   shows "right_unique R"
   using assms by (blast dest: right_unique_atD)
 
 corollary right_unique_on_in_dom_iff_right_unique [iff]:
   "right_unique_on (in_dom R) R \<longleftrightarrow> right_unique R"
   using right_unique_if_right_unique_on_in_dom right_unique_on_if_right_unique
   by blast
 
 corollary right_unique_at_in_codom_iff_right_unique [iff]:
   "right_unique_at (in_codom R) R \<longleftrightarrow> right_unique R"
   using right_unique_if_right_unique_at_in_codom right_unique_at_if_right_unique
   by blast
 
 lemma right_unique_rel_inv_iff_rel_injective [iff]:
   "right_unique R\<inverse> \<longleftrightarrow> rel_injective R"
   by (blast dest: right_uniqueD rel_injectiveD)
 
 lemma rel_injective_rel_inv_iff_right_unique [iff]:
   "rel_injective R\<inverse> \<longleftrightarrow> right_unique R"
   by (blast dest: right_uniqueD rel_injectiveD)
 
 
-paragraph \<open>Instantiatiats\<close>
+paragraph \<open>Instantiations\<close>
 
 lemma right_unique_eq: "right_unique (=)"
   by (rule right_uniqueI) blast
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Surjective.thy b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Surjective.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Surjective.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Surjective.thy
@@ -1,79 +1,79 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Surjective\<close>
 theory Binary_Relations_Surjective
   imports
     Binary_Relations_Left_Total
     HOL_Syntax_Bundles_Lattices
 begin
 
 consts rel_surjective_at :: "'a \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow> bool"
 
 overloading
   rel_surjective_at_pred \<equiv> "rel_surjective_at :: ('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "rel_surjective_at_pred P R \<equiv> \<forall>y. P y \<longrightarrow> in_codom R y"
 end
 
 lemma rel_surjective_atI [intro]:
   assumes "\<And>y. P y \<Longrightarrow> in_codom R y"
   shows "rel_surjective_at P R"
   unfolding rel_surjective_at_pred_def using assms by blast
 
 lemma rel_surjective_atE [elim]:
   assumes "rel_surjective_at P R"
   and "P y"
   obtains x where "R x y"
   using assms unfolding rel_surjective_at_pred_def by blast
 
-lemma in_codom_if_rel_surjective_at_on:
+lemma in_codom_if_rel_surjective_at:
   assumes "rel_surjective_at P R"
   and "P y"
   shows "in_codom R y"
   using assms by blast
 
 lemma rel_surjective_at_rel_inv_iff_left_total_on [iff]:
   "rel_surjective_at (P :: 'a \<Rightarrow> bool) (R\<inverse> :: 'b \<Rightarrow> 'a \<Rightarrow> bool) \<longleftrightarrow> left_total_on P R"
   by fast
 
 lemma left_total_on_rel_inv_iff_rel_surjective_at [iff]:
   "left_total_on (P :: 'a \<Rightarrow> bool) (R\<inverse> :: 'a \<Rightarrow> 'b \<Rightarrow> bool) \<longleftrightarrow> rel_surjective_at P R"
   by fast
 
-definition "rel_surjective (R :: _ \<Rightarrow> 'a \<Rightarrow> _) \<equiv> rel_surjective_at (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(rel_surjective :: (_ \<Rightarrow> 'a \<Rightarrow> _) \<Rightarrow> _) \<equiv> rel_surjective_at (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma rel_surjective_eq_rel_surjective_at:
-  "rel_surjective (R :: _ \<Rightarrow> 'a \<Rightarrow> _) = rel_surjective_at (\<top> :: 'a \<Rightarrow> bool) R"
+  "(rel_surjective :: (_ \<Rightarrow> 'a \<Rightarrow> _) \<Rightarrow> _) = rel_surjective_at (\<top> :: 'a \<Rightarrow> bool)"
   unfolding rel_surjective_def ..
 
 lemma rel_surjectiveI:
   assumes "\<And>y. in_codom R y"
   shows "rel_surjective R"
   unfolding rel_surjective_eq_rel_surjective_at using assms by (intro rel_surjective_atI)
 
 lemma rel_surjectiveE:
   assumes "rel_surjective R"
   obtains x where "R x y"
   using assms unfolding rel_surjective_eq_rel_surjective_at
   by (blast intro: top1I)
 
-lemma in_codom_if_rel_surjective_at:
+lemma in_codom_if_rel_surjective:
   assumes "rel_surjective R"
   shows "in_codom R y"
   using assms by (blast elim: rel_surjectiveE)
 
 lemma rel_surjective_rel_inv_iff_left_total [iff]: "rel_surjective R\<inverse> \<longleftrightarrow> left_total R"
   unfolding rel_surjective_eq_rel_surjective_at left_total_eq_left_total_on
   by simp
 
 lemma left_total_rel_inv_iff_rel_surjective [iff]: "left_total R\<inverse> \<longleftrightarrow> rel_surjective R"
   unfolding rel_surjective_eq_rel_surjective_at left_total_eq_left_total_on
   by simp
 
 lemma rel_surjective_at_if_surjective:
   fixes P :: "'a \<Rightarrow> bool" and R :: "_ \<Rightarrow> 'a \<Rightarrow> _"
   assumes "rel_surjective R"
   shows "rel_surjective_at P R"
-  using assms by (intro rel_surjective_atI) (blast dest: in_codom_if_rel_surjective_at)
+  using assms by (intro rel_surjective_atI) (blast dest: in_codom_if_rel_surjective)
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Symmetric.thy b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Symmetric.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Symmetric.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Symmetric.thy
@@ -1,106 +1,106 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Symmetric\<close>
 theory Binary_Relations_Symmetric
   imports
     Functions_Monotone
 begin
 
 consts symmetric_on :: "'a \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool"
 
 overloading
   symmetric_on_pred \<equiv> "symmetric_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "symmetric_on_pred P R \<equiv> \<forall>x y. P x \<and> P y \<and> R x y \<longrightarrow> R y x"
 end
 
 lemma symmetric_onI [intro]:
   assumes "\<And>x y. P x \<Longrightarrow> P y \<Longrightarrow> R x y \<Longrightarrow> R y x"
   shows "symmetric_on P R"
   unfolding symmetric_on_pred_def using assms by blast
 
 lemma symmetric_onD:
   assumes "symmetric_on P R"
   and "P x" "P y"
   and "R x y"
   shows "R y x"
   using assms unfolding symmetric_on_pred_def by blast
 
 lemma symmetric_on_rel_inv_iff_symmetric_on [iff]:
   "symmetric_on P R\<inverse> \<longleftrightarrow> symmetric_on (P :: 'a \<Rightarrow> bool) (R :: 'a \<Rightarrow> _)"
   by (blast dest: symmetric_onD)
 
 lemma antimono_symmetric_on [iff]:
   "antimono (\<lambda>(P :: 'a \<Rightarrow> bool). symmetric_on P (R :: 'a \<Rightarrow> _))"
   by (intro antimonoI) (auto dest: symmetric_onD)
 
 lemma symmetric_on_if_le_pred_if_symmetric_on:
   fixes P P' :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "symmetric_on P R"
   and "P' \<le> P"
   shows "symmetric_on P' R"
   using assms by (blast dest: symmetric_onD)
 
-definition "symmetric (R :: 'a \<Rightarrow> _) \<equiv> symmetric_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(symmetric :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> symmetric_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma symmetric_eq_symmetric_on:
-  "symmetric (R :: 'a \<Rightarrow> _) = symmetric_on (\<top> :: 'a \<Rightarrow> bool) R"
+  "(symmetric :: ('a \<Rightarrow> _) \<Rightarrow> _) = symmetric_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding symmetric_def ..
 
 lemma symmetricI [intro]:
   assumes "\<And>x y. R x y \<Longrightarrow> R y x"
   shows "symmetric R"
   unfolding symmetric_eq_symmetric_on using assms by (intro symmetric_onI)
 
 lemma symmetricD:
   assumes "symmetric R"
   and "R x y"
   shows "R y x"
   using assms unfolding symmetric_eq_symmetric_on by (auto dest: symmetric_onD)
 
 lemma symmetric_on_if_symmetric:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "symmetric R"
   shows "symmetric_on P R"
   using assms by (intro symmetric_onI) (blast dest: symmetricD)
 
 lemma symmetric_rel_inv_iff_symmetric [iff]: "symmetric R\<inverse> \<longleftrightarrow> symmetric R"
   by (blast dest: symmetricD)
 
 lemma rel_inv_eq_self_if_symmetric [simp]:
   assumes "symmetric R"
   shows "R\<inverse> = R"
   using assms by (blast dest: symmetricD)
 
 lemma rel_iff_rel_if_symmetric:
   assumes "symmetric R"
   shows "R x y \<longleftrightarrow> R y x"
   using assms by (blast dest: symmetricD)
 
 lemma symmetric_if_rel_inv_eq_self:
   assumes "R\<inverse> = R"
   shows "symmetric R"
   by (intro symmetricI, subst assms[symmetric]) simp
 
 lemma symmetric_iff_rel_inv_eq_self: "symmetric R \<longleftrightarrow> R\<inverse> = R"
   using rel_inv_eq_self_if_symmetric symmetric_if_rel_inv_eq_self by blast
 
 lemma symmetric_if_symmetric_on_in_field:
   assumes "symmetric_on (in_field R) R"
   shows "symmetric R"
   using assms by (intro symmetricI) (blast dest: symmetric_onD)
 
 corollary symmetric_on_in_field_iff_symmetric [simp]:
   "symmetric_on (in_field R) R \<longleftrightarrow> symmetric R"
   using symmetric_if_symmetric_on_in_field symmetric_on_if_symmetric
   by blast
 
 
 paragraph \<open>Instantiations\<close>
 
 lemma symmetric_eq [iff]: "symmetric (=)"
   by (rule symmetricI) (rule sym)
 
 lemma symmetric_top: "symmetric \<top>"
   by (rule symmetricI) auto
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Transitive.thy b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Transitive.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Transitive.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Properties/Binary_Relations_Transitive.thy
@@ -1,115 +1,114 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Transitive\<close>
 theory Binary_Relations_Transitive
   imports
     Binary_Relation_Functions
     Functions_Monotone
 begin
 
 consts transitive_on :: "'a \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool"
 
 overloading
   transitive_on_pred \<equiv> "transitive_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "transitive_on_pred P R \<equiv> \<forall>x y z. P x \<and> P y \<and> P z \<and> R x y \<and> R y z \<longrightarrow> R x z"
 end
 
 lemma transitive_onI [intro]:
   assumes "\<And>x y z. P x \<Longrightarrow> P y \<Longrightarrow> P z \<Longrightarrow> R x y \<Longrightarrow> R y z \<Longrightarrow> R x z"
   shows "transitive_on P R"
   unfolding transitive_on_pred_def using assms by blast
 
 lemma transitive_onD:
   assumes "transitive_on P R"
   and "P x" "P y" "P z"
   and "R x y" "R y z"
   shows "R x z"
   using assms unfolding transitive_on_pred_def by blast
 
 lemma transitive_on_if_rel_comp_self_imp:
   assumes "\<And>x y. P x \<Longrightarrow> P y \<Longrightarrow> (R \<circ>\<circ> R) x y \<Longrightarrow> R x y"
   shows "transitive_on P R"
 proof (rule transitive_onI)
   fix x y z assume "R x y" "R y z"
   then have "(R \<circ>\<circ> R) x z" by (intro rel_compI)
   moreover assume "P x" "P y" "P z"
   ultimately show "R x z" by (simp only: assms)
 qed
 
 lemma transitive_on_rel_inv_iff_transitive_on [iff]:
   "transitive_on P R\<inverse> \<longleftrightarrow> transitive_on (P :: 'a \<Rightarrow> bool) (R :: 'a \<Rightarrow> _)"
   by (auto intro!: transitive_onI dest: transitive_onD)
 
 lemma antimono_transitive_on [iff]:
   "antimono (\<lambda>(P :: 'a \<Rightarrow> bool). transitive_on P (R :: 'a \<Rightarrow> _))"
   by (intro antimonoI) (auto dest: transitive_onD)
 
 lemma transitive_on_if_le_pred_if_transitive_on:
   fixes P P' :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "transitive_on P R"
   and "P' \<le> P"
   shows "transitive_on P' R"
   using assms by (auto dest: transitive_onD)
 
-definition "transitive (R :: 'a \<Rightarrow> _) \<equiv> transitive_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(transitive :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> transitive_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma transitive_eq_transitive_on:
-  "transitive (R :: 'a \<Rightarrow> _) = transitive_on (\<top> :: 'a \<Rightarrow> bool) R"
+  "(transitive :: ('a \<Rightarrow> _) \<Rightarrow> _) = transitive_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding transitive_def ..
 
 lemma transitiveI [intro]:
   assumes "\<And>x y z. R x y \<Longrightarrow> R y z \<Longrightarrow> R x z"
   shows "transitive R"
   unfolding transitive_eq_transitive_on using assms by (intro transitive_onI)
 
 lemma transitiveD [dest]:
   assumes "transitive R"
   and "R x y" "R y z"
   shows "R x z"
   using assms unfolding transitive_eq_transitive_on
   by (auto dest: transitive_onD)
 
 lemma transitive_on_if_transitive:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "transitive R"
   shows "transitive_on P R"
   using assms by (intro transitive_onI) blast
 
 lemma transitive_if_rel_comp_le_self:
   assumes "R \<circ>\<circ> R \<le> R"
   shows "transitive R"
   using assms unfolding transitive_eq_transitive_on
     by (intro transitive_on_if_rel_comp_self_imp) blast
 
 lemma rel_comp_le_self_if_transitive:
   assumes "transitive R"
   shows "R \<circ>\<circ> R \<le> R"
   using assms by blast
 
 corollary transitive_iff_rel_comp_le_self: "transitive R \<longleftrightarrow> R \<circ>\<circ> R \<le> R"
   using transitive_if_rel_comp_le_self rel_comp_le_self_if_transitive by blast
 
 lemma transitive_if_transitive_on_in_field:
   assumes "transitive_on (in_field R) R"
   shows "transitive R"
   using assms by (intro transitiveI) (blast dest: transitive_onD)
 
 corollary transitive_on_in_field_iff_transitive [simp]:
   "transitive_on (in_field R) R \<longleftrightarrow> transitive R"
   using transitive_if_transitive_on_in_field transitive_on_if_transitive
   by blast
 
-lemma transitive_rel_inv_iff_transitive [iff]:
-  "transitive R\<inverse> \<longleftrightarrow> transitive R"
-  by (auto intro!: transitiveI)
+lemma transitive_rel_inv_iff_transitive [iff]: "transitive R\<inverse> \<longleftrightarrow> transitive R"
+  by fast
 
 paragraph \<open>Instantiations\<close>
 
 lemma transitive_eq: "transitive (=)"
   by (rule transitiveI) (rule trans)
 
 lemma transitive_top: "transitive \<top>"
   by (rule transitiveI) auto
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Binary_Relations/Restricted_Equality.thy b/thys/Transport/HOL_Basics/Binary_Relations/Restricted_Equality.thy
--- a/thys/Transport/HOL_Basics/Binary_Relations/Restricted_Equality.thy
+++ b/thys/Transport/HOL_Basics/Binary_Relations/Restricted_Equality.thy
@@ -1,98 +1,68 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Restricted Equality\<close>
 theory Restricted_Equality
   imports
     Binary_Relations_Order_Base
     Binary_Relation_Functions
     Equivalence_Relations
     Partial_Orders
 begin
 
 paragraph \<open>Summary\<close>
-text \<open>Introduces the concept of restricted equalities.
+text \<open>Introduces notations and theorems for restricted equalities.
 An equality @{term "(=)"} can be restricted to only apply to a subset of its
-elements. The restriction can be formulated, for example, by a predicate or a
-set.\<close>
-
-consts eq_restrict :: "'a \<Rightarrow> 'b \<Rightarrow> 'b \<Rightarrow> bool"
+elements. The restriction can be formulated, for example, by a predicate or a set.\<close>
 
 bundle eq_restrict_syntax
 begin
 syntax
-  "_eq_restrict" :: "'a \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool" ("(_) =(\<^bsub>_\<^esub>) (_)" [51,51,51] 50)
-notation eq_restrict ("'(=(\<^bsub>_\<^esub>)')")
+  "_eq_restrict_infix" :: "'a \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool" ("(_) =(\<^bsub>_\<^esub>) (_)" [51,51,51] 50)
+  "_eq_restrict" :: "('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool" ("'(=(\<^bsub>_\<^esub>)')")
 end
 bundle no_eq_restrict_syntax
 begin
 no_syntax
-  "_eq_restrict" :: "'a \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool" ("(_) =(\<^bsub>_\<^esub>) (_)" [51,51,51] 50)
-no_notation eq_restrict ("'(=(\<^bsub>_\<^esub>)')")
+  "_eq_restrict_infix" :: "'a \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool" ("(_) =(\<^bsub>_\<^esub>) (_)" [51,51,51] 50)
+  "_eq_restrict" :: "('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool" ("'(=(\<^bsub>_\<^esub>)')")
 end
 unbundle eq_restrict_syntax
 
 translations
-  "x =\<^bsub>P\<^esub> y" \<rightleftharpoons> "CONST eq_restrict P x y"
-
-overloading
-  eq_restrict_pred \<equiv> "eq_restrict :: ('a \<Rightarrow>  bool) \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> bool"
-begin
-  definition "eq_restrict_pred (P :: 'a \<Rightarrow> bool) \<equiv> ((=) :: 'a \<Rightarrow> _)\<restriction>\<^bsub>P\<^esub>"
-end
-
-lemma eq_restrict_eq_eq_restrict_left: "((=\<^bsub>P :: 'a \<Rightarrow> bool\<^esub>) :: 'a \<Rightarrow> _) = (=)\<restriction>\<^bsub>P\<^esub>"
-  unfolding eq_restrict_pred_def by simp
-
-lemma eq_restrictI [intro]:
-  assumes "x = y"
-  and "P x"
-  shows "x =\<^bsub>P\<^esub> y"
-  unfolding eq_restrict_eq_eq_restrict_left using assms by auto
-
-lemma eq_restrictE [elim]:
-  assumes "x =\<^bsub>P\<^esub> y"
-  obtains "P x" "y = x"
-  using assms unfolding eq_restrict_eq_eq_restrict_left by auto
-
-lemma eq_restrict_iff: "x =\<^bsub>P\<^esub> y \<longleftrightarrow> y = x \<and> P x" by auto
-
-lemma eq_restrict_le_eq: "((=\<^bsub>P :: 'a \<Rightarrow> bool\<^esub>) :: 'a \<Rightarrow> _) \<le> (=)"
-  by (intro le_relI) auto
-
-lemma eq_restrict_top_eq_eq [simp]: "(=\<^bsub>\<top> :: 'a \<Rightarrow> bool\<^esub>) = ((=) :: 'a \<Rightarrow> _)"
-  unfolding eq_restrict_eq_eq_restrict_left by simp
+  "(=\<^bsub>P\<^esub>)" \<rightleftharpoons> "CONST restrict_left (=) P"
+  "x =\<^bsub>P\<^esub> y" \<rightleftharpoons> "CONST restrict_left (=) P x y"
 
 lemma in_dom_eq_restrict_eq [simp]: "in_dom (=\<^bsub>P\<^esub>) = P" by auto
 lemma in_codom_eq_restrict_eq [simp]: "in_codom (=\<^bsub>P\<^esub>) = P" by auto
 lemma in_field_eq_restrict_eq [simp]: "in_field (=\<^bsub>P\<^esub>) = P" by auto
 
 
 paragraph \<open>Order Properties\<close>
 
 context
   fixes P :: "'a \<Rightarrow> bool"
 begin
 
 context
 begin
 lemma reflexive_on_eq_restrict: "reflexive_on P ((=\<^bsub>P\<^esub>) :: 'a \<Rightarrow> _)" by auto
 lemma transitive_eq_restrict: "transitive ((=\<^bsub>P\<^esub>) :: 'a \<Rightarrow> _)" by auto
 lemma symmetric_eq_restrict: "symmetric ((=\<^bsub>P\<^esub>) :: 'a \<Rightarrow> _)" by auto
 lemma antisymmetric_eq_restrict: "antisymmetric ((=\<^bsub>P\<^esub>) :: 'a \<Rightarrow> _)" by auto
 end
 
 context
 begin
 lemma preorder_on_eq_restrict: "preorder_on P ((=\<^bsub>P\<^esub>) :: 'a \<Rightarrow> _)"
   using reflexive_on_eq_restrict transitive_eq_restrict by auto
 lemma partial_equivalence_rel_eq_restrict: "partial_equivalence_rel ((=\<^bsub>P\<^esub>) :: 'a \<Rightarrow> _)"
   using symmetric_eq_restrict transitive_eq_restrict by auto
 end
 
 lemma partial_order_on_eq_restrict: "partial_order_on P ((=\<^bsub>P\<^esub>) :: 'a \<Rightarrow> _)"
   using preorder_on_eq_restrict antisymmetric_eq_restrict by auto
 lemma equivalence_rel_on_eq_restrict: "equivalence_rel_on P ((=\<^bsub>P\<^esub>) :: 'a \<Rightarrow> _)"
   using partial_equivalence_rel_eq_restrict reflexive_on_eq_restrict by blast
 end
 
 
 end
diff --git a/thys/Transport/HOL_Basics/Functions/Function_Relators.thy b/thys/Transport/HOL_Basics/Functions/Function_Relators.thy
--- a/thys/Transport/HOL_Basics/Functions/Function_Relators.thy
+++ b/thys/Transport/HOL_Basics/Functions/Function_Relators.thy
@@ -1,163 +1,163 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Relators\<close>
 theory Function_Relators
   imports
     Binary_Relation_Functions
     Functions_Base
     Predicates_Lattice
 begin
 
 paragraph \<open>Summary\<close>
 text \<open>Introduces the concept of function relators. The slogan of function
 relators is "related functions map related inputs to related outputs".\<close>
 
 definition "Dep_Fun_Rel_rel R S f g \<equiv> \<forall>x y. R x y \<longrightarrow> S x y (f x) (g y)"
 
 abbreviation "Fun_Rel_rel R S \<equiv> Dep_Fun_Rel_rel R (\<lambda>_ _. S)"
 
 definition "Dep_Fun_Rel_pred P R f g \<equiv> \<forall>x. P x \<longrightarrow> R x (f x) (g x)"
 
 abbreviation "Fun_Rel_pred P R \<equiv> Dep_Fun_Rel_pred P (\<lambda>_. R)"
 
 bundle Dep_Fun_Rel_syntax begin
 syntax
   "_Fun_Rel_rel" :: "('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'c) \<Rightarrow>
     ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("(_) \<Rrightarrow> (_)" [41, 40] 40)
   "_Dep_Fun_Rel_rel" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'c) \<Rightarrow> ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _] \<Rrightarrow> (_)" [41, 41, 41, 40] 40)
   "_Dep_Fun_Rel_rel_if" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'c) \<Rightarrow> ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _/ |/ _] \<Rrightarrow> (_)" [41, 41, 41, 41, 40] 40)
   "_Fun_Rel_pred" :: "('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow>
     ('a \<Rightarrow> 'c) \<Rightarrow> bool" ("[_] \<Rrightarrow> (_)" [41, 40] 40)
   "_Dep_Fun_Rel_pred" :: "idt \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'b) \<Rightarrow> ('a \<Rightarrow> 'c) \<Rightarrow> bool" ("[_/ \<Colon>/ _] \<Rrightarrow> (_)" [41, 41, 40] 40)
   "_Dep_Fun_Rel_pred_if" :: "idt \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'b) \<Rightarrow> ('a \<Rightarrow> 'c) \<Rightarrow> bool" ("[_/ \<Colon>/ _/ |/ _] \<Rrightarrow> (_)" [41, 41, 41, 40] 40)
 end
 bundle no_Dep_Fun_Rel_syntax begin
 no_syntax
   "_Fun_Rel_rel" :: "('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'c) \<Rightarrow>
     ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("(_) \<Rrightarrow> (_)" [41, 40] 40)
   "_Dep_Fun_Rel_rel" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'c) \<Rightarrow> ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _] \<Rrightarrow> (_)" [41, 41, 41, 40] 40)
   "_Dep_Fun_Rel_rel_if" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'c) \<Rightarrow> ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _/ |/ _] \<Rrightarrow> (_)" [41, 41, 41, 41, 40] 40)
   "_Fun_Rel_pred" :: "('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow>
     ('a \<Rightarrow> 'c) \<Rightarrow> bool" ("[_] \<Rrightarrow> (_)" [41, 40] 40)
   "_Dep_Fun_Rel_pred" :: "idt \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'b) \<Rightarrow> ('a \<Rightarrow> 'c) \<Rightarrow> bool" ("[_/ \<Colon>/ _] \<Rrightarrow> (_)" [41, 41, 40] 40)
   "_Dep_Fun_Rel_pred_if" :: "idt \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('b \<Rightarrow> 'c \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'b) \<Rightarrow> ('a \<Rightarrow> 'c) \<Rightarrow> bool" ("[_/ \<Colon>/ _/ |/ _] \<Rrightarrow> (_)" [41, 41, 41, 40] 40)
 end
 unbundle Dep_Fun_Rel_syntax
 translations
   "R \<Rrightarrow> S" \<rightleftharpoons> "CONST Fun_Rel_rel R S"
   "[x y \<Colon> R] \<Rrightarrow> S" \<rightleftharpoons> "CONST Dep_Fun_Rel_rel R (\<lambda>x y. S)"
   "[x y \<Colon> R | B] \<Rrightarrow> S" \<rightleftharpoons> "CONST Dep_Fun_Rel_rel R (\<lambda>x y. CONST rel_if B S)"
   "[P] \<Rrightarrow> R" \<rightleftharpoons> "CONST Fun_Rel_pred P R"
   "[x \<Colon> P] \<Rrightarrow> R" \<rightleftharpoons> "CONST Dep_Fun_Rel_pred P (\<lambda>x. R)"
   "[x \<Colon> P | B] \<Rrightarrow> R" \<rightleftharpoons> "CONST Dep_Fun_Rel_pred P (\<lambda>x. CONST rel_if B R)"
 
 lemma Dep_Fun_Rel_relI [intro]:
   assumes "\<And>x y. R x y \<Longrightarrow> S x y (f x) (g y)"
   shows "([x y \<Colon> R] \<Rrightarrow> S x y) f g"
   unfolding Dep_Fun_Rel_rel_def using assms by blast
 
 lemma Dep_Fun_Rel_relD:
   assumes "([x y \<Colon> R] \<Rrightarrow> S x y) f g"
   and "R x y"
   shows "S x y (f x) (g y)"
   using assms unfolding Dep_Fun_Rel_rel_def by blast
 
 lemma Dep_Fun_Rel_relE [elim]:
   assumes "([x y \<Colon> R] \<Rrightarrow> S x y) f g"
   and "R x y"
   obtains "S x y (f x) (g y)"
   using assms unfolding Dep_Fun_Rel_rel_def by blast
 
 lemma Dep_Fun_Rel_predI [intro]:
   assumes "\<And>x. P x \<Longrightarrow> R x (f x) (g x)"
   shows "([x \<Colon> P] \<Rrightarrow> R x) f g"
   unfolding Dep_Fun_Rel_pred_def using assms by blast
 
 lemma Dep_Fun_Rel_predD:
   assumes "([x \<Colon> P] \<Rrightarrow> R x) f g"
   and "P x"
   shows "R x (f x) (g x)"
   using assms unfolding Dep_Fun_Rel_pred_def by blast
 
 lemma Dep_Fun_Rel_predE [elim]:
   assumes "([x \<Colon> P] \<Rrightarrow> R x) f g"
   and "P x"
   obtains "R x (f x) (g x)"
   using assms unfolding Dep_Fun_Rel_pred_def by blast
 
 lemma rel_inv_Dep_Fun_Rel_rel_eq [simp]:
   "([x y \<Colon> R] \<Rrightarrow> S x y)\<inverse> = ([y x \<Colon> R\<inverse>] \<Rrightarrow> (S x y)\<inverse>)"
   by (intro ext) auto
 
 lemma rel_inv_Dep_Fun_Rel_pred_eq [simp]:
   "([x \<Colon> P] \<Rrightarrow> R x)\<inverse> = ([x \<Colon> P] \<Rrightarrow> (R x)\<inverse>)"
   by (intro ext) auto
 
 lemma Dep_Fun_Rel_pred_eq_Dep_Fun_Rel_rel:
   "([x \<Colon> P] \<Rrightarrow> R x) = ([x _ \<Colon> (((\<sqinter>) P) \<circ> (=))] \<Rrightarrow> R x)"
   by (intro ext) (auto intro!: Dep_Fun_Rel_predI Dep_Fun_Rel_relI)
 
 lemma Fun_Rel_eq_eq_eq [simp]: "((=) \<Rrightarrow> (=)) = (=)"
   by (intro ext) auto
 
 
 paragraph \<open>Composition\<close>
 
 lemma Dep_Fun_Rel_rel_compI:
   assumes Dep_Fun_Rel1: "([x y \<Colon> R] \<Rrightarrow> S x y) f g"
   and Dep_Fun_Rel2: "\<And>x y. R x y \<Longrightarrow> ([x' y' \<Colon> T x y] \<Rrightarrow> U x y x' y') f' g'"
   and le: "\<And>x y. R x y \<Longrightarrow> S x y (f x) (g y) \<Longrightarrow> T x y (f x) (g y)"
   shows "([x y \<Colon> R] \<Rrightarrow> U x y (f x) (g y)) (f' \<circ> f) (g' \<circ> g)"
   using assms by (intro Dep_Fun_Rel_relI) (auto 6 0)
 
 corollary Dep_Fun_Rel_rel_compI':
   assumes "([x y \<Colon> R] \<Rrightarrow> S x y) f g"
   and "\<And>x y. R x y \<Longrightarrow> ([x' y' \<Colon> S x y] \<Rrightarrow> T x y x' y') f' g'"
   shows "([x y \<Colon> R] \<Rrightarrow> T x y (f x) (g y)) (f' \<circ> f) (g' \<circ> g)"
   using assms by (intro Dep_Fun_Rel_rel_compI)
 
 lemma Dep_Fun_Rel_pred_comp_Dep_Fun_Rel_rel_compI:
   assumes Dep_Fun_Rel1: "([x \<Colon> P] \<Rrightarrow> R x) f g"
   and Dep_Fun_Rel2: "\<And>x. P x \<Longrightarrow> ([x' y' \<Colon> S x] \<Rrightarrow> T x x' y') f' g'"
   and le: "\<And>x. P x \<Longrightarrow> R x (f x) (g x) \<Longrightarrow> S x (f x) (g x)"
   shows "([x \<Colon> P] \<Rrightarrow> T x (f x) (g x)) (f' \<circ> f) (g' \<circ> g)"
   using assms by (intro Dep_Fun_Rel_predI) (auto 6 0)
 
 corollary Dep_Fun_Rel_pred_comp_Dep_Fun_Rel_rel_compI':
   assumes "([x \<Colon> P] \<Rrightarrow> R x) f g"
   and "\<And>x. P x \<Longrightarrow> ([x' y' \<Colon> R x] \<Rrightarrow> S x x' y') f' g'"
   shows "([x \<Colon> P] \<Rrightarrow> S x (f x) (g x)) (f' \<circ> f) (g' \<circ> g)"
   using assms by (intro Dep_Fun_Rel_pred_comp_Dep_Fun_Rel_rel_compI)
 
 
 paragraph \<open>Restrictions\<close>
 
 lemma restrict_left_Dep_Fun_Rel_rel_restrict_left_eq:
   fixes R :: "'a1 \<Rightarrow> 'a2 \<Rightarrow> bool"
   and S :: "'a1 \<Rightarrow> 'a2 \<Rightarrow> 'b1 \<Rightarrow> 'b2 \<Rightarrow> bool"
   and P :: "'a1 \<Rightarrow> 'a2 \<Rightarrow> 'b1 \<Rightarrow> bool"
   assumes "\<And>f x y. Q f \<Longrightarrow> R x y \<Longrightarrow> P x y (f x)"
   shows "([x y \<Colon> R] \<Rrightarrow> (S x y)\<restriction>\<^bsub>P x y\<^esub>)\<restriction>\<^bsub>Q\<^esub> = ([x y \<Colon> R] \<Rrightarrow> S x y)\<restriction>\<^bsub>Q\<^esub>"
-  using assms by (intro ext iffI restrict_leftI Dep_Fun_Rel_relI)
+  using assms by (intro ext iffI bin_rel_restrict_leftI Dep_Fun_Rel_relI)
   (auto dest!: Dep_Fun_Rel_relD)
 
 lemma restrict_right_Dep_Fun_Rel_rel_restrict_right_eq:
   fixes R :: "'a1 \<Rightarrow> 'a2 \<Rightarrow> bool"
   and S :: "'a1 \<Rightarrow> 'a2 \<Rightarrow> 'b1 \<Rightarrow> 'b2 \<Rightarrow> bool"
   and P :: "'a1 \<Rightarrow> 'a2 \<Rightarrow> 'b2 \<Rightarrow> bool"
   assumes "\<And>f x y. Q f \<Longrightarrow> R x y \<Longrightarrow> P x y (f y)"
   shows "(([x y \<Colon> R] \<Rrightarrow> (S x y)\<upharpoonleft>\<^bsub>P x y\<^esub>)\<upharpoonleft>\<^bsub>Q\<^esub>) = (([x y \<Colon> R] \<Rrightarrow> S x y)\<upharpoonleft>\<^bsub>Q\<^esub>)"
-  unfolding restrict_right_eq
+  unfolding bin_rel_restrict_right_eq
   using assms restrict_left_Dep_Fun_Rel_rel_restrict_left_eq[where ?R="R\<inverse>"
     and ?S="\<lambda>y x. (S x y)\<inverse>"]
   by simp
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Functions/Properties/Functions_Bijection.thy b/thys/Transport/HOL_Basics/Functions/Properties/Functions_Bijection.thy
--- a/thys/Transport/HOL_Basics/Functions/Properties/Functions_Bijection.thy
+++ b/thys/Transport/HOL_Basics/Functions/Properties/Functions_Bijection.thy
@@ -1,150 +1,149 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Bijection\<close>
 theory Functions_Bijection
   imports
     Functions_Inverse
     Functions_Monotone
 begin
 
 consts bijection_on :: "'a \<Rightarrow> 'b \<Rightarrow> ('c \<Rightarrow> 'd) \<Rightarrow> ('d \<Rightarrow> 'c) \<Rightarrow> bool"
 
 overloading
-  bijection_on_pred \<equiv> "bijection_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> bool) \<Rightarrow>
-    ('a \<Rightarrow> 'b) \<Rightarrow> ('b \<Rightarrow> 'a) \<Rightarrow> bool"
+  bijection_on_pred \<equiv> "bijection_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow> ('b \<Rightarrow> 'a) \<Rightarrow> bool"
 begin
   definition "bijection_on_pred P P' f g \<equiv>
     ([P] \<Rrightarrow>\<^sub>m P') f \<and>
     ([P'] \<Rrightarrow>\<^sub>m P) g \<and>
     inverse_on P f g \<and>
     inverse_on P' g f"
 end
 
 lemma bijection_onI [intro]:
   assumes "([P] \<Rrightarrow>\<^sub>m P') f"
   and "([P'] \<Rrightarrow>\<^sub>m P) g"
   and "inverse_on P f g"
   and "inverse_on P' g f"
   shows "bijection_on P P' f g"
   using assms unfolding bijection_on_pred_def by blast
 
 lemma bijection_onE:
   assumes "bijection_on P P' f g"
   obtains "([P] \<Rrightarrow>\<^sub>m P') f" "([P'] \<Rrightarrow>\<^sub>m P) g"
     "inverse_on P f g" "inverse_on P' g f"
   using assms unfolding bijection_on_pred_def by blast
 
 context
   fixes P :: "'a \<Rightarrow> bool"
   and P' :: "'b \<Rightarrow> bool"
   and f :: "'a \<Rightarrow> 'b"
 begin
 
 lemma mono_wrt_pred_if_bijection_on_left:
   assumes "bijection_on P P' f g"
   shows "([P] \<Rrightarrow>\<^sub>m P') f"
   using assms by (elim bijection_onE)
 
 lemma mono_wrt_pred_if_bijection_on_right:
   assumes "bijection_on P P' f g"
   shows "([P'] \<Rrightarrow>\<^sub>m P) g"
   using assms by (elim bijection_onE)
 
 lemma bijection_on_pred_right:
   assumes "bijection_on P P' f g"
   and "P x"
   shows "P' (f x)"
   using assms by (blast elim: bijection_onE)
 
 lemma bijection_on_pred_left:
   assumes "bijection_on P P' f g"
   and "P' y"
   shows "P (g y)"
   using assms by (blast elim: bijection_onE)
 
 lemma inverse_on_if_bijection_on_left_right:
   assumes "bijection_on P P' f g"
   shows "inverse_on P f g"
   using assms by (elim bijection_onE)
 
 lemma inverse_on_if_bijection_on_right_left:
   assumes "bijection_on P P' f g"
   shows "inverse_on P' g f"
   using assms by (elim bijection_onE)
 
 lemma bijection_on_left_right_eq_self:
   assumes "bijection_on P P' f g"
   and "P x"
   shows "g (f x) = x"
   using assms inverse_on_if_bijection_on_left_right
   by (intro inverse_onD)
 
 lemma bijection_on_right_left_eq_self':
   assumes "bijection_on P P' f g"
   and "P' y"
   shows "f (g y) = y"
   using assms inverse_on_if_bijection_on_right_left by (intro inverse_onD)
 
 lemma bijection_on_right_left_if_bijection_on_left_right:
   assumes "bijection_on P P' f g"
   shows "bijection_on P' P g f"
   using assms by (auto elim: bijection_onE)
 
 lemma injective_on_if_bijection_on_left:
   assumes "bijection_on P P' f g"
   shows "injective_on P f"
   using assms
   by (intro injective_on_if_inverse_on inverse_on_if_bijection_on_left_right)
 
 lemma injective_on_if_bijection_on_right:
   assumes "bijection_on P P' f g"
   shows "injective_on P' g"
   by (intro injective_on_if_inverse_on)
   (fact inverse_on_if_bijection_on_right_left[OF assms])
 
 end
 
 
-definition "bijection (f :: 'a \<Rightarrow> 'b) \<equiv> bijection_on (\<top> :: 'a \<Rightarrow> bool) (\<top> :: 'b \<Rightarrow> bool) f"
+definition "(bijection :: ('a \<Rightarrow> 'b) \<Rightarrow> _) \<equiv> bijection_on (\<top> :: 'a \<Rightarrow> bool) (\<top> :: 'b \<Rightarrow> bool)"
 
 lemma bijection_eq_bijection_on:
-  "bijection (f :: 'a \<Rightarrow> 'b) = bijection_on (\<top> :: 'a \<Rightarrow> bool) (\<top> :: 'b \<Rightarrow> bool) f"
+  "(bijection :: ('a \<Rightarrow> 'b) \<Rightarrow> _) = bijection_on (\<top> :: 'a \<Rightarrow> bool) (\<top> :: 'b \<Rightarrow> bool)"
   unfolding bijection_def ..
 
 lemma bijectionI [intro]:
   assumes "inverse f g"
   and "inverse g f"
   shows "bijection f g"
   unfolding bijection_eq_bijection_on using assms
   by (intro bijection_onI inverse_on_if_inverse dep_mono_wrt_predI) simp_all
 
 lemma bijectionE [elim]:
   assumes "bijection f g"
   obtains "inverse f g" "inverse g f"
   using assms unfolding bijection_eq_bijection_on inverse_eq_inverse_on
   by (blast elim: bijection_onE)
 
 lemma inverse_if_bijection_left_right:
   assumes "bijection f g"
   shows "inverse f g"
   using assms by (elim bijectionE)
 
 lemma inverse_if_bijection_right_left:
   assumes "bijection f g"
   shows "inverse g f"
   using assms by (elim bijectionE)
 
 lemma bijection_right_left_if_bijection_left_right:
   assumes "bijection f g"
   shows "bijection g f"
   using assms by auto
 
 
 paragraph \<open>Instantiations\<close>
 
 lemma bijection_on_self_id:
   fixes P :: "'a \<Rightarrow> bool"
   shows "bijection_on P P (id :: 'a \<Rightarrow> _) id"
   by (intro bijection_onI inverse_onI dep_mono_wrt_predI) simp_all
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Functions/Properties/Functions_Injective.thy b/thys/Transport/HOL_Basics/Functions/Properties/Functions_Injective.thy
--- a/thys/Transport/HOL_Basics/Functions/Properties/Functions_Injective.thy
+++ b/thys/Transport/HOL_Basics/Functions/Properties/Functions_Injective.thy
@@ -1,58 +1,57 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Injective\<close>
 theory Functions_Injective
   imports
     Functions_Base
     HOL_Syntax_Bundles_Lattices
 begin
 
 consts injective_on :: "'a \<Rightarrow> ('b \<Rightarrow> 'c) \<Rightarrow> bool"
 
 overloading
   injective_on_pred \<equiv> "injective_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow> bool"
 begin
   definition "injective_on_pred P f \<equiv> \<forall>x x'. P x \<longrightarrow> P x' \<longrightarrow> f x = f x' \<longrightarrow> x = x'"
 end
 
 lemma injective_onI [intro]:
   assumes "\<And>x x'. P x \<Longrightarrow> P x' \<Longrightarrow> f x = f x' \<Longrightarrow> x = x'"
   shows "injective_on P f"
   unfolding injective_on_pred_def using assms by blast
 
 lemma injective_onD:
   assumes "injective_on P f"
   and "P x" "P x'"
   and "f x = f x'"
   shows "x = x'"
   using assms unfolding injective_on_pred_def by blast
 
-definition "injective (f :: 'a \<Rightarrow> _) \<equiv> injective_on (\<top> :: 'a \<Rightarrow> bool) f"
+definition "(injective :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> injective_on (\<top> :: 'a \<Rightarrow> bool)"
 
-lemma injective_eq_injective_on:
-  "injective (f :: 'a \<Rightarrow> _) = injective_on (\<top> :: 'a \<Rightarrow> bool) f"
+lemma injective_eq_injective_on: "(injective :: ('a \<Rightarrow> _) \<Rightarrow> _) = injective_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding injective_def ..
 
 lemma injectiveI [intro]:
   assumes "\<And>x x'. f x = f x' \<Longrightarrow> x = x'"
   shows "injective f"
   unfolding injective_eq_injective_on using assms by (intro injective_onI)
 
 lemma injectiveD:
   assumes "injective f"
   and "f x = f x'"
   shows "x = x'"
   using assms unfolding injective_eq_injective_on by (auto dest: injective_onD)
 
 lemma injective_on_if_injective:
   fixes P :: "'a \<Rightarrow> bool" and f :: "'a \<Rightarrow> _"
   assumes "injective f"
   shows "injective_on P f"
   using assms by (intro injective_onI) (blast dest: injectiveD)
 
 
 paragraph \<open>Instantiations\<close>
 
 lemma injective_id: "injective id" by auto
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Functions/Properties/Functions_Inverse.thy b/thys/Transport/HOL_Basics/Functions/Properties/Functions_Inverse.thy
--- a/thys/Transport/HOL_Basics/Functions/Properties/Functions_Inverse.thy
+++ b/thys/Transport/HOL_Basics/Functions/Properties/Functions_Inverse.thy
@@ -1,62 +1,61 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Inverse\<close>
 theory Functions_Inverse
   imports
     Functions_Injective
 begin
 
 consts inverse_on :: "'a \<Rightarrow> ('b \<Rightarrow> 'c) \<Rightarrow> ('c \<Rightarrow> 'b) \<Rightarrow> bool"
 
 overloading
   inverse_on_pred \<equiv> "inverse_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow> ('b \<Rightarrow> 'a) \<Rightarrow> bool"
 begin
   definition "inverse_on_pred P f g \<equiv> \<forall>x. P x \<longrightarrow> g (f x) = x"
 end
 
 lemma inverse_onI [intro]:
   assumes "\<And>x. P x \<Longrightarrow> g (f x) = x"
   shows "inverse_on P f g"
   unfolding inverse_on_pred_def using assms by blast
 
 lemma inverse_onD:
   assumes "inverse_on P f g"
   and "P x"
   shows "g (f x) = x"
   using assms unfolding inverse_on_pred_def by blast
 
 lemma injective_on_if_inverse_on:
   assumes inv: "inverse_on (P :: 'a \<Rightarrow> bool) (f :: 'a \<Rightarrow> _) g"
   shows "injective_on P f"
 proof (rule injective_onI)
   fix x x'
   assume Px: "P x" and Px': "P x'" and f_x_eq_f_x': "f x = f x'"
   from inv have "x = g (f x)" using Px by (intro inverse_onD[symmetric])
   also have "... = g (f x')" by (simp only: f_x_eq_f_x')
   also have "... = x'" using inv Px' by (intro inverse_onD)
   finally show "x = x'" .
 qed
 
-definition "inverse (f :: 'a \<Rightarrow> _) \<equiv> inverse_on (\<top> :: 'a \<Rightarrow> bool) f"
+definition "(inverse :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> inverse_on (\<top> :: 'a \<Rightarrow> bool)"
 
-lemma inverse_eq_inverse_on:
-  "inverse (f :: 'a \<Rightarrow> _) = inverse_on (\<top> :: 'a \<Rightarrow> bool) f"
+lemma inverse_eq_inverse_on: "(inverse :: ('a \<Rightarrow> _) \<Rightarrow> _) = inverse_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding inverse_def ..
 
 lemma inverseI [intro]:
   assumes "\<And>x. g (f x) = x"
   shows "inverse f g"
   unfolding inverse_eq_inverse_on using assms by (intro inverse_onI)
 
 lemma inverseD:
   assumes "inverse f g"
   shows "g (f x) = x"
   using assms unfolding inverse_eq_inverse_on by (auto dest: inverse_onD)
 
 lemma inverse_on_if_inverse:
   fixes P :: "'a \<Rightarrow> bool" and f :: "'a \<Rightarrow> 'b"
   assumes "inverse f g"
   shows "inverse_on P f g"
   using assms by (intro inverse_onI) (blast dest: inverseD)
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Functions/Properties/Functions_Monotone.thy b/thys/Transport/HOL_Basics/Functions/Properties/Functions_Monotone.thy
--- a/thys/Transport/HOL_Basics/Functions/Properties/Functions_Monotone.thy
+++ b/thys/Transport/HOL_Basics/Functions/Properties/Functions_Monotone.thy
@@ -1,345 +1,340 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Monotonicity\<close>
 theory Functions_Monotone
   imports
     Binary_Relations_Order_Base
     Function_Relators
     Predicates
 begin
 
 paragraph \<open>Summary\<close>
 text \<open>Introduces the concept of monotone functions. A function is monotone
 if it is related to itself - see \<^term>\<open>Dep_Fun_Rel_rel\<close>.\<close>
 
 declare le_funI[intro]
 declare le_funE[elim]
 
 definition "dep_mono_wrt_rel R S f \<equiv> ([x y \<Colon> R] \<Rrightarrow> S x y) f f"
 
 abbreviation "mono_wrt_rel R S \<equiv> dep_mono_wrt_rel R (\<lambda>_ _. S)"
 
 definition "dep_mono_wrt_pred P Q f \<equiv> ([x \<Colon> P] \<Rrightarrow> (\<lambda>_. Q x)) f f"
 
 abbreviation "mono_wrt_pred P Q \<equiv> dep_mono_wrt_pred P (\<lambda>_. Q)"
 
 bundle dep_mono_wrt_syntax begin
 syntax
   "_mono_wrt_rel" :: "('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow>
     bool" ("(_) \<Rrightarrow>\<^sub>m (_)" [41, 40] 40)
   "_dep_mono_wrt_rel" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'b) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _] \<Rrightarrow>\<^sub>m (_)" [41, 41, 41, 40] 40)
   "_dep_mono_wrt_rel_if" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'b) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _/ |/ _] \<Rrightarrow>\<^sub>m (_)" [41, 41, 41, 41, 40] 40)
   "_mono_wrt_pred" :: "('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow>
     bool" ("[_] \<Rrightarrow>\<^sub>m (_)" [41, 40] 40)
   "_dep_mono_wrt_pred" :: "idt \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'b) \<Rightarrow> bool" ("[_/ \<Colon>/ _] \<Rrightarrow>\<^sub>m (_)" [41, 41, 40] 40)
-  (*TODO: this only works if we introduce a pred_if constant first*)
-  (* "_dep_mono_wrt_pred_if" :: "idt \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> *)
-    (* ('a \<Rightarrow> 'b) \<Rightarrow> bool" ("[_/ \<Colon>/ _/ |/ _] \<Rrightarrow>\<^sub>m (_)" [41, 41, 41, 40] 40) *)
+  "_dep_mono_wrt_pred_if" :: "idt \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow>
+    ('a \<Rightarrow> 'b) \<Rightarrow> bool" ("[_/ \<Colon>/ _/ |/ _] \<Rrightarrow>\<^sub>m (_)" [41, 41, 41, 40] 40)
 end
 bundle no_dep_mono_wrt_syntax begin
 no_syntax
   "_mono_wrt_rel" :: "('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow>
     bool" ("(_) \<Rrightarrow>\<^sub>m (_)" [41, 40] 40)
   "_dep_mono_wrt_rel" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'b) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _] \<Rrightarrow>\<^sub>m (_)" [41, 41, 41, 40] 40)
   "_dep_mono_wrt_rel_if" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'b) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _/ |/ _] \<Rrightarrow>\<^sub>m (_)" [41, 41, 41, 41, 40] 40)
   "_mono_wrt_pred" :: "('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow>
     bool" ("[_] \<Rrightarrow>\<^sub>m (_)" [41, 40] 40)
   "_dep_mono_wrt_pred" :: "idt \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'b) \<Rightarrow> bool" ("[_/ \<Colon>/ _] \<Rrightarrow>\<^sub>m (_)" [41, 41, 40] 40)
-  (* "_dep_mono_wrt_pred_if" :: "idt \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> *)
-    (* ('a \<Rightarrow> 'b) \<Rightarrow> bool" ("[_/ \<Colon>/ _/ |/ _] \<Rrightarrow>\<^sub>m (_)" [41, 41, 41, 40] 40) *)
+  "_dep_mono_wrt_pred_if" :: "idt \<Rightarrow> ('a \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow>
+    ('a \<Rightarrow> 'b) \<Rightarrow> bool" ("[_/ \<Colon>/ _/ |/ _] \<Rrightarrow>\<^sub>m (_)" [41, 41, 41, 40] 40)
 end
 unbundle dep_mono_wrt_syntax
 translations
   "R \<Rrightarrow>\<^sub>m S" \<rightleftharpoons> "CONST mono_wrt_rel R S"
   "[x y \<Colon> R] \<Rrightarrow>\<^sub>m S" \<rightleftharpoons> "CONST dep_mono_wrt_rel R (\<lambda>x y. S)"
   "[x y \<Colon> R | B] \<Rrightarrow>\<^sub>m S" \<rightleftharpoons> "CONST dep_mono_wrt_rel R (\<lambda>x y. CONST rel_if B S)"
   "[P] \<Rrightarrow>\<^sub>m Q" \<rightleftharpoons> "CONST mono_wrt_pred P Q"
   "[x \<Colon> P] \<Rrightarrow>\<^sub>m Q" \<rightleftharpoons> "CONST dep_mono_wrt_pred P (\<lambda>x. Q)"
-  (* "[x \<Colon> P | B] \<Rrightarrow>\<^sub>m Q" \<rightleftharpoons> "CONST dep_mono_wrt_pred P (\<lambda>x. CONST rel_if B Q)" *)
+  "[x \<Colon> P | B] \<Rrightarrow>\<^sub>m Q" \<rightleftharpoons> "CONST dep_mono_wrt_pred P (\<lambda>x. CONST pred_if B Q)"
 
 lemma dep_mono_wrt_relI [intro]:
   assumes "\<And>x y. R x y \<Longrightarrow> S x y (f x) (f y)"
   shows "([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   using assms unfolding dep_mono_wrt_rel_def by blast
 
 lemma dep_mono_wrt_relE [elim]:
   assumes "([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
-  and "R x y"
-  obtains "S x y (f x) (f y)"
+  obtains "\<And>x y. R x y \<Longrightarrow> S x y (f x) (f y)"
   using assms unfolding dep_mono_wrt_rel_def by blast
 
 lemma dep_mono_wrt_relD:
   assumes "([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   and "R x y"
   shows "S x y (f x) (f y)"
   using assms by blast
 
 lemma dep_mono_wrt_predI [intro]:
   assumes "\<And>x. P x \<Longrightarrow> Q x (f x)"
   shows "([x \<Colon> P] \<Rrightarrow>\<^sub>m Q x) f"
   using assms unfolding dep_mono_wrt_pred_def by blast
 
 lemma dep_mono_wrt_predE [elim]:
   assumes "([x \<Colon> P] \<Rrightarrow>\<^sub>m Q x) f"
-  and "P x"
-  obtains "Q x (f x)"
+  obtains "\<And>x. P x \<Longrightarrow> Q x (f x)"
   using assms unfolding dep_mono_wrt_pred_def by blast
 
 lemma dep_mono_wrt_predD:
   assumes "([x \<Colon> P] \<Rrightarrow>\<^sub>m Q x) f"
   and "P x"
   shows "Q x (f x)"
   using assms by blast
 
 lemma dep_mono_wrt_rel_if_Dep_Fun_Rel_rel_self:
   assumes "([x y \<Colon> R] \<Rrightarrow> S x y) f f"
   shows "([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   using assms by blast
 
 lemma dep_mono_wrt_pred_if_Dep_Fun_Rel_pred_self:
   assumes "([x \<Colon> P] \<Rrightarrow> (\<lambda>_. Q x)) f f"
   shows "([x \<Colon> P] \<Rrightarrow>\<^sub>m Q x) f"
   using assms by blast
 
 lemma Dep_Fun_Rel_rel_self_if_dep_mono_wrt_rel:
   assumes "([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   shows "([x y \<Colon> R] \<Rrightarrow> S x y) f f"
   using assms by blast
 
 lemma Dep_Fun_Rel_pred_self_if_dep_mono_wrt_pred:
   assumes "([x \<Colon> P] \<Rrightarrow>\<^sub>m Q x) f"
   shows "([x \<Colon> P] \<Rrightarrow> (\<lambda>_. Q x)) f f"
   using assms by blast
 
 corollary Dep_Fun_Rel_rel_self_iff_dep_mono_wrt_rel:
   "([x y \<Colon> R] \<Rrightarrow> S x y) f f \<longleftrightarrow> ([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   using dep_mono_wrt_rel_if_Dep_Fun_Rel_rel_self
     Dep_Fun_Rel_rel_self_if_dep_mono_wrt_rel by blast
 
 corollary Dep_Fun_Rel_pred_self_iff_dep_mono_wrt_pred:
   "([x \<Colon> P] \<Rrightarrow> (\<lambda>_. Q x)) f f \<longleftrightarrow> ([x \<Colon> P] \<Rrightarrow>\<^sub>m Q x) f"
   using dep_mono_wrt_pred_if_Dep_Fun_Rel_pred_self
     Dep_Fun_Rel_pred_self_if_dep_mono_wrt_pred by blast
 
 lemma dep_mono_wrt_rel_inv_eq [simp]:
   "([y x \<Colon> R\<inverse>] \<Rrightarrow>\<^sub>m (S x y)\<inverse>) = ([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y)"
-  by (intro ext) auto
+  by (intro ext) force
 
 lemma in_dom_if_rel_if_dep_mono_wrt_rel:
   assumes "([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   and "R x y"
   shows "in_dom (S x y) (f x)"
   using assms by (intro in_domI) blast
 
 corollary in_dom_if_in_dom_if_mono_wrt_rel:
   assumes "(R \<Rrightarrow>\<^sub>m S) f"
   shows "([in_dom R] \<Rrightarrow>\<^sub>m in_dom S) f"
   using assms in_dom_if_rel_if_dep_mono_wrt_rel by fast
 
 lemma in_codom_if_rel_if_dep_mono_wrt_rel:
   assumes "([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   and "R x y"
   shows "in_codom (S x y) (f y)"
   using assms by (intro in_codomI) blast
 
 corollary in_codom_if_in_codom_if_mono_wrt_rel:
   assumes "(R \<Rrightarrow>\<^sub>m S) f"
   shows "([in_codom R] \<Rrightarrow>\<^sub>m in_codom S) f"
   using assms in_dom_if_rel_if_dep_mono_wrt_rel by fast
 
 corollary in_field_if_in_field_if_mono_wrt_rel:
   assumes "(R \<Rrightarrow>\<^sub>m S) f"
   shows "([in_field R] \<Rrightarrow>\<^sub>m in_field S) f"
   using assms by (intro dep_mono_wrt_predI) blast
 
 lemma le_rel_map_if_mono_wrt_rel:
   assumes "(R \<Rrightarrow>\<^sub>m S) f"
   shows "R \<le> rel_map f S"
   using assms by (intro le_relI) auto
 
 lemma le_pred_map_if_mono_wrt_pred:
   assumes "([P] \<Rrightarrow>\<^sub>m Q) f"
   shows "P \<le> pred_map f Q"
   using assms by (intro le_predI) auto
 
 lemma mono_wrt_rel_if_le_rel_map:
   assumes "R \<le> rel_map f S"
   shows "(R \<Rrightarrow>\<^sub>m S) f"
   using assms by (intro dep_mono_wrt_relI) auto
 
 lemma mono_wrt_pred_if_le_pred_map:
   assumes "P \<le> pred_map f Q"
   shows "([P] \<Rrightarrow>\<^sub>m Q) f"
   using assms by (intro dep_mono_wrt_predI) auto
 
 corollary mono_wrt_rel_iff_le_rel_map: "(R \<Rrightarrow>\<^sub>m S) f \<longleftrightarrow> R \<le> rel_map f S"
   using mono_wrt_rel_if_le_rel_map le_rel_map_if_mono_wrt_rel by auto
 
 corollary mono_wrt_pred_iff_le_pred_map: "([P] \<Rrightarrow>\<^sub>m Q) f \<longleftrightarrow> P \<le> pred_map f Q"
   using mono_wrt_pred_if_le_pred_map le_pred_map_if_mono_wrt_pred by auto
 
 definition "mono \<equiv> ((\<le>) \<Rrightarrow>\<^sub>m (\<le>))"
 
 definition "antimono \<equiv> ((\<le>) \<Rrightarrow>\<^sub>m (\<ge>))"
 
 lemma monoI [intro]:
   assumes "\<And>x y. x \<le> y \<Longrightarrow> f x \<le> f y"
   shows "mono f"
   unfolding mono_def using assms by blast
 
 lemma monoE [elim]:
   assumes "mono f"
-  and "x \<le> y"
-  obtains "f x \<le> f y"
+  obtains "\<And>x y. x \<le> y \<Longrightarrow> f x \<le> f y"
   using assms unfolding mono_def by blast
 
 lemma monoD:
   assumes "mono f"
   and "x \<le> y"
   shows "f x \<le> f y"
   using assms by blast
 
 lemma antimonoI [intro]:
   assumes "\<And>x y. x \<le> y \<Longrightarrow> f y \<le> f x"
   shows "antimono f"
   unfolding antimono_def using assms by blast
 
 lemma antimonoE [elim]:
   assumes "antimono f"
-  and "x \<le> y"
-  obtains "f y \<le> f x"
+  obtains "\<And>x y. x \<le> y \<Longrightarrow> f y \<le> f x"
   using assms unfolding antimono_def by blast
 
 lemma antimonoD:
   assumes "antimono f"
   and "x \<le> y"
   shows "f y \<le> f x"
   using assms by blast
 
 lemma antimono_Dep_Fun_Rel_rel_left: "antimono (\<lambda>R. [x y \<Colon> R] \<Rrightarrow> S x y)"
   by (intro antimonoI) auto
 
 lemma antimono_Dep_Fun_Rel_pred_left: "antimono (\<lambda>P. [x \<Colon> P] \<Rrightarrow> Q x)"
   by (intro antimonoI) auto
 
 lemma antimono_dep_mono_wrt_rel_left: "antimono (\<lambda>R. [x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y)"
-  by (intro antimonoI) auto
+  by (intro antimonoI) blast
 
 lemma antimono_dep_mono_wrt_pred_left: "antimono (\<lambda>P. [x \<Colon> P] \<Rrightarrow>\<^sub>m Q x)"
-  by (intro antimonoI) auto
+  by (intro antimonoI) blast
 
 lemma Dep_Fun_Rel_rel_if_le_left_if_Dep_Fun_Rel_rel:
   assumes "([x y \<Colon> R] \<Rrightarrow> S x y) f g"
   and "T \<le> R"
   shows "([x y \<Colon> T] \<Rrightarrow> S x y) f g"
   using assms by blast
 
 lemma Dep_Fun_Rel_pred_if_le_left_if_Dep_Fun_Rel_pred:
   assumes "([x \<Colon> P] \<Rrightarrow> Q x) f g"
   and "T \<le> P"
   shows "([x \<Colon> T] \<Rrightarrow> Q x) f g"
   using assms by blast
 
 lemma dep_mono_wrt_rel_if_le_left_if_dep_mono_wrt_rel:
   assumes "([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   and "T \<le> R"
   shows "([x y \<Colon> T] \<Rrightarrow>\<^sub>m S x y) f"
   using assms by blast
 
 lemma dep_mono_wrt_pred_if_le_left_if_dep_mono_wrt_pred:
   assumes "([x \<Colon> P] \<Rrightarrow>\<^sub>m Q x) f"
   and "T \<le> P"
   shows "([x \<Colon> T] \<Rrightarrow>\<^sub>m Q x) f"
   using assms by blast
 
 lemma mono_Dep_Fun_Rel_rel_right: "mono (\<lambda>S. [x y \<Colon> R] \<Rrightarrow> S x y)"
   by (intro monoI) blast
 
 lemma mono_Dep_Fun_Rel_pred_right: "mono (\<lambda>Q. [x \<Colon> P] \<Rrightarrow> Q x)"
   by (intro monoI) blast
 
 lemma mono_dep_mono_wrt_rel_right: "mono (\<lambda>S. [x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y)"
   by (intro monoI) blast
 
 lemma mono_dep_mono_wrt_pred_right: "mono (\<lambda>Q. [x \<Colon> P] \<Rrightarrow>\<^sub>m Q x)"
   by (intro monoI) blast
 
 lemma Dep_Fun_Rel_rel_if_le_right_if_Dep_Fun_Rel_rel:
   assumes "([x y \<Colon> R] \<Rrightarrow> S x y) f g"
   and "\<And>x y. R x y \<Longrightarrow> S x y (f x) (g y) \<Longrightarrow> T x y (f x) (g y)"
   shows "([x y \<Colon> R] \<Rrightarrow> T x y) f g"
   using assms by (intro Dep_Fun_Rel_relI) blast
 
 lemma Dep_Fun_Rel_pred_if_le_right_if_Dep_Fun_Rel_pred:
   assumes "([x \<Colon> P] \<Rrightarrow> Q x) f g"
   and "\<And>x. P x \<Longrightarrow> Q x (f x) (g x) \<Longrightarrow> T x (f x) (g x)"
   shows "([x \<Colon> P] \<Rrightarrow> T x) f g"
   using assms by blast
 
 lemma dep_mono_wrt_rel_if_le_right_if_dep_mono_wrt_rel:
   assumes "([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   and "\<And>x y. R x y \<Longrightarrow> S x y (f x) (f y) \<Longrightarrow> T x y (f x) (f y)"
   shows "([x y \<Colon> R] \<Rrightarrow>\<^sub>m T x y) f"
   using assms by (intro dep_mono_wrt_relI) blast
 
 lemma dep_mono_wrt_pred_if_le_right_if_dep_mono_wrt_pred:
   assumes "([x \<Colon> P] \<Rrightarrow>\<^sub>m Q x) f"
   and "\<And>x. P x \<Longrightarrow> Q x (f x) \<Longrightarrow> T x (f x)"
   shows "([x \<Colon> P] \<Rrightarrow>\<^sub>m T x) f"
   using assms by blast
 
 
 paragraph \<open>Composition\<close>
 
 lemma dep_mono_wrt_rel_compI:
   assumes "([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   and "\<And>x y. R x y \<Longrightarrow> ([x' y' \<Colon> T x y] \<Rrightarrow>\<^sub>m U x y x' y') f'"
   and "\<And>x y. R x y \<Longrightarrow> S x y (f x) (f y) \<Longrightarrow> T x y (f x) (f y)"
   shows "([x y \<Colon> R] \<Rrightarrow>\<^sub>m U x y (f x) (f y)) (f' \<circ> f)"
-  using assms by (intro dep_mono_wrt_relI) (auto 6 0)
+  using assms by (intro dep_mono_wrt_relI) force
 
 corollary dep_mono_wrt_rel_compI':
   assumes "([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   and "\<And>x y. R x y \<Longrightarrow> ([x' y' \<Colon> S x y] \<Rrightarrow>\<^sub>m T x y x' y') f'"
   shows "([x y \<Colon> R] \<Rrightarrow>\<^sub>m T x y (f x) (f y)) (f' \<circ> f)"
   using assms by (intro dep_mono_wrt_rel_compI)
 
 lemma dep_mono_wrt_pred_comp_dep_mono_wrt_rel_compI:
   assumes "([x \<Colon> P] \<Rrightarrow>\<^sub>m Q x) f"
   and "\<And>x. P x \<Longrightarrow> ([x' y' \<Colon> R x] \<Rrightarrow>\<^sub>m S x x' y') f'"
   and "\<And>x. P x \<Longrightarrow> Q x (f x) \<Longrightarrow> R x (f x) (f x)"
   shows "([x \<Colon> P] \<Rrightarrow>\<^sub>m (\<lambda>y. S x (f x) (f x) y y)) (f' \<circ> f)"
-  using assms by (intro dep_mono_wrt_predI) (auto 6 0)
+  using assms by (intro dep_mono_wrt_predI) force
 
 lemma dep_mono_wrt_pred_comp_dep_mono_wrt_pred_compI:
   assumes "([x \<Colon> P] \<Rrightarrow>\<^sub>m Q x) f"
   and "\<And>x. P x \<Longrightarrow> ([x' \<Colon> R x] \<Rrightarrow>\<^sub>m S x x') f'"
   and "\<And>x. P x \<Longrightarrow> Q x (f x) \<Longrightarrow> R x (f x)"
   shows "([x \<Colon> P] \<Rrightarrow>\<^sub>m S x (f x)) (f' \<circ> f)"
-  using assms by (intro dep_mono_wrt_predI) (auto 6 0)
+  using assms by (intro dep_mono_wrt_predI) force
 
 corollary dep_mono_wrt_pred_comp_dep_mono_wrt_pred_compI':
   assumes "([x \<Colon> P] \<Rrightarrow>\<^sub>m Q x) f"
   and "\<And>x. P x \<Longrightarrow> ([x' \<Colon> Q x] \<Rrightarrow>\<^sub>m S x x') f'"
   shows "([x \<Colon> P] \<Rrightarrow>\<^sub>m S x (f x)) (f' \<circ> f)"
   using assms by (intro dep_mono_wrt_pred_comp_dep_mono_wrt_pred_compI)
 
 
 paragraph \<open>Instantiations\<close>
 
 lemma mono_wrt_rel_self_id: "(R \<Rrightarrow>\<^sub>m R) id" by auto
 lemma mono_wrt_pred_self_id: "([P] \<Rrightarrow>\<^sub>m P) id" by auto
 
 lemma mono_in_dom: "mono in_dom" by (intro monoI) fast
 lemma mono_in_codom: "mono in_codom" by (intro monoI) fast
 lemma mono_in_field: "mono in_field" by (intro monoI) fast
 lemma mono_rel_comp1: "mono (\<circ>\<circ>)" by (intro monoI) fast
 lemma mono_rel_comp2: "mono ((\<circ>\<circ>) x)" by (intro monoI) fast
 
 
 end
diff --git a/thys/Transport/HOL_Basics/Functions/Properties/Functions_Surjective.thy b/thys/Transport/HOL_Basics/Functions/Properties/Functions_Surjective.thy
--- a/thys/Transport/HOL_Basics/Functions/Properties/Functions_Surjective.thy
+++ b/thys/Transport/HOL_Basics/Functions/Properties/Functions_Surjective.thy
@@ -1,50 +1,49 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Surjective\<close>
 theory Functions_Surjective
   imports
     HOL_Syntax_Bundles_Lattices
 begin
 
 consts surjective_at :: "'a \<Rightarrow> ('b \<Rightarrow> 'c) \<Rightarrow> bool"
 
 overloading
   surjective_at_pred \<equiv> "surjective_at :: ('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'a) \<Rightarrow> bool"
 begin
   definition "surjective_at_pred P f \<equiv> \<forall>y. P y \<longrightarrow> (\<exists>x. y = f x)"
 end
 
 lemma surjective_atI [intro]:
   assumes "\<And>y. P y \<Longrightarrow> \<exists>x. y = f x"
   shows "surjective_at P f"
   unfolding surjective_at_pred_def using assms by blast
 
 lemma surjective_atE [elim]:
   assumes "surjective_at P f"
   and "P y"
   obtains x where "y = f x"
   using assms unfolding surjective_at_pred_def by blast
 
-definition "surjective (f :: _ \<Rightarrow> 'a) \<equiv> surjective_at (\<top> :: 'a \<Rightarrow> bool) f"
+definition "(surjective :: (_ \<Rightarrow> 'a) \<Rightarrow> _) \<equiv> surjective_at (\<top> :: 'a \<Rightarrow> bool)"
 
-lemma surjective_eq_surjective_at:
-  "surjective (f :: _ \<Rightarrow> 'a) = surjective_at (\<top> :: 'a \<Rightarrow> bool) f"
+lemma surjective_eq_surjective_at: "(surjective :: (_ \<Rightarrow> 'a) \<Rightarrow> _) = surjective_at (\<top> :: 'a \<Rightarrow> bool)"
   unfolding surjective_def ..
 
 lemma surjectiveI [intro]:
   assumes "\<And>y. \<exists>x. y = f x"
   shows "surjective f"
   unfolding surjective_eq_surjective_at using assms by (intro surjective_atI)
 
 lemma surjectiveE:
   assumes "surjective f"
   obtains x where "y = f x"
   using assms unfolding surjective_eq_surjective_at by (blast intro: top1I)
 
 lemma surjective_at_if_surjective:
   fixes P :: "'a \<Rightarrow> bool" and f :: "_ \<Rightarrow> 'a"
   assumes "surjective f"
   shows "surjective_at P f"
   using assms by (intro surjective_atI) (blast elim: surjectiveE)
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Galois/Galois_Relator.thy b/thys/Transport/HOL_Basics/Galois/Galois_Relator.thy
--- a/thys/Transport/HOL_Basics/Galois/Galois_Relator.thy
+++ b/thys/Transport/HOL_Basics/Galois/Galois_Relator.thy
@@ -1,180 +1,180 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Relator For Galois Connections\<close>
 theory Galois_Relator
   imports
     Galois_Relator_Base
     Galois_Property
 begin
 
 context galois_prop
 begin
 
 interpretation flip_inv : galois_rel "(\<ge>\<^bsub>R\<^esub>)" "(\<ge>\<^bsub>L\<^esub>)" l .
 
 lemma left_Galois_if_Galois_right_if_half_galois_prop_right:
   assumes "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   and "x \<lessapprox>\<^bsub>R\<^esub> y"
   shows "x \<^bsub>L\<^esub>\<lessapprox> y"
   using assms by (intro left_GaloisI) auto
 
 lemma Galois_right_if_left_Galois_if_half_galois_prop_left:
   assumes "((\<le>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   and "x \<^bsub>L\<^esub>\<lessapprox> y"
   shows "x \<lessapprox>\<^bsub>R\<^esub> y"
   using assms by blast
 
 corollary Galois_right_iff_left_Galois_if_galois_prop [iff]:
   assumes "((\<le>\<^bsub>L\<^esub>) \<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   shows "x \<lessapprox>\<^bsub>R\<^esub> y \<longleftrightarrow> x \<^bsub>L\<^esub>\<lessapprox> y"
   using assms
     left_Galois_if_Galois_right_if_half_galois_prop_right
     Galois_right_if_left_Galois_if_half_galois_prop_left
   by blast
 
 lemma rel_inv_Galois_eq_flip_Galois_rel_inv_if_galois_prop [simp]:
   assumes "((\<le>\<^bsub>L\<^esub>) \<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   shows "(\<greaterapprox>\<^bsub>L\<^esub>) = (\<^bsub>R\<^esub>\<greaterapprox>)"
   using assms by blast
 
 corollary flip_Galois_rel_inv_iff_Galois_if_galois_prop [iff]:
   assumes "((\<le>\<^bsub>L\<^esub>) \<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   shows "y \<^bsub>R\<^esub>\<greaterapprox> x \<longleftrightarrow> x \<^bsub>L\<^esub>\<lessapprox> y"
   using assms by blast
 
 corollary inv_flip_Galois_rel_inv_eq_Galois_if_galois_prop [simp]:
   assumes "((\<le>\<^bsub>L\<^esub>) \<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   shows "(\<lessapprox>\<^bsub>R\<^esub>) = (\<^bsub>L\<^esub>\<lessapprox>)" \<comment>\<open>Note that @{term "(\<lessapprox>\<^bsub>R\<^esub>) = (galois_rel.Galois (\<ge>\<^bsub>R\<^esub>) (\<ge>\<^bsub>L\<^esub>) l)\<inverse>"}\<close>
   using assms by (subst rel_inv_eq_iff_eq[symmetric]) simp
 
 end
 
 context galois
 begin
 
 interpretation flip_inv : galois "(\<ge>\<^bsub>R\<^esub>)" "(\<ge>\<^bsub>L\<^esub>)" r l .
 
 context
 begin
 
 interpretation flip : galois R L r l .
 
 lemma left_Galois_left_if_left_relI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   and "x \<le>\<^bsub>L\<^esub> x'"
   shows "x \<^bsub>L\<^esub>\<lessapprox> l x'"
   using assms
-  by (intro left_Galois_if_Galois_right_if_half_galois_prop_right) auto
+  by (intro left_Galois_if_Galois_right_if_half_galois_prop_right) (auto 5 0)
 
 corollary left_Galois_left_if_reflexive_on_if_half_galois_prop_rightI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   and "reflexive_on P (\<le>\<^bsub>L\<^esub>)"
   and "P x"
   shows "x \<^bsub>L\<^esub>\<lessapprox> l x"
   using assms by (intro left_Galois_left_if_left_relI) auto
 
 lemma left_Galois_left_if_in_codom_if_inflationary_onI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "inflationary_on P (\<le>\<^bsub>L\<^esub>) \<eta>"
   and "in_codom (\<le>\<^bsub>L\<^esub>) x"
   and "P x"
   shows "x \<^bsub>L\<^esub>\<lessapprox> l x"
   using assms by (intro left_GaloisI) (auto elim!: in_codomE)
 
 lemma left_Galois_left_if_in_codom_if_inflationary_on_in_codomI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "inflationary_on (in_codom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   and "in_codom (\<le>\<^bsub>L\<^esub>) x"
   shows "x \<^bsub>L\<^esub>\<lessapprox> l x"
   using assms by (auto intro!: left_Galois_left_if_in_codom_if_inflationary_onI)
 
 lemma left_Galois_left_if_left_rel_if_inflationary_on_in_fieldI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "inflationary_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   and "x \<le>\<^bsub>L\<^esub> x"
   shows "x \<^bsub>L\<^esub>\<lessapprox> l x"
   using assms by (auto intro!: left_Galois_left_if_in_codom_if_inflationary_onI)
 
 lemma right_left_Galois_if_right_relI:
   assumes "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "y \<le>\<^bsub>R\<^esub> y'"
   shows "r y \<^bsub>L\<^esub>\<lessapprox> y'"
   using assms by (intro left_GaloisI) auto
 
 corollary right_left_Galois_if_reflexive_onI:
   assumes "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "reflexive_on P (\<le>\<^bsub>R\<^esub>)"
   and "P y"
   shows "r y \<^bsub>L\<^esub>\<lessapprox> y"
   using assms by (intro right_left_Galois_if_right_relI) auto
 
 lemma left_Galois_if_right_rel_if_left_GaloisI:
   assumes "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "transitive (\<le>\<^bsub>L\<^esub>)"
   and "x \<^bsub>L\<^esub>\<lessapprox> y"
   and "y \<le>\<^bsub>R\<^esub> z"
   shows "x \<^bsub>L\<^esub>\<lessapprox> z"
-  using assms by (intro left_GaloisI) auto
+  using assms by (intro left_GaloisI) (auto 5 0)
 
 lemma left_Galois_if_left_Galois_if_left_relI:
   assumes "transitive (\<le>\<^bsub>L\<^esub>)"
   and "x \<le>\<^bsub>L\<^esub> y"
   and "y \<^bsub>L\<^esub>\<lessapprox> z"
   shows "x \<^bsub>L\<^esub>\<lessapprox> z"
   using assms by (intro left_GaloisI) auto
 
 lemma left_rel_if_right_Galois_if_left_GaloisI:
   assumes "((\<le>\<^bsub>R\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L\<^esub>)) r l"
   and "transitive (\<le>\<^bsub>L\<^esub>)"
   and "x \<^bsub>L\<^esub>\<lessapprox> y"
   and "y \<^bsub>R\<^esub>\<lessapprox> z"
   shows "x \<le>\<^bsub>L\<^esub> z"
   using assms by auto
 
 lemma Dep_Fun_Rel_left_Galois_right_Galois_if_mono_wrt_rel [intro]:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   shows "((\<^bsub>L\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>R\<^esub>\<lessapprox>)) l r"
-  using assms by auto
+  using assms by blast
 
 lemma left_ge_Galois_eq_left_Galois_if_in_codom_eq_in_dom_if_symmetric:
   assumes "symmetric (\<le>\<^bsub>L\<^esub>)"
   and "in_codom (\<le>\<^bsub>R\<^esub>) = in_dom (\<le>\<^bsub>R\<^esub>)"
   shows "(\<^bsub>L\<^esub>\<greaterapprox>) = (\<^bsub>L\<^esub>\<lessapprox>)" \<comment>\<open>Note that @{term "(\<^bsub>L\<^esub>\<greaterapprox>) = galois_rel.Galois (\<ge>\<^bsub>L\<^esub>) (\<ge>\<^bsub>R\<^esub>) r"}\<close>
   using assms by (intro ext iffI)
   (auto elim!: galois_rel.left_GaloisE intro!: galois_rel.left_GaloisI)
 
 end
 
 interpretation flip : galois R L r l .
 
 lemma ge_Galois_right_eq_left_Galois_if_symmetric_if_in_codom_eq_in_dom_if_galois_prop:
   assumes "((\<le>\<^bsub>L\<^esub>) \<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   and "in_codom (\<le>\<^bsub>L\<^esub>) = in_dom (\<le>\<^bsub>L\<^esub>)"
   and "symmetric (\<le>\<^bsub>R\<^esub>)"
   shows "(\<greaterapprox>\<^bsub>R\<^esub>) = (\<^bsub>L\<^esub>\<lessapprox>)" \<comment>\<open>Note that @{term "(\<greaterapprox>\<^bsub>R\<^esub>) = (galois_rel.Galois (\<le>\<^bsub>R\<^esub>) (\<le>\<^bsub>L\<^esub>) l)\<inverse>"}\<close>
   using assms
   by (simp only: inv_flip_Galois_rel_inv_eq_Galois_if_galois_prop
     flip: flip.left_ge_Galois_eq_left_Galois_if_in_codom_eq_in_dom_if_symmetric)
 
 interpretation gp : galois_prop "(\<^bsub>L\<^esub>\<lessapprox>)" "(\<^bsub>R\<^esub>\<lessapprox>)" l l .
 
 lemma half_galois_prop_left_left_Galois_right_Galois_if_half_galois_prop_leftI [intro]:
   assumes "((\<le>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   shows "((\<^bsub>L\<^esub>\<lessapprox>) \<^sub>h\<unlhd> (\<^bsub>R\<^esub>\<lessapprox>)) l l"
   using assms by fast
 
 lemma half_galois_prop_right_left_Galois_right_Galois_if_half_galois_prop_rightI [intro]:
   assumes "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   shows "((\<^bsub>L\<^esub>\<lessapprox>) \<unlhd>\<^sub>h (\<^bsub>R\<^esub>\<lessapprox>)) l l"
   using assms by fast
 
 corollary galois_prop_left_Galois_right_Galois_if_galois_prop [intro]:
   assumes "((\<le>\<^bsub>L\<^esub>) \<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   shows "((\<^bsub>L\<^esub>\<lessapprox>) \<unlhd> (\<^bsub>R\<^esub>\<lessapprox>)) l l"
   using assms by blast
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Galois/Galois_Relator_Base.thy b/thys/Transport/HOL_Basics/Galois/Galois_Relator_Base.thy
--- a/thys/Transport/HOL_Basics/Galois/Galois_Relator_Base.thy
+++ b/thys/Transport/HOL_Basics/Galois/Galois_Relator_Base.thy
@@ -1,62 +1,62 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Basics For Relator For Galois Connections\<close>
 theory Galois_Relator_Base
   imports
     Galois_Base
 begin
 
 locale galois_rel = orders L R
   for L :: "'a \<Rightarrow> 'b \<Rightarrow> bool"
   and R :: "'c \<Rightarrow> 'd \<Rightarrow> bool"
   and r :: "'d \<Rightarrow> 'b"
 begin
 
 text \<open>Morally speaking, the Galois relator characterises when two terms
 \<^term>\<open>x :: 'a\<close> and \<^term>\<open>y :: 'b\<close> are "similar".\<close>
 
 definition "Galois x y \<equiv> in_codom (\<le>\<^bsub>R\<^esub>) y \<and> x \<le>\<^bsub>L\<^esub> r y"
 
 abbreviation "left_Galois \<equiv> Galois"
 notation left_Galois (infix "\<^bsub>L\<^esub>\<lessapprox>" 50)
 
 abbreviation (input) "ge_Galois_left \<equiv> (\<^bsub>L\<^esub>\<lessapprox>)\<inverse>"
 notation ge_Galois_left (infix "\<greaterapprox>\<^bsub>L\<^esub>" 50)
 
 text \<open>Here we only introduced the (left) Galois relator @{term "(\<^bsub>L\<^esub>\<lessapprox>)"}.
 All other variants can be introduced by considering suitable flipped and inversed
 interpretations (see @{file "Half_Galois_Property.thy"}).\<close>
 
 lemma left_GaloisI [intro]:
   assumes "in_codom (\<le>\<^bsub>R\<^esub>) y"
   and "x \<le>\<^bsub>L\<^esub> r y"
   shows "x \<^bsub>L\<^esub>\<lessapprox> y"
   unfolding Galois_def using assms by blast
 
 lemma left_GaloisE [elim]:
   assumes "x \<^bsub>L\<^esub>\<lessapprox> y"
   obtains "in_codom (\<le>\<^bsub>R\<^esub>) y" "x \<le>\<^bsub>L\<^esub> r y"
   using assms unfolding Galois_def by blast
 
 corollary in_dom_left_if_left_Galois:
   assumes "x \<^bsub>L\<^esub>\<lessapprox> y"
   shows "in_dom (\<le>\<^bsub>L\<^esub>) x"
   using assms by blast
 
 corollary left_Galois_iff_in_codom_and_left_rel_right:
   "x \<^bsub>L\<^esub>\<lessapprox> y \<longleftrightarrow> in_codom (\<le>\<^bsub>R\<^esub>) y \<and> x \<le>\<^bsub>L\<^esub> r y"
   by blast
 
 lemma left_Galois_restrict_left_eq_left_Galois_left_restrict_left:
   "(\<^bsub>L\<^esub>\<lessapprox>)\<restriction>\<^bsub>P :: 'a \<Rightarrow> bool\<^esub> = galois_rel.Galois (\<le>\<^bsub>L\<^esub>)\<restriction>\<^bsub>P\<^esub> (\<le>\<^bsub>R\<^esub>) r"
-  by (intro ext iffI galois_rel.left_GaloisI restrict_leftI)
+  by (intro ext iffI galois_rel.left_GaloisI bin_rel_restrict_leftI)
   (auto elim: galois_rel.left_GaloisE)
 
 lemma left_Galois_restrict_right_eq_left_Galois_right_restrict_right:
   "(\<^bsub>L\<^esub>\<lessapprox>)\<upharpoonleft>\<^bsub>P :: 'd \<Rightarrow> bool\<^esub> = galois_rel.Galois (\<le>\<^bsub>L\<^esub>) (\<le>\<^bsub>R\<^esub>)\<upharpoonleft>\<^bsub>P\<^esub> r"
-  by (intro ext iffI galois_rel.left_GaloisI restrict_rightI)
-  (auto elim!: galois_rel.left_GaloisE restrict_rightE)
+  by (intro ext iffI galois_rel.left_GaloisI bin_rel_restrict_rightI)
+  (auto elim!: galois_rel.left_GaloisE bin_rel_restrict_rightE)
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Galois/Half_Galois_Property.thy b/thys/Transport/HOL_Basics/Galois/Half_Galois_Property.thy
--- a/thys/Transport/HOL_Basics/Galois/Half_Galois_Property.thy
+++ b/thys/Transport/HOL_Basics/Galois/Half_Galois_Property.thy
@@ -1,283 +1,283 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Half Galois Property\<close>
 theory Half_Galois_Property
   imports
     Galois_Relator_Base
     Order_Equivalences
 begin
 
 text \<open>As the definition of the Galois property also works on heterogeneous relations,
 we define the concepts in a locale that generalises @{locale galois}.\<close>
 
 locale galois_prop = orders L R
   for L :: "'a \<Rightarrow> 'b \<Rightarrow> bool"
   and R :: "'c \<Rightarrow> 'd \<Rightarrow> bool"
   and l :: "'a \<Rightarrow> 'c"
   and r :: "'d \<Rightarrow> 'b"
 begin
 
 sublocale galois_rel L R r .
 
 interpretation gr_flip_inv : galois_rel "(\<ge>\<^bsub>R\<^esub>)" "(\<ge>\<^bsub>L\<^esub>)" l .
 
 abbreviation "right_ge_Galois \<equiv> gr_flip_inv.Galois"
 notation right_ge_Galois (infix "\<^bsub>R\<^esub>\<greaterapprox>" 50)
 
 abbreviation (input) "Galois_right \<equiv> gr_flip_inv.ge_Galois_left"
 notation Galois_right (infix "\<lessapprox>\<^bsub>R\<^esub>" 50)
 
 lemma Galois_rightI [intro]:
   assumes "in_dom (\<le>\<^bsub>L\<^esub>) x"
   and "l x \<le>\<^bsub>R\<^esub> y"
   shows "x \<lessapprox>\<^bsub>R\<^esub> y"
   using assms by blast
 
 lemma Galois_rightE [elim]:
   assumes "x \<lessapprox>\<^bsub>R\<^esub> y"
   obtains "in_dom (\<le>\<^bsub>L\<^esub>) x" "l x \<le>\<^bsub>R\<^esub> y"
   using assms by blast
 
 corollary Galois_right_iff_in_dom_and_left_right_rel:
   "x \<lessapprox>\<^bsub>R\<^esub> y \<longleftrightarrow> in_dom (\<le>\<^bsub>L\<^esub>) x \<and> l x \<le>\<^bsub>R\<^esub> y"
   by blast
 
 text \<open>Unlike common literature, we split the definition of the Galois property
 into two halves. This has its merits in modularity of proofs and preciser
 statement of required assumptions.\<close>
 
 definition "half_galois_prop_left \<equiv> \<forall>x y. x \<^bsub>L\<^esub>\<lessapprox> y \<longrightarrow> l x \<le>\<^bsub>R\<^esub> y"
 
 notation galois_prop.half_galois_prop_left (infix "\<^sub>h\<unlhd>" 50)
 
 lemma half_galois_prop_leftI [intro]:
   assumes "\<And>x y. x \<^bsub>L\<^esub>\<lessapprox> y \<Longrightarrow> l x \<le>\<^bsub>R\<^esub> y"
   shows "((\<le>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   unfolding half_galois_prop_left_def using assms by blast
 
 lemma half_galois_prop_leftD [dest]:
   assumes "((\<le>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   and " x \<^bsub>L\<^esub>\<lessapprox> y"
   shows "l x \<le>\<^bsub>R\<^esub> y"
   using assms unfolding half_galois_prop_left_def by blast
 
 text\<open>Observe that the second half can be obtained by creating an appropriately
 flipped and inverted interpretation of @{locale galois_prop}. Indeed, many
 concepts in our formalisation are "closed" under inversion,
 i.e. taking their inversion yields a statement for a related concept.
 Many theorems can thus be derived for free by inverting (and flipping) the
 concepts at hand. In such cases, we only state those theorems that require some
 non-trivial setup. All other theorems can simply be obtained by creating a
 suitable locale interpretation.\<close>
 
 interpretation flip_inv : galois_prop "(\<ge>\<^bsub>R\<^esub>)" "(\<ge>\<^bsub>L\<^esub>)" r l .
 
 definition "half_galois_prop_right \<equiv> flip_inv.half_galois_prop_left"
 
 notation galois_prop.half_galois_prop_right (infix "\<unlhd>\<^sub>h" 50)
 
 lemma half_galois_prop_rightI [intro]:
   assumes "\<And>x y. x \<lessapprox>\<^bsub>R\<^esub> y \<Longrightarrow> x \<le>\<^bsub>L\<^esub> r y"
   shows "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   unfolding half_galois_prop_right_def using assms by blast
 
 lemma half_galois_prop_rightD [dest]:
   assumes "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   and "x \<lessapprox>\<^bsub>R\<^esub> y"
   shows "x \<le>\<^bsub>L\<^esub> r y"
   using assms unfolding half_galois_prop_right_def by blast
 
 interpretation g : galois_prop S T f g for S T f g .
 
 lemma rel_inv_half_galois_prop_right_eq_half_galois_prop_left_rel_inv [simp]:
   "((\<le>\<^bsub>R\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>L\<^esub>))\<inverse> = ((\<ge>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<ge>\<^bsub>R\<^esub>))"
   by (intro ext) blast
 
 corollary half_galois_prop_left_rel_inv_iff_half_galois_prop_right [iff]:
   "((\<ge>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<ge>\<^bsub>R\<^esub>)) f g \<longleftrightarrow> ((\<le>\<^bsub>R\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>L\<^esub>)) g f"
   by (simp flip: rel_inv_half_galois_prop_right_eq_half_galois_prop_left_rel_inv)
 
 lemma rel_inv_half_galois_prop_left_eq_half_galois_prop_right_rel_inv [simp]:
   "((\<le>\<^bsub>R\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L\<^esub>))\<inverse> = ((\<ge>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<ge>\<^bsub>R\<^esub>))"
   by (intro ext) blast
 
 corollary half_galois_prop_right_rel_inv_iff_half_galois_prop_left [iff]:
   "((\<ge>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<ge>\<^bsub>R\<^esub>)) f g \<longleftrightarrow> ((\<le>\<^bsub>R\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L\<^esub>)) g f"
   by (simp flip: rel_inv_half_galois_prop_left_eq_half_galois_prop_right_rel_inv)
 
 end
 
 context galois
 begin
 
 sublocale galois_prop L R l r .
 
 interpretation flip : galois R L r l .
 
 abbreviation "right_Galois \<equiv> flip.Galois"
 notation right_Galois (infix "\<^bsub>R\<^esub>\<lessapprox>" 50)
 
 abbreviation (input) "ge_Galois_right \<equiv> flip.ge_Galois_left"
 notation ge_Galois_right (infix "\<greaterapprox>\<^bsub>R\<^esub>" 50)
 
 abbreviation "left_ge_Galois \<equiv> flip.right_ge_Galois"
 notation left_ge_Galois (infix "\<^bsub>L\<^esub>\<greaterapprox>" 50)
 
 abbreviation (input) "Galois_left \<equiv> flip.Galois_right"
 notation Galois_left (infix "\<lessapprox>\<^bsub>L\<^esub>" 50)
 
 context
 begin
 
 interpretation flip_inv : galois "(\<ge>\<^bsub>R\<^esub>)" "(\<ge>\<^bsub>L\<^esub>)" r l .
 
 lemma rel_unit_if_left_rel_if_mono_wrt_relI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "x \<lessapprox>\<^bsub>R\<^esub> l x' \<Longrightarrow> x \<le>\<^bsub>L\<^esub> \<eta> x'"
   and "x \<le>\<^bsub>L\<^esub> x'"
   shows "x \<le>\<^bsub>L\<^esub> \<eta> x'"
-  using assms by auto
+  using assms by blast
 
 corollary rel_unit_if_left_rel_if_half_galois_prop_right_if_mono_wrt_rel:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   and "x \<le>\<^bsub>L\<^esub> x'"
   shows "x \<le>\<^bsub>L\<^esub> \<eta> x'"
-  using assms by (auto intro: rel_unit_if_left_rel_if_mono_wrt_relI)
+  using assms by (fastforce intro: rel_unit_if_left_rel_if_mono_wrt_relI)
 
 corollary rel_unit_if_reflexive_on_if_half_galois_prop_right_if_mono_wrt_rel:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   and "reflexive_on P (\<le>\<^bsub>L\<^esub>)"
   and "P x"
   shows "x \<le>\<^bsub>L\<^esub> \<eta> x"
   using assms by (blast intro: rel_unit_if_left_rel_if_half_galois_prop_right_if_mono_wrt_rel)
 
 corollary inflationary_on_unit_if_reflexive_on_if_half_galois_prop_rightI:
   fixes P :: "'a \<Rightarrow> bool"
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   and "reflexive_on P (\<le>\<^bsub>L\<^esub>)"
   shows "inflationary_on P (\<le>\<^bsub>L\<^esub>) \<eta>"
   using assms by (intro inflationary_onI)
   (fastforce intro: rel_unit_if_reflexive_on_if_half_galois_prop_right_if_mono_wrt_rel)
 
 interpretation flip : galois_prop R L r l .
 
 lemma right_rel_if_Galois_left_right_if_deflationary_onI:
   assumes "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "((\<le>\<^bsub>R\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>L\<^esub>)) r l"
   and "deflationary_on P (\<le>\<^bsub>R\<^esub>) \<epsilon>"
   and "transitive (\<le>\<^bsub>R\<^esub>)"
   and "y \<lessapprox>\<^bsub>L\<^esub> r y'"
   and "P y'"
   shows "y \<le>\<^bsub>R\<^esub> y'"
   using assms by force
 
 lemma half_galois_prop_left_left_right_if_transitive_if_deflationary_on_if_mono_wrt_rel:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "deflationary_on (in_codom (\<le>\<^bsub>R\<^esub>)) (\<le>\<^bsub>R\<^esub>) \<epsilon>"
   and "transitive (\<le>\<^bsub>R\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro half_galois_prop_leftI) fastforce
 
 end
 
 interpretation flip_inv : galois "(\<ge>\<^bsub>R\<^esub>)" "(\<ge>\<^bsub>L\<^esub>)" r l
   rewrites "flip_inv.unit \<equiv> \<epsilon>" and "flip_inv.counit \<equiv> \<eta>"
   and "\<And>R S. (R\<inverse> \<Rrightarrow>\<^sub>m S\<inverse>) \<equiv> (R \<Rrightarrow>\<^sub>m S)"
   and "\<And>R S f g. (R\<inverse> \<unlhd>\<^sub>h S\<inverse>) f g \<equiv> (S \<^sub>h\<unlhd> R) g f"
   and "((\<ge>\<^bsub>R\<^esub>) \<^sub>h\<unlhd> (\<ge>\<^bsub>L\<^esub>)) r l \<equiv> ((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   and "\<And>R. R\<inverse>\<inverse> \<equiv> R"
   and "\<And>P R. inflationary_on P R\<inverse> \<equiv> deflationary_on P R"
   and "\<And>P R. deflationary_on P R\<inverse>  \<equiv> inflationary_on P R"
   and "\<And>(P :: 'b \<Rightarrow> bool). reflexive_on P (\<ge>\<^bsub>R\<^esub>) \<equiv> reflexive_on P (\<le>\<^bsub>R\<^esub>)"
   and "\<And>R. transitive R\<inverse> \<equiv> transitive R"
   and "\<And>R. in_codom R\<inverse> \<equiv> in_dom R"
   by (simp_all add: flip_unit_eq_counit flip_counit_eq_unit
     galois_prop.half_galois_prop_left_rel_inv_iff_half_galois_prop_right
     galois_prop.half_galois_prop_right_rel_inv_iff_half_galois_prop_left)
 
 corollary counit_rel_if_right_rel_if_mono_wrt_relI:
   assumes "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "r y \<^bsub>L\<^esub>\<lessapprox> y' \<Longrightarrow> \<epsilon> y \<le>\<^bsub>R\<^esub> y'"
   and "y \<le>\<^bsub>R\<^esub> y'"
   shows "\<epsilon> y \<le>\<^bsub>R\<^esub> y'"
   using assms
   by (fact flip_inv.rel_unit_if_left_rel_if_mono_wrt_relI
     [simplified rel_inv_iff_rel])
 
 corollary counit_rel_if_right_rel_if_half_galois_prop_left_if_mono_wrt_rel:
   assumes "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "((\<le>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   and "y \<le>\<^bsub>R\<^esub> y'"
   shows "\<epsilon> y \<le>\<^bsub>R\<^esub> y'"
   using assms
   by (fact flip_inv.rel_unit_if_left_rel_if_half_galois_prop_right_if_mono_wrt_rel
     [simplified rel_inv_iff_rel])
 
 corollary counit_rel_if_reflexive_on_if_half_galois_prop_left_if_mono_wrt_rel:
   assumes "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "((\<le>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   and "reflexive_on P (\<le>\<^bsub>R\<^esub>)"
   and "P y"
   shows "\<epsilon> y \<le>\<^bsub>R\<^esub> y"
   using assms
   by (fact flip_inv.rel_unit_if_reflexive_on_if_half_galois_prop_right_if_mono_wrt_rel
     [simplified rel_inv_iff_rel])
 
 corollary deflationary_on_counit_if_reflexive_on_if_half_galois_prop_leftI:
   fixes P :: "'b \<Rightarrow> bool"
   assumes "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "((\<le>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   and "reflexive_on P (\<le>\<^bsub>R\<^esub>)"
   shows "deflationary_on P (\<le>\<^bsub>R\<^esub>) \<epsilon>"
   using assms
   by (fact flip_inv.inflationary_on_unit_if_reflexive_on_if_half_galois_prop_rightI)
 
 corollary left_rel_if_left_right_Galois_if_inflationary_onI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>R\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L\<^esub>)) r l"
   and "inflationary_on P (\<le>\<^bsub>L\<^esub>) \<eta>"
   and "transitive (\<le>\<^bsub>L\<^esub>)"
   and "l x \<^bsub>R\<^esub>\<lessapprox> x'"
   and "P x"
   shows "x \<le>\<^bsub>L\<^esub> x'"
   using assms by (intro flip_inv.right_rel_if_Galois_left_right_if_deflationary_onI
     [simplified rel_inv_iff_rel])
 
 corollary half_galois_prop_right_left_right_if_transitive_if_inflationary_on_if_mono_wrt_rel:
   assumes "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "inflationary_on (in_dom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   and "transitive (\<le>\<^bsub>L\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   using assms
   by (fact flip_inv.half_galois_prop_left_left_right_if_transitive_if_deflationary_on_if_mono_wrt_rel)
 
 end
 
 context order_functors
 begin
 
 interpretation g : galois L R l r .
 interpretation flip_g : galois R L r l
   rewrites "flip_g.unit \<equiv> \<epsilon>" and "flip_g.counit \<equiv> \<eta>"
   by (simp_all only: flip_unit_eq_counit flip_counit_eq_unit)
 
 lemma left_rel_if_left_right_rel_left_if_order_equivalenceI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)) l r"
   and "transitive (\<le>\<^bsub>L\<^esub>)"
   and "l x \<le>\<^bsub>R\<^esub> l x'"
   and "in_dom (\<le>\<^bsub>L\<^esub>) x"
   and "in_codom (\<le>\<^bsub>L\<^esub>) x'"
   shows "x \<le>\<^bsub>L\<^esub> x'"
   using assms by (auto intro!:
       flip_g.right_rel_if_Galois_left_right_if_deflationary_onI
       g.half_galois_prop_right_left_right_if_transitive_if_inflationary_on_if_mono_wrt_rel
     elim!: rel_equivalence_onE
     intro: inflationary_on_if_le_pred_if_inflationary_on
       in_field_if_in_dom in_field_if_in_codom)
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Algebra_Alignment_Galois.thy b/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Algebra_Alignment_Galois.thy
--- a/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Algebra_Alignment_Galois.thy
+++ b/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Algebra_Alignment_Galois.thy
@@ -1,80 +1,81 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Alignment With Definitions from HOL-Algebra\<close>
 theory HOL_Algebra_Alignment_Galois
   imports
     "HOL-Algebra.Galois_Connection"
     HOL_Algebra_Alignment_Orders
     Galois
 begin
 
 named_theorems HOL_Algebra_galois_alignment
 
 context galois_connection
 begin
 
 context
   fixes L R l r
   defines "L \<equiv> (\<sqsubseteq>\<^bsub>\<X>\<^esub>)\<restriction>\<^bsub>carrier \<X>\<^esub>\<upharpoonleft>\<^bsub>carrier \<X>\<^esub>" and "R \<equiv> (\<sqsubseteq>\<^bsub>\<Y>\<^esub>)\<restriction>\<^bsub>carrier \<Y>\<^esub>\<upharpoonleft>\<^bsub>carrier \<Y>\<^esub>"
     and "l \<equiv> \<pi>\<^sup>*" and "r \<equiv> \<pi>\<^sub>*"
-  notes defs[simp] = L_def R_def l_def r_def and restrict_right_eq[simp]
-    and restrict_leftI[intro!] restrict_leftE[elim!]
+  notes defs[simp] = L_def R_def l_def r_def and bin_rel_restrict_right_eq[simp]
+    and bin_rel_restrict_leftI[intro!] bin_rel_restrict_leftE[elim!]
 begin
 
 interpretation galois L R l r .
 
 lemma mono_wrt_rel_lower [HOL_Algebra_galois_alignment]: "(L \<Rrightarrow>\<^sub>m R) l"
   using lower_closed upper_closed by (fastforce intro: use_iso2[OF lower_iso])
 
 lemma mono_wrt_rel_upper [HOL_Algebra_galois_alignment]: "(R \<Rrightarrow>\<^sub>m L) r"
   using lower_closed upper_closed by (fastforce intro: use_iso2[OF upper_iso])
 
 lemma half_galois_prop_left [HOL_Algebra_galois_alignment]: "(L \<^sub>h\<unlhd> R) l r"
-  using galois_property lower_closed by fastforce
+  using galois_property lower_closed by (intro half_galois_prop_leftI) fastforce
 
 lemma half_galois_prop_right [HOL_Algebra_galois_alignment]: "(L \<unlhd>\<^sub>h R) l r"
-  using galois_property upper_closed by fastforce
+  using galois_property upper_closed by (intro half_galois_prop_rightI) fastforce
 
 lemma galois_prop [HOL_Algebra_galois_alignment]: "(L \<unlhd> R) l r"
   using half_galois_prop_left half_galois_prop_right by blast
 
 lemma galois_connection [HOL_Algebra_galois_alignment]: "(L \<stileturn> R) l r"
   using mono_wrt_rel_lower mono_wrt_rel_upper galois_prop by blast
 
 end
 end
 
 context galois_bijection
 begin
 
 context
   fixes L R l r
   defines "L \<equiv> (\<sqsubseteq>\<^bsub>\<X>\<^esub>)\<restriction>\<^bsub>carrier \<X>\<^esub>\<upharpoonleft>\<^bsub>carrier \<X>\<^esub>" and "R \<equiv> (\<sqsubseteq>\<^bsub>\<Y>\<^esub>)\<restriction>\<^bsub>carrier \<Y>\<^esub>\<upharpoonleft>\<^bsub>carrier \<Y>\<^esub>"
     and "l \<equiv> \<pi>\<^sup>*" and "r \<equiv> \<pi>\<^sub>*"
-  notes defs[simp] = L_def R_def l_def r_def and restrict_right_eq[simp]
-    and restrict_leftI[intro!] restrict_leftE[elim!] in_codom_restrict_leftE[elim!]
+  notes defs[simp] = L_def R_def l_def r_def and bin_rel_restrict_right_eq[simp]
+    and bin_rel_restrict_leftI[intro!] bin_rel_restrict_leftE[elim!]
+      in_codom_bin_rel_restrict_leftE[elim!]
 begin
 
 interpretation galois R L r l .
 
 lemma half_galois_prop_left_right_left [HOL_Algebra_galois_alignment]:
   "(R \<^sub>h\<unlhd> L) r l"
   using gal_bij_conn.right lower_inv_eq upper_closed upper_inv_eq
   by (intro half_galois_prop_leftI; elim left_GaloisE) (auto; metis)
 
 lemma half_galois_prop_right_right_left [HOL_Algebra_galois_alignment]:
   "(R \<unlhd>\<^sub>h L) r l"
   using gal_bij_conn.left lower_closed lower_inv_eq upper_inv_eq
   by (intro half_galois_prop_rightI; elim Galois_rightE) (auto; metis)
 
 lemma prop_right_right_left [HOL_Algebra_galois_alignment]: "(R \<unlhd> L) r l"
   using half_galois_prop_left_right_left half_galois_prop_right_right_left by blast
 
 lemma galois_equivalence [HOL_Algebra_galois_alignment]: "(L \<equiv>\<^sub>G R) l r"
   using gal_bij_conn.galois_connection prop_right_right_left
   by (intro galois.galois_equivalenceI) auto
 
 end
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Alignment_Binary_Relations.thy b/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Alignment_Binary_Relations.thy
--- a/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Alignment_Binary_Relations.thy
+++ b/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Alignment_Binary_Relations.thy
@@ -1,306 +1,296 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Alignment With Definitions from HOL.Main\<close>
 theory HOL_Alignment_Binary_Relations
   imports
     Main
     HOL_Mem_Of
     HOL_Syntax_Bundles_Relations
     LBinary_Relations
 begin
 
 unbundle no_HOL_relation_syntax
 
 named_theorems HOL_bin_rel_alignment
 
 paragraph \<open>Properties\<close>
 subparagraph \<open>Antisymmetric\<close>
 
 overloading
   antisymmetric_on_set \<equiv> "antisymmetric_on :: 'a set \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "antisymmetric_on_set (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> _ \<equiv>
     antisymmetric_on (mem_of S)"
 end
 
 lemma antisymmetric_on_set_eq_antisymmetric_on_pred [simp]:
   "(antisymmetric_on (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> bool) =
     antisymmetric_on (mem_of S)"
   unfolding antisymmetric_on_set_def by simp
 
 lemma antisymmetric_on_set_iff_antisymmetric_on_pred [iff]:
   "antisymmetric_on (S :: 'a set) (R :: 'a \<Rightarrow> _) \<longleftrightarrow> antisymmetric_on (mem_of S) R"
   by simp
 
 lemma antisymp_eq_antisymmetric [HOL_bin_rel_alignment]:
   "antisymp = antisymmetric"
   by (intro ext) (auto intro: antisympI dest: antisymmetricD antisympD)
 
 
 subparagraph \<open>Injective\<close>
 
 overloading
   rel_injective_on_set \<equiv> "rel_injective_on :: 'a set \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool"
   rel_injective_at_set \<equiv> "rel_injective_at :: 'a set \<Rightarrow> ('b \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "rel_injective_on_set (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> _ \<equiv>
     rel_injective_on (mem_of S)"
   definition "rel_injective_at_set (S :: 'a set) :: ('b \<Rightarrow> 'a \<Rightarrow> _) \<Rightarrow> _ \<equiv>
     rel_injective_at (mem_of S)"
 end
 
 lemma rel_injective_on_set_eq_rel_injective_on_pred [simp]:
   "(rel_injective_on (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> bool) =
     rel_injective_on (mem_of S)"
   unfolding rel_injective_on_set_def by simp
 
 lemma rel_injective_on_set_iff_rel_injective_on_pred [iff]:
   "rel_injective_on (S :: 'a set) (R :: 'a \<Rightarrow> _) \<longleftrightarrow> rel_injective_on (mem_of S) R"
   by simp
 
 lemma rel_injective_at_set_eq_rel_injective_at_pred [simp]:
   "(rel_injective_at (S :: 'a set) :: ('b \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool) =
     rel_injective_at (mem_of S)"
   unfolding rel_injective_at_set_def by simp
 
 lemma rel_injective_at_set_iff_rel_injective_at_pred [iff]:
   "rel_injective_at (S :: 'a set) (R :: 'b \<Rightarrow> 'a \<Rightarrow> bool) \<longleftrightarrow> rel_injective_at (mem_of S) R"
   by simp
 
 lemma left_unique_eq_rel_injective [HOL_bin_rel_alignment]:
   "left_unique = rel_injective"
   by (intro ext) (blast intro: left_uniqueI dest: rel_injectiveD left_uniqueD)
 
 subparagraph \<open>Irreflexive\<close>
 
 overloading
   irreflexive_on_set \<equiv> "irreflexive_on :: 'a set \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "irreflexive_on_set (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> _ \<equiv>
     irreflexive_on (mem_of S)"
 end
 
 lemma irreflexive_on_set_eq_irreflexive_on_pred [simp]:
   "(irreflexive_on (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> bool) =
     irreflexive_on (mem_of S)"
   unfolding irreflexive_on_set_def by simp
 
 lemma irreflexive_on_set_iff_irreflexive_on_pred [iff]:
   "irreflexive_on (S :: 'a set) (R :: 'a \<Rightarrow> _) \<longleftrightarrow>
     irreflexive_on (mem_of S) R"
   by simp
 
 lemma irreflp_on_eq_irreflexive_on [HOL_bin_rel_alignment]:
   "irreflp_on = irreflexive_on"
   by (intro ext) (blast intro: irreflp_onI dest: irreflp_onD)
 
 lemma irreflp_eq_irreflexive [HOL_bin_rel_alignment]: "irreflp = irreflexive"
   by (intro ext) (blast intro: irreflpI dest: irreflexiveD irreflpD)
 
 subparagraph \<open>Left-Total\<close>
 
 overloading
   left_total_on_set \<equiv> "left_total_on :: 'a set \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "left_total_on_set (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> _ \<equiv>
     left_total_on (mem_of S)"
 end
 
 lemma left_total_on_set_eq_left_total_on_pred [simp]:
   "(left_total_on (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> bool) =
     left_total_on (mem_of S)"
   unfolding left_total_on_set_def by simp
 
 lemma left_total_on_set_iff_left_total_on_pred [iff]:
   "left_total_on (S :: 'a set) (R :: 'a \<Rightarrow> _) \<longleftrightarrow> left_total_on (mem_of S) R"
   by simp
 
 lemma Transfer_left_total_eq_left_total [HOL_bin_rel_alignment]:
   "Transfer.left_total = Binary_Relations_Left_Total.left_total"
   by (intro ext) (fast intro: Transfer.left_totalI
     elim: Transfer.left_totalE Binary_Relations_Left_Total.left_totalE)
 
 
 subparagraph \<open>Reflexive\<close>
 
 overloading
   reflexive_on_set \<equiv> "reflexive_on :: 'a set \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "reflexive_on_set (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> _ \<equiv>
     reflexive_on (mem_of S)"
 end
 
 lemma reflexive_on_set_eq_reflexive_on_pred [simp]:
   "(reflexive_on (S :: 'a set) :: ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool) =
     reflexive_on (mem_of S)"
   unfolding reflexive_on_set_def by simp
 
 lemma reflexive_on_set_iff_reflexive_on_pred [iff]:
   "reflexive_on (S :: 'a set) (R :: 'a \<Rightarrow> 'a \<Rightarrow> bool) \<longleftrightarrow>
     reflexive_on (mem_of S) R"
   by simp
 
 lemma reflp_on_eq_reflexive_on [HOL_bin_rel_alignment]:
   "reflp_on = reflexive_on"
   by (intro ext) (blast intro: reflp_onI dest: reflp_onD)
 
 lemma reflp_eq_reflexive [HOL_bin_rel_alignment]: "reflp = reflexive"
   by (intro ext) (blast intro: reflpI dest: reflexiveD reflpD)
 
 
 subparagraph \<open>Right-Unique\<close>
 
 overloading
   right_unique_on_set \<equiv> "right_unique_on :: 'a set \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool"
   right_unique_at_set \<equiv> "right_unique_at :: 'a set \<Rightarrow> ('b \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "right_unique_on_set (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> _ \<equiv>
     right_unique_on (mem_of S)"
   definition "right_unique_at_set (S :: 'a set) :: ('b \<Rightarrow> 'a \<Rightarrow> _) \<Rightarrow> _ \<equiv>
     right_unique_at (mem_of S)"
 end
 
 lemma right_unique_on_set_eq_right_unique_on_pred [simp]:
   "(right_unique_on (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> bool) =
     right_unique_on (mem_of S)"
   unfolding right_unique_on_set_def by simp
 
 lemma right_unique_on_set_iff_right_unique_on_pred [iff]:
   "right_unique_on (S :: 'a set) (R :: 'a \<Rightarrow> _) \<longleftrightarrow> right_unique_on (mem_of S) R"
   by simp
 
 lemma right_unique_at_set_eq_right_unique_at_pred [simp]:
   "(right_unique_at (S :: 'a set) :: ('b \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool) =
     right_unique_at (mem_of S)"
   unfolding right_unique_at_set_def by simp
 
 lemma right_unique_at_set_iff_right_unique_at_pred [iff]:
   "right_unique_at (S :: 'a set) (R :: 'b \<Rightarrow> 'a \<Rightarrow> bool) \<longleftrightarrow> right_unique_at (mem_of S) R"
   by simp
 
 lemma Transfer_right_unique_eq_right_unique [HOL_bin_rel_alignment]:
   "Transfer.right_unique = Binary_Relations_Right_Unique.right_unique"
   by (intro ext) (blast intro: Transfer.right_uniqueI
     dest: Transfer.right_uniqueD Binary_Relations_Right_Unique.right_uniqueD)
 
 
 subparagraph \<open>Surjective\<close>
 
 overloading
   rel_surjective_at_set \<equiv> "rel_surjective_at :: 'a set \<Rightarrow> ('b \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "rel_surjective_at_set (S :: 'a set) :: ('b \<Rightarrow> 'a \<Rightarrow> _) \<Rightarrow> _ \<equiv>
     rel_surjective_at (mem_of S)"
 end
 
 lemma rel_surjective_at_set_eq_rel_surjective_at_pred [simp]:
   "(rel_surjective_at (S :: 'a set) :: ('b \<Rightarrow> 'a \<Rightarrow> _) \<Rightarrow> bool) =
     rel_surjective_at (mem_of S)"
   unfolding rel_surjective_at_set_def by simp
 
 lemma rel_surjective_at_set_iff_rel_surjective_at_pred [iff]:
   "rel_surjective_at (S :: 'a set) (R :: 'b \<Rightarrow> 'a \<Rightarrow> _) \<longleftrightarrow> rel_surjective_at (mem_of S) R"
   by simp
 
 lemma Transfer_right_total_eq_rel_surjective [HOL_bin_rel_alignment]:
   "Transfer.right_total = rel_surjective"
   by (intro ext) (fast intro: Transfer.right_totalI rel_surjectiveI
     elim: Transfer.right_totalE rel_surjectiveE)
 
 
 subparagraph \<open>Symmetric\<close>
 
 overloading
   symmetric_on_set \<equiv> "symmetric_on :: 'a set \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "symmetric_on_set (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> _ \<equiv>
     symmetric_on (mem_of S)"
 end
 
 lemma symmetric_on_set_eq_symmetric_on_pred [simp]:
   "(symmetric_on (S :: 'a set) :: ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool) =
     symmetric_on (mem_of S)"
   unfolding symmetric_on_set_def by simp
 
 lemma symmetric_on_set_iff_symmetric_on_pred [iff]:
   "symmetric_on (S :: 'a set) (R :: 'a \<Rightarrow> 'a \<Rightarrow> bool) \<longleftrightarrow>
     symmetric_on (mem_of S) R"
   by simp
 
 lemma symp_eq_symmetric [HOL_bin_rel_alignment]: "symp = symmetric"
   by (intro ext) (blast intro: sympI dest: symmetricD sympD)
 
 
 subparagraph \<open>Transitive\<close>
 
 overloading
   transitive_on_set \<equiv> "transitive_on :: 'a set \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool"
 begin
   definition "transitive_on_set (S :: 'a set) :: ('a \<Rightarrow> _) \<Rightarrow> _ \<equiv>
     transitive_on (mem_of S)"
 end
 
 lemma transitive_on_set_eq_transitive_on_pred [simp]:
   "(transitive_on (S :: 'a set) :: ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> bool) =
     transitive_on (mem_of S)"
   unfolding transitive_on_set_def by simp
 
 lemma transitive_on_set_iff_transitive_on_pred [iff]:
   "transitive_on (S :: 'a set) (R :: 'a \<Rightarrow> 'a \<Rightarrow> bool) \<longleftrightarrow>
     transitive_on (mem_of S) R"
   by simp
 
 lemma transp_eq_transitive [HOL_bin_rel_alignment]: "transp = transitive"
   by (intro ext) (blast intro: transpI dest: transpD)
 
 
 paragraph \<open>Functions\<close>
 
 lemma relcompp_eq_rel_comp [HOL_bin_rel_alignment]: "relcompp = rel_comp"
   by (intro ext) auto
 
 lemma conversep_eq_rel_inv [HOL_bin_rel_alignment]: "conversep = rel_inv"
   by (intro ext) auto
 
 lemma Domainp_eq_in_dom [HOL_bin_rel_alignment]: "Domainp = in_dom"
   by (intro ext) auto
 
 lemma Rangep_eq_in_codom [HOL_bin_rel_alignment]: "Rangep = in_codom"
    by (intro ext) auto
 
-overloading
-  restrict_left_set \<equiv> "restrict_left :: ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('a set) \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> bool"
-begin
-  definition "restrict_left_set (R :: 'a \<Rightarrow> _) (S :: 'a set) \<equiv> R\<restriction>\<^bsub>mem_of S\<^esub>"
-end
-
-lemma restrict_left_set_eq_restrict_left_pred [simp]:
-  "(R\<restriction>\<^bsub>S :: 'a set\<^esub> :: 'a \<Rightarrow> _) = R\<restriction>\<^bsub>mem_of S\<^esub>"
-  unfolding restrict_left_set_def by simp
-
-lemma restrict_left_set_iff_restrict_left_pred [iff]:
-  "(R\<restriction>\<^bsub>S :: 'a set\<^esub> :: 'a \<Rightarrow> _) x y \<longleftrightarrow> R\<restriction>\<^bsub>mem_of S\<^esub> x y"
-  by simp
-
-
-
-paragraph \<open>Restricted Equality\<close>
-
-lemma eq_onp_eq_eq_restrict [HOL_bin_rel_alignment]: "eq_onp = eq_restrict"
+lemma eq_onp_eq_eq_restrict [HOL_bin_rel_alignment]: "eq_onp = restrict_left (=)"
   unfolding eq_onp_def by (intro ext) auto
 
 overloading
-  eq_restrict_set \<equiv> "eq_restrict :: 'a set \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> bool"
+  bin_rel_restrict_left_set \<equiv> "restrict_left :: ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> 'a set \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> bool"
+  bin_rel_restrict_right_set \<equiv> "restrict_right :: ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> 'b set \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> bool"
 begin
-  definition "eq_restrict_set (S :: 'a set) \<equiv> ((=\<^bsub>mem_of S\<^esub>) :: 'a \<Rightarrow> _)"
+  definition "bin_rel_restrict_left_set (R :: 'a \<Rightarrow> 'b \<Rightarrow> bool) (S :: 'a set) \<equiv> R\<restriction>\<^bsub>mem_of S\<^esub>"
+  definition "bin_rel_restrict_right_set (R :: 'a \<Rightarrow> 'b \<Rightarrow> bool) (S :: 'b set) \<equiv> R\<upharpoonleft>\<^bsub>mem_of S\<^esub>"
 end
 
-lemma eq_restrict_set_eq_eq_restrict_pred [simp]:
-  "((=\<^bsub>S :: 'a set\<^esub>) :: 'a \<Rightarrow> _) = (=\<^bsub>mem_of S\<^esub>)"
-  unfolding eq_restrict_set_def by simp
+lemma bin_rel_restrict_left_set_eq_restrict_left_pred [simp]:
+  "(R\<restriction>\<^bsub>S :: 'a set\<^esub> :: 'a \<Rightarrow> 'b \<Rightarrow> bool) = R\<restriction>\<^bsub>mem_of S\<^esub>"
+  unfolding bin_rel_restrict_left_set_def by simp
 
-lemma eq_restrict_set_iff_eq_restrict_pred [iff]:
-  "(x :: 'a) =\<^bsub>(S :: 'a set)\<^esub> y \<longleftrightarrow> x =\<^bsub>mem_of S\<^esub> y"
+lemma bin_rel_restrict_right_set_eq_restrict_right_pred [simp]:
+  "(R\<upharpoonleft>\<^bsub>S :: 'b set\<^esub> :: 'a \<Rightarrow> 'b \<Rightarrow> bool) = R\<upharpoonleft>\<^bsub>mem_of S\<^esub>"
+  unfolding bin_rel_restrict_right_set_def by simp
+
+lemma restrict_left_set_iff_restrict_left_pred [iff]: "(R\<restriction>\<^bsub>S :: 'a set\<^esub> :: 'a \<Rightarrow> _) x y \<longleftrightarrow> R\<restriction>\<^bsub>mem_of S\<^esub> x y"
   by simp
 
+lemma restrict_right_set_iff_restrict_right_pred [iff]:
+  "(R\<upharpoonleft>\<^bsub>S :: 'b set\<^esub> :: _ \<Rightarrow> 'b \<Rightarrow> _) x y \<longleftrightarrow> R\<upharpoonleft>\<^bsub>mem_of S\<^esub> x y"
+  by simp
 
 end
diff --git a/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Alignment_Functions.thy b/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Alignment_Functions.thy
--- a/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Alignment_Functions.thy
+++ b/thys/Transport/HOL_Basics/HOL_Alignments/HOL_Alignment_Functions.thy
@@ -1,161 +1,160 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Alignment With Definitions from HOL.Main\<close>
 theory HOL_Alignment_Functions
   imports
     HOL_Alignment_Binary_Relations
     HOL_Syntax_Bundles_Functions
     LFunctions
 begin
 
 unbundle no_HOL_function_syntax
 
 named_theorems HOL_fun_alignment
 
 paragraph \<open>Functions\<close>
 
 subparagraph \<open>Bijection\<close>
 
 overloading
   bijection_on_set \<equiv> "bijection_on :: 'a set \<Rightarrow> 'b set \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow> ('b \<Rightarrow> 'a) \<Rightarrow> bool"
 begin
   definition "bijection_on_set (S :: 'a set) (S' :: 'b set) :: ('a \<Rightarrow> 'b) \<Rightarrow> ('b \<Rightarrow> 'a) \<Rightarrow> bool \<equiv>
     bijection_on (mem_of S) (mem_of S')"
 end
 
 lemma bijection_on_set_eq_bijection_on_pred [simp]:
   "(bijection_on (S :: 'a set) (S' :: 'b set) :: ('a \<Rightarrow> 'b) \<Rightarrow> _) =
     bijection_on (mem_of S) (mem_of S')"
   unfolding bijection_on_set_def by simp
 
 lemma bijection_on_set_iff_bijection_on_pred [iff]:
   "bijection_on (S :: 'a set) (S' :: 'b set) (f :: 'a \<Rightarrow> 'b) g \<longleftrightarrow>
     bijection_on (mem_of S) (mem_of S') f g"
   by simp
 
 lemma bij_betw_bijection_onE:
   assumes "bij_betw f S S'"
   obtains g where "bijection_on S S' f g"
 proof
   let ?g = "the_inv_into S f"
   from assms bij_betw_the_inv_into have "bij_betw ?g S' S" by blast
   with assms show "bijection_on S S' f ?g"
     by (auto intro!: bijection_onI
       dest: bij_betw_apply bij_betw_imp_inj_on the_inv_into_f_f
       simp: f_the_inv_into_f_bij_betw)
 qed
 
 lemma bij_betw_if_bijection_on:
   assumes "bijection_on S S' f g"
   shows "bij_betw f S S'"
   using assms by (intro bij_betw_byWitness[where ?f'=g])
   (auto elim: bijection_onE dest: inverse_onD)
 
 corollary bij_betw_iff_ex_bijection_on [HOL_fun_alignment]:
   "bij_betw f S S' \<longleftrightarrow> (\<exists>g. bijection_on S S' f g)"
   by (intro iffI)
   (auto elim!: bij_betw_bijection_onE intro: bij_betw_if_bijection_on)
 
 
 subparagraph \<open>Injective\<close>
 
 overloading
   injective_on_set \<equiv> "injective_on :: 'a set \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow> bool"
 begin
   definition "injective_on_set (S :: 'a set) :: ('a \<Rightarrow> 'b) \<Rightarrow> bool \<equiv>
     injective_on (mem_of S)"
 end
 
 lemma injective_on_set_eq_injective_on_pred [simp]:
   "(injective_on (S :: 'a set) :: ('a \<Rightarrow> 'b) \<Rightarrow> _) = injective_on (mem_of S)"
   unfolding injective_on_set_def by simp
 
 lemma injective_on_set_iff_injective_on_pred [iff]:
   "injective_on (S :: 'a set) (f :: 'a \<Rightarrow> 'b) \<longleftrightarrow> injective_on (mem_of S) f"
   by simp
 
 lemma inj_on_iff_injective_on [HOL_fun_alignment]: "inj_on f P \<longleftrightarrow> injective_on P f"
   by (auto intro: inj_onI dest: inj_onD injective_onD)
 
 lemma inj_eq_injective [HOL_fun_alignment]: "inj = injective"
   by (auto intro: injI dest: injD injectiveD)
 
 
 subparagraph \<open>Inverse\<close>
 
 overloading
   inverse_on_set \<equiv> "inverse_on :: 'a set \<Rightarrow> ('a \<Rightarrow> 'b) \<Rightarrow> ('b \<Rightarrow> 'a) \<Rightarrow> bool"
 begin
   definition "inverse_on_set (S :: 'a set) :: ('a \<Rightarrow> 'b) \<Rightarrow> _ \<equiv>
     inverse_on (mem_of S)"
 end
 
 lemma inverse_on_set_eq_inverse_on_pred [simp]:
   "(inverse_on (S :: 'a set) :: ('a \<Rightarrow> 'b) \<Rightarrow> _) = inverse_on (mem_of S)"
   unfolding inverse_on_set_def by simp
 
 lemma inverse_on_set_iff_inverse_on_pred [iff]:
   "inverse_on (S :: 'a set) (f :: 'a \<Rightarrow> 'b) g \<longleftrightarrow> inverse_on (mem_of S) f g"
   by simp
 
 
 subparagraph \<open>Monotone\<close>
 
 lemma monotone_on_eq_mono_wrt_rel_restrict_left_right [HOL_fun_alignment]:
-  "monotone_on S R = mono_wrt_rel (R\<restriction>\<^bsub>S\<^esub>\<upharpoonleft>\<^bsub>S\<^esub>)"
-  unfolding restrict_right_eq
-  by (intro ext) (blast intro: monotone_onI dest: monotone_onD)
+  "monotone_on S R = mono_wrt_rel R\<restriction>\<^bsub>S\<^esub>\<upharpoonleft>\<^bsub>S\<^esub>"
+  by (intro ext) (auto intro!: monotone_onI dest: monotone_onD)
 
 lemma monotone_eq_mono_wrt_rel [HOL_fun_alignment]: "monotone = mono_wrt_rel"
   by (intro ext) (auto intro: monotoneI dest: monotoneD)
 
 lemma pred_fun_eq_mono_wrt_pred [HOL_fun_alignment]: "pred_fun = mono_wrt_pred"
   by (intro ext) auto
 
 lemma Fun_mono_eq_mono [HOL_fun_alignment]: "Fun.mono = mono"
   by (intro ext) (auto intro: Fun.mono_onI dest: Fun.monoD)
 
 lemma Fun_antimono_eq_antimono [HOL_fun_alignment]: "Fun.antimono = antimono"
   by (intro ext) (auto intro: monotoneI dest: monotoneD)
 
 
 subparagraph \<open>Surjective\<close>
 
 overloading
   surjective_at_set \<equiv> "surjective_at :: 'a set \<Rightarrow> ('b \<Rightarrow> 'a) \<Rightarrow> bool"
 begin
   definition "surjective_at_set (S :: 'a set) :: ('b \<Rightarrow> 'a) \<Rightarrow> bool \<equiv>
     surjective_at (mem_of S)"
 end
 
 lemma surjective_at_set_eq_surjective_at_pred [simp]:
   "(surjective_at (S :: 'a set) :: ('b \<Rightarrow> 'a) \<Rightarrow> _) = surjective_at (mem_of S)"
   unfolding surjective_at_set_def by simp
 
 lemma surjective_at_set_iff_surjective_at_pred [iff]:
   "surjective_at (S :: 'a set) (f :: 'b \<Rightarrow> 'a) \<longleftrightarrow> surjective_at (mem_of S) f"
   by simp
 
 lemma surj_eq_surjective [HOL_fun_alignment]: "surj = surjective"
   by (intro ext) (fast intro: surjI dest: surjD elim: surjectiveE)
 
 
 paragraph \<open>Functions\<close>
 
 lemma Fun_id_eq_id [HOL_fun_alignment]: "Fun.id = Functions_Base.id"
   by (intro ext) simp
 
 lemma Fun_comp_eq_comp [HOL_fun_alignment]: "Fun.comp = Functions_Base.comp"
   by (intro ext) simp
 
 lemma map_fun_eq_fun_map [HOL_fun_alignment]: "map_fun = fun_map"
   by (intro ext) simp
 
 
 paragraph \<open>Relators\<close>
 
 lemma rel_fun_eq_Fun_Rel_rel [HOL_fun_alignment]: "rel_fun = Fun_Rel_rel"
   by (intro ext) (auto dest: rel_funD)
 
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Orders/Equivalence_Relations.thy b/thys/Transport/HOL_Basics/Orders/Equivalence_Relations.thy
--- a/thys/Transport/HOL_Basics/Orders/Equivalence_Relations.thy
+++ b/thys/Transport/HOL_Basics/Orders/Equivalence_Relations.thy
@@ -1,72 +1,71 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Equivalences\<close>
 theory Equivalence_Relations
   imports
     Partial_Equivalence_Relations
 begin
 
-definition "equivalence_rel_on P R \<equiv>
-  partial_equivalence_rel_on P R \<and> reflexive_on P R"
+definition "equivalence_rel_on \<equiv> partial_equivalence_rel_on \<sqinter> reflexive_on"
 
 lemma equivalence_rel_onI [intro]:
   assumes "partial_equivalence_rel_on P R"
   and "reflexive_on P R"
   shows "equivalence_rel_on P R"
-  unfolding equivalence_rel_on_def using assms by blast
+  unfolding equivalence_rel_on_def using assms by auto
 
 lemma equivalence_rel_onE [elim]:
   assumes "equivalence_rel_on P R"
   obtains "partial_equivalence_rel_on P R" "reflexive_on P R"
-  using assms unfolding equivalence_rel_on_def by blast
+  using assms unfolding equivalence_rel_on_def by auto
 
 lemma equivalence_rel_on_in_field_if_partial_equivalence_rel:
   assumes "partial_equivalence_rel R"
   shows "equivalence_rel_on (in_field R) R"
   using assms
   by (intro equivalence_rel_onI reflexive_on_in_field_if_partial_equivalence_rel) auto
 
 corollary partial_equivalence_rel_iff_equivalence_rel_on_in_field:
   "partial_equivalence_rel R \<longleftrightarrow> equivalence_rel_on (in_field R) R"
   using equivalence_rel_on_in_field_if_partial_equivalence_rel by auto
 
 
-definition "equivalence_rel (R :: 'a \<Rightarrow> _) \<equiv> equivalence_rel_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(equivalence_rel :: ('a \<Rightarrow> _) \<Rightarrow> bool) \<equiv> equivalence_rel_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma equivalence_rel_eq_equivalence_rel_on:
-  "equivalence_rel (R :: 'a \<Rightarrow> _) = equivalence_rel_on (\<top> :: 'a \<Rightarrow> bool) R"
+  "(equivalence_rel :: ('a \<Rightarrow> _) \<Rightarrow> bool) = equivalence_rel_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding equivalence_rel_def ..
 
 lemma equivalence_relI [intro]:
   assumes "partial_equivalence_rel R"
   and "reflexive R"
   shows "equivalence_rel R"
   unfolding equivalence_rel_eq_equivalence_rel_on using assms
   by (intro equivalence_rel_onI partial_equivalence_rel_on_if_partial_equivalence_rel
     reflexive_on_if_reflexive)
 
 lemma equivalence_relE [elim]:
   assumes "equivalence_rel R"
   obtains "partial_equivalence_rel R" "reflexive R"
   using assms unfolding equivalence_rel_eq_equivalence_rel_on
   by (elim equivalence_rel_onE)
   (simp only: partial_equivalence_rel_eq_partial_equivalence_rel_on
     reflexive_eq_reflexive_on)
 
 lemma equivalence_rel_on_if_equivalence:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "equivalence_rel R"
   shows "equivalence_rel_on P R"
   using assms by (elim equivalence_relE)
   (intro equivalence_rel_onI partial_equivalence_rel_on_if_partial_equivalence_rel
     reflexive_on_if_reflexive)
 
 
 paragraph \<open>Instantiations\<close>
 
 lemma equivalence_eq: "equivalence_rel (=)"
   using partial_equivalence_rel_eq reflexive_eq by (rule equivalence_relI)
 
 lemma equivalence_top: "equivalence_rel \<top>"
   using partial_equivalence_rel_top reflexive_top by (rule equivalence_relI)
 
 end
diff --git a/thys/Transport/HOL_Basics/Orders/Functions/Closure_Operators.thy b/thys/Transport/HOL_Basics/Orders/Functions/Closure_Operators.thy
--- a/thys/Transport/HOL_Basics/Orders/Functions/Closure_Operators.thy
+++ b/thys/Transport/HOL_Basics/Orders/Functions/Closure_Operators.thy
@@ -1,86 +1,85 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsubsection \<open>Closure Operators\<close>
 theory Closure_Operators
   imports
     Order_Functions_Base
 begin
 
 definition "idempotent_on P R f \<equiv> rel_equivalence_on P (rel_map f R) f"
 
 lemma idempotent_onI [intro]:
   assumes "\<And>x. P x \<Longrightarrow> f x \<equiv>\<^bsub>R\<^esub> f (f x)"
   shows "idempotent_on P R f"
   unfolding idempotent_on_def using assms by fastforce
 
 lemma idempotent_onE [elim]:
   assumes "idempotent_on P R f"
   and "P x"
   obtains "R (f (f x)) (f x)" "R (f x) (f (f x))"
   using assms unfolding idempotent_on_def by fastforce
 
 lemma rel_equivalence_on_rel_map_iff_idempotent_on [iff]:
   "rel_equivalence_on P (rel_map f R) f \<longleftrightarrow> idempotent_on P R f"
   unfolding idempotent_on_def by simp
 
 lemma bi_related_if_idempotent_onD:
   assumes "idempotent_on P R f"
   and "P x"
   shows "f x \<equiv>\<^bsub>R\<^esub> f (f x)"
   using assms by blast
 
-definition "idempotent (R :: 'a \<Rightarrow> _) f \<equiv> idempotent_on (\<top> :: 'a \<Rightarrow> bool) R f"
+definition "(idempotent :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> idempotent_on (\<top> :: 'a \<Rightarrow> bool)"
 
-lemma idempotent_eq_idempotent_on:
-  "idempotent (R :: 'a \<Rightarrow> _) f = idempotent_on (\<top> :: 'a \<Rightarrow> bool) R f"
+lemma idempotent_eq_idempotent_on: "(idempotent :: ('a \<Rightarrow> _) \<Rightarrow> _) = idempotent_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding idempotent_def ..
 
 lemma idempotentI [intro]:
   assumes "\<And>x. R (f (f x)) (f x)"
   and "\<And>x. R (f x) (f (f x))"
   shows "idempotent R f"
   unfolding idempotent_eq_idempotent_on using assms by blast
 
 lemma idempotentE [elim]:
   assumes "idempotent R f"
   obtains "R (f (f x)) (f x)" "R (f x) (f (f x))"
   using assms unfolding idempotent_eq_idempotent_on by (blast intro: top1I)
 
 lemma idempotent_on_if_idempotent:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "idempotent R f"
   shows "idempotent_on P R f"
   using assms by (intro idempotent_onI) auto
 
-definition "closure_operator R f \<equiv>
-  (R \<Rrightarrow>\<^sub>m R) f \<and> inflationary_on (in_field R) R f \<and> idempotent_on (in_field R) R f"
+definition "closure_operator R \<equiv>
+  (R \<Rrightarrow>\<^sub>m R) \<sqinter> inflationary_on (in_field R) R \<sqinter> idempotent_on (in_field R) R"
 
 lemma closure_operatorI [intro]:
   assumes "(R \<Rrightarrow>\<^sub>m R) f"
   and "inflationary_on (in_field R) R f"
   and "idempotent_on (in_field R) R f"
   shows "closure_operator R f"
   unfolding closure_operator_def using assms by blast
 
 lemma closure_operatorE [elim]:
   assumes "closure_operator R f"
   obtains "(R \<Rrightarrow>\<^sub>m R) f" "inflationary_on (in_field R) R f"
     "idempotent_on (in_field R) R f"
   using assms unfolding closure_operator_def by blast
 
 lemma mono_wrt_rel_if_closure_operator:
   assumes "closure_operator R f"
   shows "(R \<Rrightarrow>\<^sub>m R) f"
   using assms by (elim closure_operatorE)
 
 lemma inflationary_on_in_field_if_closure_operator:
   assumes "closure_operator R f"
   shows "inflationary_on (in_field R) R f"
   using assms by (elim closure_operatorE)
 
 lemma idempotent_on_in_field_if_closure_operator:
   assumes "closure_operator R f"
   shows "idempotent_on (in_field R) R f"
   using assms by (elim closure_operatorE)
 
 
 end
diff --git a/thys/Transport/HOL_Basics/Orders/Functions/Order_Functions_Base.thy b/thys/Transport/HOL_Basics/Orders/Functions/Order_Functions_Base.thy
--- a/thys/Transport/HOL_Basics/Orders/Functions/Order_Functions_Base.thy
+++ b/thys/Transport/HOL_Basics/Orders/Functions/Order_Functions_Base.thy
@@ -1,445 +1,447 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Functions On Orders\<close>
 subsubsection \<open>Basics\<close>
 theory Order_Functions_Base
   imports
     Functions_Monotone
-    Restricted_Equality
+    Binary_Relations_Antisymmetric
+    Binary_Relations_Symmetric
+    Preorders
 begin
 
 subparagraph \<open>Bi-Relation\<close>
 
 definition "bi_related R x y \<equiv> R x y \<and> R y x"
 
 (*Note: we are not using (\<equiv>\<index>) as infix here because it would produce an ambiguous
 grammar whenever using a of the form "definition c \<equiv> t"*)
 bundle bi_related_syntax begin
 syntax
   "_bi_related" :: "'a \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool" ("(_) \<equiv>\<^bsub>(_)\<^esub> (_)" [51,51,51] 50)
 notation bi_related ("'(\<equiv>(\<^bsub>_\<^esub>)')")
 end
 bundle no_bi_related_syntax begin
 no_syntax
   "_bi_related" :: "'a \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> bool" ("(_) \<equiv>\<^bsub>(_)\<^esub> (_)" [51,51,51] 50)
 no_notation bi_related ("'(\<equiv>(\<^bsub>_\<^esub>)')")
 end
 unbundle bi_related_syntax
 translations
   "x \<equiv>\<^bsub>R\<^esub> y" \<rightleftharpoons> "CONST bi_related R x y"
 
 lemma bi_relatedI [intro]:
   assumes "R x y"
   and "R y x"
   shows "x \<equiv>\<^bsub>R\<^esub> y"
   unfolding bi_related_def using assms by blast
 
 lemma bi_relatedE [elim]:
   assumes "x \<equiv>\<^bsub>R\<^esub> y"
   obtains "R x y" "R y x"
   using assms unfolding bi_related_def by blast
 
 lemma symmetric_bi_related [iff]: "symmetric (\<equiv>\<^bsub>R\<^esub>)"
   by (intro symmetricI) blast
 
 lemma reflexive_bi_related_if_reflexive [intro]:
   assumes "reflexive R"
   shows "reflexive (\<equiv>\<^bsub>R\<^esub>)"
   using assms by (intro reflexiveI) (blast dest: reflexiveD)
 
 lemma transitive_bi_related_if_transitive [intro]:
   assumes "transitive R"
   shows "transitive (\<equiv>\<^bsub>R\<^esub>)"
   using assms by (intro transitiveI bi_relatedI) auto
 
 lemma mono_bi_related [iff]: "mono bi_related"
   by (intro monoI) blast
 
 lemma bi_related_if_le_rel_if_bi_related:
   assumes "x \<equiv>\<^bsub>R\<^esub> y"
   and "R \<le> S"
   shows "x \<equiv>\<^bsub>S\<^esub> y"
   using assms by blast
 
 lemma eq_if_bi_related_if_antisymmetric_on:
   assumes "antisymmetric_on P R"
   and "x \<equiv>\<^bsub>R\<^esub> y"
   and "P x" "P y"
   shows "x = y"
   using assms by (blast dest: antisymmetric_onD)
 
 lemma eq_if_bi_related_if_in_field_le_if_antisymmetric_on:
   assumes "antisymmetric_on P R"
   and "in_field R \<le> P"
   and "x \<equiv>\<^bsub>R\<^esub> y"
   shows "x = y"
   using assms by (intro eq_if_bi_related_if_antisymmetric_on) blast+
 
 lemma bi_related_le_eq_if_antisymmetric_on_in_field:
   assumes "antisymmetric_on (in_field R) R"
   shows "(\<equiv>\<^bsub>R\<^esub>) \<le> (=)"
   using assms
   by (intro le_relI eq_if_bi_related_if_in_field_le_if_antisymmetric_on) blast+
 
 lemma bi_related_if_all_rel_iff_if_reflexive_on:
   assumes "reflexive_on P R"
   and "\<And>z. P z \<Longrightarrow> R x z \<longleftrightarrow> R y z"
   and "P x" "P y"
   shows "x \<equiv>\<^bsub>R\<^esub> y"
   using assms by blast
 
 lemma bi_related_if_all_rel_iff_if_reflexive_on':
   assumes "reflexive_on P R"
   and "\<And>z. P z \<Longrightarrow> R z x \<longleftrightarrow> R z y"
   and "P x" "P y"
   shows "x \<equiv>\<^bsub>R\<^esub> y"
   using assms by blast
 
 corollary eq_if_all_rel_iff_if_antisymmetric_on_if_reflexive_on:
   assumes "reflexive_on P R" and "antisymmetric_on P R"
   and "\<And>z. P z \<Longrightarrow> R x z \<longleftrightarrow> R y z"
   and "P x" "P y"
   shows "x = y"
   using assms by (blast intro: eq_if_bi_related_if_antisymmetric_on
     bi_related_if_all_rel_iff_if_reflexive_on)
 
 corollary eq_if_all_rel_iff_if_antisymmetric_on_if_reflexive_on':
   assumes "reflexive_on P R" and "antisymmetric_on P R"
   and "\<And>z. P z \<Longrightarrow> R z x \<longleftrightarrow> R z y"
   and "P x" "P y"
   shows "x = y"
   using assms by (blast intro: eq_if_bi_related_if_antisymmetric_on
     bi_related_if_all_rel_iff_if_reflexive_on')
 
 
 subparagraph \<open>Inflationary\<close>
 
 consts inflationary_on :: "'a \<Rightarrow> ('b \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> 'b) \<Rightarrow> bool"
 
 overloading
   inflationary_on_pred \<equiv> "inflationary_on ::
     ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'a) \<Rightarrow> bool"
 begin
   text \<open>Often also called "extensive".\<close>
   definition "inflationary_on_pred P (R :: 'a \<Rightarrow> 'a \<Rightarrow> _) f \<equiv> \<forall>x. P x \<longrightarrow> R x (f x)"
 end
 
 lemma inflationary_onI [intro]:
   assumes "\<And>x. P x \<Longrightarrow> R x (f x)"
   shows "inflationary_on P R f"
   unfolding inflationary_on_pred_def using assms by blast
 
 lemma inflationary_onD [dest]:
   assumes "inflationary_on P R f"
   and "P x"
   shows "R x (f x)"
   using assms unfolding inflationary_on_pred_def by blast
 
 lemma inflationary_on_eq_dep_mono_wrt_pred: "inflationary_on = dep_mono_wrt_pred"
   by blast
 
 lemma antimono_inflationary_on_pred [iff]:
   "antimono (\<lambda>(P :: 'a \<Rightarrow> bool). inflationary_on P (R :: 'a \<Rightarrow> _))"
   by (intro antimonoI) auto
 
 lemma inflationary_on_if_le_pred_if_inflationary_on:
   fixes P P' :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "inflationary_on P R f"
   and "P' \<le> P"
   shows "inflationary_on P' R f"
   using assms by blast
 
 lemma mono_inflationary_on_rel [iff]:
   "mono (\<lambda>(R :: 'a \<Rightarrow> _). inflationary_on (P :: 'a \<Rightarrow> bool) R)"
   by (intro monoI) auto
 
 lemma inflationary_on_if_le_rel_if_inflationary_on:
   assumes "inflationary_on P R f"
   and "\<And>x. P x \<Longrightarrow> R x (f x) \<Longrightarrow> R' x (f x)"
   shows "inflationary_on P R' f"
   using assms by blast
 
 lemma le_in_dom_if_inflationary_on:
   assumes "inflationary_on P R f"
   shows "P \<le> in_dom R"
   using assms by blast
 
 lemma inflationary_on_sup_eq [simp]:
   "(inflationary_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> _) \<Rightarrow> _) ((P :: 'a \<Rightarrow> bool) \<squnion> Q)
   = inflationary_on P \<sqinter> inflationary_on Q"
   by (intro ext iffI inflationary_onI)
     (auto intro: inflationary_on_if_le_pred_if_inflationary_on)
 
 
-definition "inflationary (R :: 'a \<Rightarrow> _) f \<equiv> inflationary_on (\<top> :: 'a \<Rightarrow> bool) R f"
+definition "(inflationary :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> inflationary_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma inflationary_eq_inflationary_on:
-  "inflationary (R :: 'a \<Rightarrow> _) f = inflationary_on (\<top> :: 'a \<Rightarrow> bool) R f"
+  "(inflationary :: ('a \<Rightarrow> _) \<Rightarrow> _) = inflationary_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding inflationary_def ..
 
 lemma inflationaryI [intro]:
   assumes "\<And>x. R x (f x)"
   shows "inflationary R f"
   unfolding inflationary_eq_inflationary_on using assms
   by (intro inflationary_onI)
 
 lemma inflationaryD:
   assumes "inflationary R f"
   shows "R x (f x)"
   using assms unfolding inflationary_eq_inflationary_on by auto
 
 lemma inflationary_on_if_inflationary:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "inflationary R f"
   shows "inflationary_on P R f"
   using assms by (intro inflationary_onI) (blast dest: inflationaryD)
 
 lemma inflationary_eq_dep_mono_wrt_pred: "inflationary = dep_mono_wrt_pred \<top>"
   by (intro ext) (fastforce dest: inflationaryD)
 
 
 subparagraph \<open>Deflationary\<close>
 
 definition "deflationary_on P R \<equiv> inflationary_on P R\<inverse>"
 
 lemma deflationary_on_eq_inflationary_on_rel_inv:
   "deflationary_on P R = inflationary_on P R\<inverse>"
   unfolding deflationary_on_def ..
 
 declare deflationary_on_eq_inflationary_on_rel_inv[symmetric, simp]
 
 corollary deflationary_on_rel_inv_eq_inflationary_on [simp]:
   "deflationary_on P R\<inverse> = inflationary_on P R"
   unfolding deflationary_on_eq_inflationary_on_rel_inv by simp
 
 lemma deflationary_onI [intro]:
   assumes "\<And>x. P x \<Longrightarrow> R (f x) x"
   shows "deflationary_on P R f"
   unfolding deflationary_on_eq_inflationary_on_rel_inv using assms
   by (intro inflationary_onI rel_invI)
 
 lemma deflationary_onD [dest]:
   assumes "deflationary_on P R f"
   and "P x"
   shows "R (f x) x"
   using assms unfolding deflationary_on_eq_inflationary_on_rel_inv by blast
 
 lemma deflationary_on_eq_dep_mono_wrt_pred_rel_inv:
   "deflationary_on P R = ([x \<Colon> P] \<Rrightarrow>\<^sub>m R\<inverse> x)"
   by blast
 
 lemma antimono_deflationary_on_pred [iff]:
   "antimono (\<lambda>(P :: 'a \<Rightarrow> bool). deflationary_on P (R :: 'a \<Rightarrow> _))"
   by (intro antimonoI) auto
 
 lemma deflationary_on_if_le_pred_if_deflationary_on:
   fixes P P' :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "deflationary_on P R f"
   and "P' \<le> P"
   shows "deflationary_on P' R f"
   using assms by blast
 
 lemma mono_deflationary_on_rel [iff]:
   "mono (\<lambda>(R :: 'a \<Rightarrow> _). deflationary_on (P :: 'a \<Rightarrow> bool) R)"
   by (intro monoI) auto
 
 lemma deflationary_on_if_le_rel_if_deflationary_on:
   assumes "deflationary_on P R f"
   and "\<And>x. P x \<Longrightarrow> R (f x) x \<Longrightarrow> R' (f x) x"
   shows "deflationary_on P R' f"
   using assms by auto
 
 lemma le_in_dom_if_deflationary_on:
   assumes "deflationary_on P R f"
   shows "P \<le> in_codom R"
   using assms by blast
 
 lemma deflationary_on_sup_eq [simp]:
   "(deflationary_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> _) \<Rightarrow> _) ((P :: 'a \<Rightarrow> bool) \<squnion> Q)
   = deflationary_on P \<sqinter> deflationary_on Q"
   unfolding deflationary_on_eq_inflationary_on_rel_inv by auto
 
-definition "deflationary R (f :: 'a \<Rightarrow> _) \<equiv> deflationary_on (\<top> :: 'a \<Rightarrow> bool) R f"
+definition "(deflationary :: ('a \<Rightarrow> _) \<Rightarrow> _) \<equiv> deflationary_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma deflationary_eq_deflationary_on:
-  "deflationary R (f :: 'a \<Rightarrow> _) = deflationary_on (\<top> :: 'a \<Rightarrow> bool) R f"
+  "(deflationary :: ('a \<Rightarrow> _) \<Rightarrow> _) = deflationary_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding deflationary_def ..
 
 lemma deflationaryI [intro]:
   assumes "\<And>x. R (f x) x"
   shows "deflationary R f"
   unfolding deflationary_eq_deflationary_on using assms by (intro deflationary_onI)
 
 lemma deflationaryD:
   assumes "deflationary R f"
   shows "R (f x) x"
   using assms unfolding deflationary_eq_deflationary_on by auto
 
 lemma deflationary_on_if_deflationary:
   fixes P :: "'a \<Rightarrow> bool" and f :: "'a \<Rightarrow> _"
   assumes "deflationary R f"
   shows "deflationary_on P R f"
   using assms by (intro deflationary_onI) (blast dest: deflationaryD)
 
 lemma deflationary_eq_dep_mono_wrt_pred_rel_inv:
   "deflationary R = dep_mono_wrt_pred \<top> R\<inverse>"
   by (intro ext) (fastforce dest: deflationaryD)
 
 
 subparagraph \<open>Relational Equivalence\<close>
 
 definition "rel_equivalence_on \<equiv> inflationary_on \<sqinter> deflationary_on"
 
 lemma rel_equivalence_on_eq:
   "rel_equivalence_on = inflationary_on \<sqinter> deflationary_on"
   unfolding rel_equivalence_on_def ..
 
 lemma rel_equivalence_onI [intro]:
   assumes "inflationary_on P R f"
   and "deflationary_on P R f"
   shows "rel_equivalence_on P R f"
   unfolding rel_equivalence_on_eq using assms by auto
 
 lemma rel_equivalence_onE [elim]:
   assumes "rel_equivalence_on P R f"
   obtains "inflationary_on P R f" "deflationary_on P R f"
   using assms unfolding rel_equivalence_on_eq by auto
 
 lemma rel_equivalence_on_eq_dep_mono_wrt_pred_inf:
   "rel_equivalence_on P R = dep_mono_wrt_pred P (R \<sqinter> R\<inverse>)"
   by (intro ext) fastforce
 
 lemma bi_related_if_rel_equivalence_on:
   assumes "rel_equivalence_on P R f"
   and "P x"
   shows "x \<equiv>\<^bsub>R\<^esub> f x"
   using assms by (intro bi_relatedI) auto
 
 lemma rel_equivalence_on_if_all_bi_related:
   assumes "\<And>x. P x \<Longrightarrow> x \<equiv>\<^bsub>R\<^esub> f x"
   shows "rel_equivalence_on P R f"
   using assms by auto
 
 corollary rel_equivalence_on_iff_all_bi_related:
   "rel_equivalence_on P R f \<longleftrightarrow> (\<forall>x. P x \<longrightarrow> x \<equiv>\<^bsub>R\<^esub> f x)"
   using rel_equivalence_on_if_all_bi_related bi_related_if_rel_equivalence_on
   by blast
 
 lemma rel_equivalence_onD [dest]:
   assumes "rel_equivalence_on P R f"
   and "P x"
   shows "R x (f x)" "R (f x) x"
   using assms by (auto dest: bi_related_if_rel_equivalence_on)
 
 lemma rel_equivalence_on_rel_inv_eq_rel_equivalence_on [simp]:
   "rel_equivalence_on P R\<inverse> = rel_equivalence_on P R"
   by (intro ext) fastforce
 
 lemma antimono_rel_equivalence_on_pred [iff]:
   "antimono (\<lambda>(P :: 'a \<Rightarrow> bool). rel_equivalence_on P (R :: 'a \<Rightarrow> _))"
   by (intro antimonoI) blast
 
 lemma rel_equivalence_on_if_le_pred_if_rel_equivalence_on:
   fixes P P' :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "rel_equivalence_on P R f"
   and "P' \<le> P"
   shows "rel_equivalence_on P' R f"
   using assms by blast
 
 lemma rel_equivalence_on_sup_eq [simp]:
   "(rel_equivalence_on :: ('a \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> _) \<Rightarrow> _) ((P :: 'a \<Rightarrow> bool) \<squnion> Q)
   = rel_equivalence_on P \<sqinter> rel_equivalence_on Q"
   unfolding rel_equivalence_on_eq by (simp add: inf_aci)
 
 lemma in_codom_eq_in_dom_if_rel_equivalence_on_in_field:
   assumes "rel_equivalence_on (in_field R) R f"
   shows "in_codom R = in_dom R"
   using assms by (intro ext) blast
 
 lemma reflexive_on_if_transitive_on_if_mon_wrt_pred_if_rel_equivalence_on:
   assumes "rel_equivalence_on P R f"
   and "([P] \<Rrightarrow>\<^sub>m P) f"
   and "transitive_on P R"
   shows "reflexive_on P R"
   using assms by (blast dest: transitive_onD)
 
 lemma inflationary_on_eq_rel_equivalence_on_if_symmetric:
   assumes "symmetric R"
   shows "inflationary_on P R = rel_equivalence_on P R"
   using assms
   by (simp add: rel_equivalence_on_eq deflationary_on_eq_inflationary_on_rel_inv)
 
 lemma deflationary_on_eq_rel_equivalence_on_if_symmetric:
   assumes "symmetric R"
   shows "deflationary_on P R = rel_equivalence_on P R"
   using assms
   by (simp add: deflationary_on_eq_inflationary_on_rel_inv rel_equivalence_on_eq)
 
 
-definition "rel_equivalence (R :: 'a \<Rightarrow> _) f \<equiv> rel_equivalence_on (\<top> :: 'a \<Rightarrow> bool) R f"
+definition "(rel_equivalence :: ('a \<Rightarrow> _) \<Rightarrow> _ ) \<equiv> rel_equivalence_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma rel_equivalence_eq_rel_equivalence_on:
-  "rel_equivalence (R :: 'a \<Rightarrow> _) f = rel_equivalence_on (\<top> :: 'a \<Rightarrow> bool) R f"
+  "(rel_equivalence :: ('a \<Rightarrow> _) \<Rightarrow> _ ) = rel_equivalence_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding rel_equivalence_def ..
 
 lemma rel_equivalenceI [intro]:
   assumes "inflationary R f"
   and "deflationary R f"
   shows "rel_equivalence R f"
   unfolding rel_equivalence_eq_rel_equivalence_on using assms
   by (intro rel_equivalence_onI)
   (auto dest: inflationary_on_if_inflationary deflationary_on_if_deflationary)
 
 lemma rel_equivalenceE [elim]:
   assumes "rel_equivalence R f"
   obtains "inflationary R f" "deflationary R f"
   using assms unfolding rel_equivalence_eq_rel_equivalence_on
   by (elim rel_equivalence_onE)
   (simp only: inflationary_eq_inflationary_on deflationary_eq_deflationary_on)
 
 lemma inflationary_if_rel_equivalence:
   assumes "rel_equivalence R f"
   shows "inflationary R f"
   using assms by (elim rel_equivalenceE)
 
 lemma deflationary_if_rel_equivalence:
   assumes "rel_equivalence R f"
   shows "deflationary R f"
   using assms by (elim rel_equivalenceE)
 
 lemma rel_equivalence_on_if_rel_equivalence:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "rel_equivalence R f"
   shows "rel_equivalence_on P R f"
   using assms by (intro rel_equivalence_onI)
   (auto dest: inflationary_on_if_inflationary deflationary_on_if_deflationary)
 
 lemma bi_related_if_rel_equivalence:
   assumes "rel_equivalence R f"
   shows "x \<equiv>\<^bsub>R\<^esub> f x"
   using assms by (intro bi_relatedI) (auto dest: inflationaryD deflationaryD)
 
 lemma rel_equivalence_if_all_bi_related:
   assumes "\<And>x. x \<equiv>\<^bsub>R\<^esub> f x"
   shows "rel_equivalence R f"
   using assms by auto
 
 lemma rel_equivalenceD:
   assumes "rel_equivalence R f"
   shows "R x (f x)" "R (f x) x"
   using assms by (auto dest: bi_related_if_rel_equivalence)
 
 lemma reflexive_on_in_field_if_transitive_if_rel_equivalence_on:
   assumes "rel_equivalence_on (in_field R) R f"
   and "transitive R"
   shows "reflexive_on (in_field R) R"
   using assms by (intro reflexive_onI) blast
 
 corollary preorder_on_in_field_if_transitive_if_rel_equivalence_on:
   assumes "rel_equivalence_on (in_field R) R f"
   and "transitive R"
   shows "preorder_on (in_field R) R"
   using assms reflexive_on_in_field_if_transitive_if_rel_equivalence_on
-  using assms by blast
+  by blast
 
 
 end
diff --git a/thys/Transport/HOL_Basics/Orders/Functors/Order_Functors_Base.thy b/thys/Transport/HOL_Basics/Orders/Functors/Order_Functors_Base.thy
--- a/thys/Transport/HOL_Basics/Orders/Functors/Order_Functors_Base.thy
+++ b/thys/Transport/HOL_Basics/Orders/Functors/Order_Functors_Base.thy
@@ -1,196 +1,196 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Order Functors\<close>
 subsubsection \<open>Basic Setup and Results\<close>
 theory Order_Functors_Base
   imports
     Functions_Inverse
     Order_Functions_Base
 begin
 
 text \<open>In the following, we do not add any assumptions to our locales but rather
 add them as needed to the theorem statements. This allows consumers to
 state preciser results; particularly, the development of Transport depends
 on this setup.\<close>
 
 locale orders =
   fixes L :: "'a \<Rightarrow> 'b \<Rightarrow> bool"
   and R :: "'c \<Rightarrow> 'd \<Rightarrow> bool"
 begin
 
 notation L (infix "\<le>\<^bsub>L\<^esub>" 50)
 notation R (infix "\<le>\<^bsub>R\<^esub>" 50)
 
 text\<open>We call @{term "(\<le>\<^bsub>L\<^esub>)"} the \<^emph>\<open>left relation\<close> and @{term "(\<le>\<^bsub>R\<^esub>)"} the
 \<^emph>\<open>right relation\<close>.\<close>
 
 abbreviation (input) "ge_left \<equiv> (\<le>\<^bsub>L\<^esub>)\<inverse>"
 notation ge_left (infix "\<ge>\<^bsub>L\<^esub>" 50)
 
 abbreviation (input) "ge_right \<equiv> (\<le>\<^bsub>R\<^esub>)\<inverse>"
 notation ge_right (infix "\<ge>\<^bsub>R\<^esub>" 50)
 
 end
 
 text \<open>Homogeneous orders\<close>
 locale hom_orders = orders L R
   for L :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
   and R :: "'b \<Rightarrow> 'b \<Rightarrow> bool"
 
 locale order_functor = hom_orders L R
   for L :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
   and R :: "'b \<Rightarrow> 'b \<Rightarrow> bool"
   and l :: "'a \<Rightarrow> 'b"
 begin
 
 lemma left_right_rel_left_self_if_reflexive_on_left_if_mono_left:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "reflexive_on P (\<le>\<^bsub>L\<^esub>)"
   and "P x"
   shows "l x \<le>\<^bsub>R\<^esub> l x"
   using assms by blast
 
 lemma left_right_rel_left_self_if_reflexive_on_in_dom_right_if_mono_left:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "reflexive_on (in_dom (\<le>\<^bsub>R\<^esub>)) (\<le>\<^bsub>R\<^esub>)"
   and "in_dom (\<le>\<^bsub>L\<^esub>) x"
   shows "l x \<le>\<^bsub>R\<^esub> l x"
   using assms by blast
 
 lemma left_right_rel_left_self_if_reflexive_on_in_codom_right_if_mono_left:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "reflexive_on (in_codom (\<le>\<^bsub>R\<^esub>)) (\<le>\<^bsub>R\<^esub>)"
   and "in_codom (\<le>\<^bsub>L\<^esub>) x"
   shows "l x \<le>\<^bsub>R\<^esub> l x"
   using assms by blast
 
 lemma left_right_rel_left_self_if_reflexive_on_in_field_right_if_mono_left:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "reflexive_on (in_field (\<le>\<^bsub>R\<^esub>)) (\<le>\<^bsub>R\<^esub>)"
   and "in_field (\<le>\<^bsub>L\<^esub>) x"
   shows "l x \<le>\<^bsub>R\<^esub> l x"
   using assms by blast
 
 lemma mono_wrt_rel_left_if_reflexive_on_if_le_eq_if_mono_wrt_in_field:
   assumes "([in_field (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m P) l"
   and "(\<le>\<^bsub>L\<^esub>) \<le> (=)"
   and "reflexive_on P (\<le>\<^bsub>R\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   using assms by (intro dep_mono_wrt_relI) auto
 
 end
 
 
 locale order_functors = order_functor L R l + flip_of : order_functor R L r
   for L R l r
 begin
 
 text \<open>We call the composition \<^term>\<open>r \<circ> l\<close> the \<^emph>\<open>unit\<close>
 and the term \<^term>\<open>l \<circ> r\<close> the \<^emph>\<open>counit\<close> of the order functors pair.
 This is terminology is borrowed from category theory - the functors
 are an \<^emph>\<open>adjoint\<close>.\<close>
 
 definition "unit \<equiv> r \<circ> l"
 
 notation unit ("\<eta>")
 
 lemma unit_eq_comp: "\<eta> = r \<circ> l" unfolding unit_def by simp
 
 lemma unit_eq [simp]: "\<eta> x = r (l x)" by (simp add: unit_eq_comp)
 
 context
 begin
 
 text \<open>Note that by flipping the roles of the left and rights functors,
 we obtain a flipped interpretation of @{locale order_functors}.
 In many cases, this allows us to obtain symmetric definitions and theorems for free.
 As such, in many cases, we do we do not explicitly state those free results but
 users can obtain them as needed by creating said flipped interpretation.\<close>
 
 interpretation flip : order_functors R L r l .
 
 definition "counit \<equiv> flip.unit"
 
 notation counit ("\<epsilon>")
 
 lemma counit_eq_comp: "\<epsilon> = l \<circ> r" unfolding counit_def flip.unit_def by simp
 
 lemma counit_eq [simp]: "\<epsilon> x = l (r x)" by (simp add: counit_eq_comp)
 
 end
 
 context
 begin
 
 interpretation flip : order_functors R L r l .
 
 lemma flip_counit_eq_unit: "flip.counit = \<eta>"
   by (intro ext) simp
 
 lemma flip_unit_eq_counit: "flip.unit = \<epsilon>"
   by (intro ext) simp
 
 lemma inflationary_on_unit_if_left_rel_right_if_left_right_relI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "reflexive_on P (\<le>\<^bsub>L\<^esub>)"
   and "\<And>x y. P x \<Longrightarrow> l x \<le>\<^bsub>R\<^esub> y \<Longrightarrow> x \<le>\<^bsub>L\<^esub> r y"
   shows "inflationary_on P (\<le>\<^bsub>L\<^esub>) \<eta>"
-  using assms by (intro inflationary_onI) auto
+  using assms by (intro inflationary_onI) fastforce
 
 lemma deflationary_on_unit_if_right_left_rel_if_right_rel_leftI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "reflexive_on P (\<le>\<^bsub>L\<^esub>)"
   and "\<And>x y. P x \<Longrightarrow> y \<le>\<^bsub>R\<^esub> l x \<Longrightarrow> r y \<le>\<^bsub>L\<^esub> x"
   shows "deflationary_on P (\<le>\<^bsub>L\<^esub>) \<eta>"
-  using assms by (intro deflationary_onI) auto
+  using assms by (intro deflationary_onI) fastforce
 
 context
   fixes P :: "'a \<Rightarrow> bool"
 begin
 
 lemma rel_equivalence_on_unit_iff_inflationary_on_if_inverse_on:
   assumes "inverse_on P l r"
   shows "rel_equivalence_on P (\<le>\<^bsub>L\<^esub>) \<eta> \<longleftrightarrow> inflationary_on P (\<le>\<^bsub>L\<^esub>) \<eta>"
   using assms by (intro iffI rel_equivalence_onI inflationary_onI deflationary_onI)
   (auto dest!: inverse_onD)
 
 lemma reflexive_on_left_if_inflationary_on_unit_if_inverse_on:
   assumes "inverse_on P l r"
   and "inflationary_on P (\<le>\<^bsub>L\<^esub>) \<eta>"
   shows "reflexive_on P (\<le>\<^bsub>L\<^esub>)"
   using assms by (intro reflexive_onI) (auto dest!: inverse_onD)
 
 lemma rel_equivalence_on_unit_if_reflexive_on_if_inverse_on:
   assumes "inverse_on P l r"
   and "reflexive_on P (\<le>\<^bsub>L\<^esub>)"
   shows "rel_equivalence_on P (\<le>\<^bsub>L\<^esub>) \<eta>"
   using assms by (intro rel_equivalence_onI inflationary_onI deflationary_onI)
   (auto dest!: inverse_onD)
 
 end
 
 corollary rel_equivalence_on_unit_iff_reflexive_on_if_inverse_on:
   fixes P :: "'a \<Rightarrow> bool"
   assumes "inverse_on P l r"
   shows "rel_equivalence_on P (\<le>\<^bsub>L\<^esub>) \<eta> \<longleftrightarrow> reflexive_on P (\<le>\<^bsub>L\<^esub>)"
   using assms reflexive_on_left_if_inflationary_on_unit_if_inverse_on
     rel_equivalence_on_unit_if_reflexive_on_if_inverse_on
   by (intro iffI) auto
 
 end
 
 
 text \<open>Here is an example of a free theorem.\<close>
 
 notepad
 begin
   interpret flip : order_functors R L r l
     rewrites "flip.unit \<equiv> \<epsilon>" by (simp only: flip_unit_eq_counit)
   have "\<lbrakk>((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r; reflexive_on P (\<le>\<^bsub>R\<^esub>); \<And>x y. \<lbrakk>P x; r x \<le>\<^bsub>L\<^esub> y\<rbrakk> \<Longrightarrow> x \<le>\<^bsub>R\<^esub> l y\<rbrakk>
       \<Longrightarrow> inflationary_on P (\<le>\<^bsub>R\<^esub>) \<epsilon>" for P
     by (fact flip.inflationary_on_unit_if_left_rel_right_if_left_right_relI)
 end
 
 end
 
 
 end
diff --git a/thys/Transport/HOL_Basics/Orders/Partial_Equivalence_Relations.thy b/thys/Transport/HOL_Basics/Orders/Partial_Equivalence_Relations.thy
--- a/thys/Transport/HOL_Basics/Orders/Partial_Equivalence_Relations.thy
+++ b/thys/Transport/HOL_Basics/Orders/Partial_Equivalence_Relations.thy
@@ -1,115 +1,116 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Partial Equivalence Relations\<close>
 theory Partial_Equivalence_Relations
   imports
     Binary_Relations_Symmetric
     Preorders
 begin
 
-definition "partial_equivalence_rel_on P R \<equiv> transitive_on P R \<and> symmetric_on P R"
+definition "partial_equivalence_rel_on \<equiv> transitive_on \<sqinter> symmetric_on"
 
 lemma partial_equivalence_rel_onI [intro]:
   assumes "transitive_on P R"
   and "symmetric_on P R"
   shows "partial_equivalence_rel_on P R"
-  unfolding partial_equivalence_rel_on_def using assms by blast
+  unfolding partial_equivalence_rel_on_def using assms by auto
 
 lemma partial_equivalence_rel_onE [elim]:
   assumes "partial_equivalence_rel_on P R"
   obtains "transitive_on P R" "symmetric_on P R"
-  using assms unfolding partial_equivalence_rel_on_def by blast
+  using assms unfolding partial_equivalence_rel_on_def by auto
 
 lemma partial_equivalence_rel_on_rel_self_if_rel_dom:
   assumes "partial_equivalence_rel_on (P :: 'a \<Rightarrow> bool) (R :: 'a \<Rightarrow> 'a \<Rightarrow> bool)"
   and "P x" "P y"
   and "R x y"
   shows "R x x"
   using assms by (blast dest: symmetric_onD transitive_onD)
 
 lemma partial_equivalence_rel_on_rel_self_if_rel_codom:
   assumes "partial_equivalence_rel_on (P :: 'a \<Rightarrow> bool) (R :: 'a \<Rightarrow> 'a \<Rightarrow> bool)"
   and "P x" "P y"
   and "R x y"
   shows "R y y"
   using assms by (blast dest: symmetric_onD transitive_onD)
 
 lemma partial_equivalence_rel_on_rel_inv_iff_partial_equivalence_rel_on [iff]:
   "partial_equivalence_rel_on P R\<inverse> \<longleftrightarrow> partial_equivalence_rel_on (P :: 'a \<Rightarrow> bool) (R :: 'a \<Rightarrow> _)"
   by blast
 
-definition "partial_equivalence_rel (R :: 'a \<Rightarrow> _) \<equiv> partial_equivalence_rel_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(partial_equivalence_rel :: ('a \<Rightarrow> _) \<Rightarrow> bool) \<equiv>
+  partial_equivalence_rel_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma partial_equivalence_rel_eq_partial_equivalence_rel_on:
-  "partial_equivalence_rel (R :: 'a \<Rightarrow> _) = partial_equivalence_rel_on (\<top> :: 'a \<Rightarrow> bool) R"
+  "(partial_equivalence_rel :: ('a \<Rightarrow> _) \<Rightarrow> bool) = partial_equivalence_rel_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding partial_equivalence_rel_def ..
 
 lemma partial_equivalence_relI [intro]:
   assumes "transitive R"
   and "symmetric R"
   shows "partial_equivalence_rel R"
   unfolding partial_equivalence_rel_eq_partial_equivalence_rel_on using assms
   by (intro partial_equivalence_rel_onI transitive_on_if_transitive symmetric_on_if_symmetric)
 
 lemma reflexive_on_in_field_if_partial_equivalence_rel:
   assumes "partial_equivalence_rel R"
   shows "reflexive_on (in_field R) R"
   using assms unfolding partial_equivalence_rel_eq_partial_equivalence_rel_on
   by (intro reflexive_onI) (blast
     intro: top1I partial_equivalence_rel_on_rel_self_if_rel_dom
     partial_equivalence_rel_on_rel_self_if_rel_codom)
 
 lemma partial_equivalence_relE [elim]:
   assumes "partial_equivalence_rel R"
   obtains "preorder_on (in_field R) R" "symmetric R"
   using assms unfolding partial_equivalence_rel_eq_partial_equivalence_rel_on
   by (elim partial_equivalence_rel_onE)
   (auto intro: reflexive_on_in_field_if_partial_equivalence_rel
     simp flip: transitive_eq_transitive_on symmetric_eq_symmetric_on)
 
 lemma partial_equivalence_rel_on_if_partial_equivalence_rel:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "partial_equivalence_rel R"
   shows "partial_equivalence_rel_on P R"
   using assms by (elim partial_equivalence_relE preorder_on_in_fieldE)
   (intro partial_equivalence_rel_onI transitive_on_if_transitive
     symmetric_on_if_symmetric)
 
 lemma partial_equivalence_rel_rel_inv_iff_partial_equivalence_rel [iff]:
   "partial_equivalence_rel R\<inverse> \<longleftrightarrow> partial_equivalence_rel R"
   unfolding partial_equivalence_rel_eq_partial_equivalence_rel_on by blast
 
 corollary in_codom_eq_in_dom_if_partial_equivalence_rel:
   assumes "partial_equivalence_rel R"
   shows "in_codom R = in_dom R"
   using assms reflexive_on_in_field_if_partial_equivalence_rel
     in_codom_eq_in_dom_if_reflexive_on_in_field
   by auto
 
 lemma partial_equivalence_rel_rel_comp_self_eq_self:
   assumes "partial_equivalence_rel R"
   shows "(R \<circ>\<circ> R) = R"
   using assms by (intro ext) (blast dest: symmetricD)
 
 lemma partial_equivalence_rel_if_partial_equivalence_rel_on_in_field:
   assumes "partial_equivalence_rel_on (in_field R) R"
   shows "partial_equivalence_rel R"
   using assms by (intro partial_equivalence_relI)
   (auto intro: transitive_if_transitive_on_in_field symmetric_if_symmetric_on_in_field)
 
 corollary partial_equivalence_rel_on_in_field_iff_partial_equivalence_rel [iff]:
   "partial_equivalence_rel_on (in_field R) R \<longleftrightarrow> partial_equivalence_rel R"
   using partial_equivalence_rel_if_partial_equivalence_rel_on_in_field
     partial_equivalence_rel_on_if_partial_equivalence_rel
   by blast
 
 
 paragraph \<open>Instantiations\<close>
 
 lemma partial_equivalence_rel_eq: "partial_equivalence_rel (=)"
   using transitive_eq symmetric_eq by (rule partial_equivalence_relI)
 
 lemma partial_equivalence_rel_top: "partial_equivalence_rel \<top>"
   using transitive_top symmetric_top by (rule partial_equivalence_relI)
 
 
 end
diff --git a/thys/Transport/HOL_Basics/Orders/Partial_Orders.thy b/thys/Transport/HOL_Basics/Orders/Partial_Orders.thy
--- a/thys/Transport/HOL_Basics/Orders/Partial_Orders.thy
+++ b/thys/Transport/HOL_Basics/Orders/Partial_Orders.thy
@@ -1,61 +1,61 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Partial Orders\<close>
 theory Partial_Orders
   imports
     Binary_Relations_Antisymmetric
     Preorders
 begin
 
-definition "partial_order_on P R \<equiv> preorder_on P R \<and> antisymmetric_on P R"
+definition "partial_order_on \<equiv> preorder_on \<sqinter> antisymmetric_on"
 
 lemma partial_order_onI [intro]:
   assumes "preorder_on P R"
   and "antisymmetric_on P R"
   shows "partial_order_on P R"
-  unfolding partial_order_on_def using assms by blast
+  unfolding partial_order_on_def using assms by auto
 
 lemma partial_order_onE [elim]:
   assumes "partial_order_on P R"
   obtains "preorder_on P R" "antisymmetric_on P R"
-  using assms unfolding partial_order_on_def by blast
+  using assms unfolding partial_order_on_def by auto
 
 lemma transitive_if_partial_order_on_in_field:
   assumes "partial_order_on (in_field R) R"
   shows "transitive R"
   using assms by (elim partial_order_onE) (rule transitive_if_preorder_on_in_field)
 
 lemma antisymmetric_if_partial_order_on_in_field:
   assumes "partial_order_on (in_field R) R"
   shows "antisymmetric R"
   using assms by (elim partial_order_onE)
-    (rule antisymmetric_if_antisymmetric_on_in_field)
+  (rule antisymmetric_if_antisymmetric_on_in_field)
 
-definition "partial_order (R :: 'a \<Rightarrow> _) \<equiv> partial_order_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(partial_order :: ('a \<Rightarrow> _) \<Rightarrow> bool) \<equiv> partial_order_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma partial_order_eq_partial_order_on:
-  "partial_order (R :: 'a \<Rightarrow> _) = partial_order_on (\<top> :: 'a \<Rightarrow> bool) R"
+  "(partial_order :: ('a \<Rightarrow> _) \<Rightarrow> bool) = partial_order_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding partial_order_def ..
 
 lemma partial_orderI [intro]:
   assumes "preorder R"
   and "antisymmetric R"
   shows "partial_order R"
   unfolding partial_order_eq_partial_order_on using assms
   by (intro partial_order_onI preorder_on_if_preorder antisymmetric_on_if_antisymmetric)
 
 lemma partial_orderE [elim]:
   assumes "partial_order R"
   obtains "preorder R" "antisymmetric R"
   using assms unfolding partial_order_eq_partial_order_on
   by (elim partial_order_onE)
   (simp only: preorder_eq_preorder_on antisymmetric_eq_antisymmetric_on)
 
 lemma partial_order_on_if_partial_order:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "partial_order R"
   shows "partial_order_on P R"
   using assms by (elim partial_orderE)
   (intro partial_order_onI preorder_on_if_preorder antisymmetric_on_if_antisymmetric)
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/HOL_Basics/Orders/Preorders.thy b/thys/Transport/HOL_Basics/Orders/Preorders.thy
--- a/thys/Transport/HOL_Basics/Orders/Preorders.thy
+++ b/thys/Transport/HOL_Basics/Orders/Preorders.thy
@@ -1,94 +1,94 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Preorders\<close>
 theory Preorders
   imports
     Binary_Relations_Reflexive
     Binary_Relations_Transitive
 begin
 
-definition "preorder_on P R \<equiv> reflexive_on P R \<and> transitive_on P R"
+definition "preorder_on \<equiv> reflexive_on \<sqinter> transitive_on"
 
 lemma preorder_onI [intro]:
   assumes "reflexive_on P R"
   and "transitive_on P R"
   shows "preorder_on P R"
-  unfolding preorder_on_def using assms by blast
+  unfolding preorder_on_def using assms by auto
 
 lemma preorder_onE [elim]:
   assumes "preorder_on P R"
   obtains "reflexive_on P R" "transitive_on P R"
-  using assms unfolding preorder_on_def by blast
+  using assms unfolding preorder_on_def by auto
 
 lemma reflexive_on_if_preorder_on:
   assumes "preorder_on P R"
   shows "reflexive_on P R"
   using assms by (elim preorder_onE)
 
 lemma transitive_on_if_preorder_on:
   assumes "preorder_on P R"
   shows "transitive_on P R"
   using assms by (elim preorder_onE)
 
 lemma transitive_if_preorder_on_in_field:
   assumes "preorder_on (in_field R) R"
   shows "transitive R"
   using assms by (elim preorder_onE) (rule transitive_if_transitive_on_in_field)
 
 corollary preorder_on_in_fieldE [elim]:
   assumes "preorder_on (in_field R) R"
   obtains "reflexive_on (in_field R) R" "transitive R"
   using assms
   by (blast dest: reflexive_on_if_preorder_on transitive_if_preorder_on_in_field)
 
 lemma preorder_on_rel_inv_if_preorder_on [iff]:
   "preorder_on P R\<inverse> \<longleftrightarrow> preorder_on (P :: 'a \<Rightarrow> bool) (R :: 'a \<Rightarrow> _)"
   by auto
 
 lemma rel_if_all_rel_if_rel_if_reflexive_on:
   assumes "reflexive_on P R"
   and "\<And>z. P z \<Longrightarrow> R x z \<Longrightarrow> R y z"
   and "P x"
   shows "R y x"
   using assms by blast
 
 lemma rel_if_all_rel_if_rel_if_reflexive_on':
   assumes "reflexive_on P R"
   and "\<And>z. P z \<Longrightarrow> R z x \<Longrightarrow> R z y"
   and "P x"
   shows "R x y"
   using assms by blast
 
-definition "preorder (R :: 'a \<Rightarrow> _) \<equiv> preorder_on (\<top> :: 'a \<Rightarrow> bool) R"
+definition "(preorder :: ('a \<Rightarrow> _) \<Rightarrow> bool) \<equiv> preorder_on (\<top> :: 'a \<Rightarrow> bool)"
 
 lemma preorder_eq_preorder_on:
-  "preorder (R :: 'a \<Rightarrow> _) = preorder_on (\<top> :: 'a \<Rightarrow> bool) R"
+  "(preorder :: ('a \<Rightarrow> _) \<Rightarrow> bool) = preorder_on (\<top> :: 'a \<Rightarrow> bool)"
   unfolding preorder_def ..
 
 lemma preorderI [intro]:
   assumes "reflexive R"
   and "transitive R"
   shows "preorder R"
   unfolding preorder_eq_preorder_on using assms
   by (intro preorder_onI reflexive_on_if_reflexive transitive_on_if_transitive)
 
 lemma preorderE [elim]:
   assumes "preorder R"
   obtains "reflexive R" "transitive R"
   using assms unfolding preorder_eq_preorder_on by (elim preorder_onE)
   (simp only: reflexive_eq_reflexive_on transitive_eq_transitive_on)
 
 lemma preorder_on_if_preorder:
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> _"
   assumes "preorder R"
   shows "preorder_on P R"
   using assms by (elim preorderE)
   (intro preorder_onI reflexive_on_if_reflexive transitive_on_if_transitive)
 
 
 paragraph \<open>Instantiations\<close>
 
 lemma preorder_eq: "preorder (=)"
   using reflexive_eq transitive_eq by (rule preorderI)
 
 
 end
diff --git a/thys/Transport/HOL_Basics/Predicates/Predicates.thy b/thys/Transport/HOL_Basics/Predicates/Predicates.thy
--- a/thys/Transport/HOL_Basics/Predicates/Predicates.thy
+++ b/thys/Transport/HOL_Basics/Predicates/Predicates.thy
@@ -1,23 +1,55 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 section \<open>Predicates\<close>
 theory Predicates
   imports
     Functions_Base
     Predicates_Order
     Predicates_Lattice
 begin
 
 paragraph \<open>Summary\<close>
 text \<open>Basic concepts on predicates.\<close>
 
 
 definition "pred_map f (P :: 'a \<Rightarrow> bool) x \<equiv> P (f x)"
 
 lemma pred_map_eq [simp]: "pred_map f P x = P (f x)"
   unfolding pred_map_def by simp
 
 lemma comp_eq_pred_map [simp]: "P \<circ> f = pred_map f P"
   by (intro ext) simp
 
+definition "pred_if B P x \<equiv> B \<longrightarrow> P x"
+
+bundle pred_if_syntax begin notation (output) pred_if (infixl "\<longrightarrow>" 50) end
+bundle no_pred_if_syntax begin no_notation (output) pred_if (infixl "\<longrightarrow>" 50) end
+unbundle pred_if_syntax
+
+lemma pred_if_eq_pred_if_pred [simp]:
+  assumes "B"
+  shows "(pred_if B P) = P"
+  unfolding pred_if_def using assms by blast
+
+lemma pred_if_eq_top_if_not_pred [simp]:
+  assumes "\<not>B"
+  shows "(pred_if B P) = (\<lambda>_. True)"
+  unfolding pred_if_def using assms by blast
+
+lemma pred_if_if_impI [intro]:
+  assumes "B \<Longrightarrow> P x"
+  shows "(pred_if B P) x"
+  unfolding pred_if_def using assms by blast
+
+lemma pred_ifE [elim]:
+  assumes "(pred_if B P) x"
+  obtains "\<not>B" | "B" "P x"
+  using assms unfolding pred_if_def by blast
+
+lemma pred_ifD:
+  assumes "(pred_if B P) x"
+  and "B"
+  shows "P x"
+  using assms by blast
+
 
 end
\ No newline at end of file
diff --git a/thys/Transport/ROOT b/thys/Transport/ROOT
--- a/thys/Transport/ROOT
+++ b/thys/Transport/ROOT
@@ -1,50 +1,51 @@
 chapter AFP
 
-session Transport = "HOL-Algebra" +
+session Transport = "HOL" +
   description
     "Transport via partial Galois connections and equivalences and basic libraries on top of HOL axioms."
   options
     [timeout = 600]
   sessions
+    "HOL-Algebra"
     "HOL-Library"
     "ML_Unification"
   directories
     "HOL_Basics"
     "HOL_Basics/Binary_Relations"
     "HOL_Basics/Binary_Relations/Order"
     "HOL_Basics/Binary_Relations/Properties"
     "HOL_Basics/Functions"
     "HOL_Basics/Functions/Properties"
     "HOL_Basics/HOL_Alignments"
     "HOL_Basics/HOL_Syntax_Bundles"
     "HOL_Basics/Orders"
     "HOL_Basics/Orders/Functions"
     "HOL_Basics/Orders/Functors"
     "HOL_Basics/Predicates"
     "HOL_Basics/Galois"
     "Transport"
     "Transport/Compositions"
     "Transport/Compositions/Agree"
     "Transport/Compositions/Generic"
     "Transport/Examples"
     "Transport/Examples/Prototype"
     "Transport/Examples/Typedef"
     "Transport/Functions"
     "Transport/Natural_Functors"
   theories
     HOL_Basics
     HOL_Alignments
     HOL_Algebra_Alignments
     HOL_Syntax_Bundles
     Transport
     Transport_Natural_Functors
     (*Examples*)
     Transport_Dep_Fun_Rel_Examples
     Transport_Lists_Sets_Examples
     Transport_Partial_Quotient_Types
     Transport_Typedef
     (*Paper*)
     Transport_Via_Partial_Galois_Connections_Equivalences_Paper
   document_files
     "root.tex"
     "root.bib"
diff --git a/thys/Transport/Transport/Compositions/Agree/Transport_Compositions_Agree_Galois_Relator.thy b/thys/Transport/Transport/Compositions/Agree/Transport_Compositions_Agree_Galois_Relator.thy
--- a/thys/Transport/Transport/Compositions/Agree/Transport_Compositions_Agree_Galois_Relator.thy
+++ b/thys/Transport/Transport/Compositions/Agree/Transport_Compositions_Agree_Galois_Relator.thy
@@ -1,91 +1,91 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Galois Relator\<close>
 theory Transport_Compositions_Agree_Galois_Relator
   imports
     Transport_Compositions_Agree_Base
 begin
 
 context transport_comp_agree
 begin
 
 lemma left_Galois_le_comp_left_GaloisI:
   assumes in_codom_mono_r2: "([in_codom (\<le>\<^bsub>R2\<^esub>)] \<Rrightarrow>\<^sub>m in_codom (\<le>\<^bsub>R1\<^esub>)) r2"
   and r2_L2_self_if_in_codom: "\<And>z. in_codom (\<le>\<^bsub>R2\<^esub>) z \<Longrightarrow> r2 z \<le>\<^bsub>L2\<^esub> r2 z"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) \<le> ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
 proof (rule le_relI)
   fix x z assume "x \<^bsub>L\<^esub>\<lessapprox> z"
   then have "x \<le>\<^bsub>L1\<^esub> r z" "in_codom (\<le>\<^bsub>R\<^esub>) z" by auto
-  with \<open>x \<le>\<^bsub>L1\<^esub> r z\<close> in_codom_mono_r2 have "x \<^bsub>L1\<^esub>\<lessapprox> r2 z" by auto
+  with \<open>x \<le>\<^bsub>L1\<^esub> r z\<close> in_codom_mono_r2 have "x \<^bsub>L1\<^esub>\<lessapprox> r2 z" by fastforce
   moreover from \<open>in_codom (\<le>\<^bsub>R2\<^esub>) z\<close> r2_L2_self_if_in_codom have "r2 z \<^bsub>L2\<^esub>\<lessapprox> z"
     by (intro g2.left_GaloisI) auto
   ultimately show "((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>)) x z" by blast
 qed
 
 lemma comp_left_Galois_le_left_GaloisI:
   assumes mono_r1: "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and trans_L1: "transitive (\<le>\<^bsub>L1\<^esub>)"
   and R1_r2_if_in_codom: "\<And>y z. in_codom (\<le>\<^bsub>R2\<^esub>) z \<Longrightarrow> y \<le>\<^bsub>L2\<^esub> r2 z \<Longrightarrow> y \<le>\<^bsub>R1\<^esub> r2 z"
   shows "((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>)) \<le> (\<^bsub>L\<^esub>\<lessapprox>)"
 proof (rule le_relI)
   fix x z assume "((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>)) x z"
   then obtain y where "x \<^bsub>L1\<^esub>\<lessapprox> y" "y \<^bsub>L2\<^esub>\<lessapprox> z" by blast
   then have "x \<le>\<^bsub>L1\<^esub> r1 y" "y \<le>\<^bsub>L2\<^esub> r2 z" "in_codom (\<le>\<^bsub>R\<^esub>) z" by auto
   with R1_r2_if_in_codom have "y \<le>\<^bsub>R1\<^esub> r2 z" by blast
   with mono_r1 have "r1 y \<le>\<^bsub>L1\<^esub> r z" by auto
   with \<open>x \<le>\<^bsub>L1\<^esub> r1 y\<close> \<open>in_codom (\<le>\<^bsub>R\<^esub>) z\<close> show "x \<^bsub>L\<^esub>\<lessapprox> z" using trans_L1 by blast
 qed
 
 corollary left_Galois_eq_comp_left_GaloisI:
   assumes "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>z. in_codom (\<le>\<^bsub>R2\<^esub>) z \<Longrightarrow> r2 z \<le>\<^bsub>L2\<^esub> r2 z"
   and "\<And>y z. in_codom (\<le>\<^bsub>R2\<^esub>) z \<Longrightarrow> y \<le>\<^bsub>L2\<^esub> r2 z \<Longrightarrow> y \<le>\<^bsub>R1\<^esub> r2 z"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
   using assms
   by (intro antisym left_Galois_le_comp_left_GaloisI comp_left_Galois_le_left_GaloisI
     dep_mono_wrt_predI)
   fastforce
 
 corollary left_Galois_eq_comp_left_GaloisI':
   assumes "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "reflexive_on (in_codom (\<le>\<^bsub>R2\<^esub>)) (\<le>\<^bsub>R2\<^esub>)"
   and "\<And>y z. in_codom (\<le>\<^bsub>R2\<^esub>) z \<Longrightarrow> y \<le>\<^bsub>L2\<^esub> r2 z \<Longrightarrow> y \<le>\<^bsub>R1\<^esub> r2 z"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
-  using assms by (intro left_Galois_eq_comp_left_GaloisI) auto
+  using assms by (intro left_Galois_eq_comp_left_GaloisI) (auto 5 0)
 
 corollary left_Galois_eq_comp_left_GaloisI'':
   assumes "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "reflexive_on (in_codom (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and "\<And>y z. in_codom (\<le>\<^bsub>R2\<^esub>) z \<Longrightarrow> y \<le>\<^bsub>L2\<^esub> r2 z \<Longrightarrow> y \<le>\<^bsub>R1\<^esub> r2 z"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
-  using assms by (intro left_Galois_eq_comp_left_GaloisI) (auto 0 4)
+  using assms by (intro left_Galois_eq_comp_left_GaloisI) (auto 0 6)
 
 end
 
 context transport_comp_same
 begin
 
 lemma left_Galois_eq_comp_left_GaloisI:
   assumes "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) r2"
   and "reflexive_on (in_codom (\<le>\<^bsub>R2\<^esub>)) (\<le>\<^bsub>R2\<^esub>)"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
   using assms by (intro left_Galois_eq_comp_left_GaloisI') auto
 
 lemma left_Galois_eq_comp_left_GaloisI':
   assumes "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_codom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) r2"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
   using assms by (intro left_Galois_eq_comp_left_GaloisI'') auto
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Compositions/Agree/Transport_Compositions_Agree_Order_Equivalence.thy b/thys/Transport/Transport/Compositions/Agree/Transport_Compositions_Agree_Order_Equivalence.thy
--- a/thys/Transport/Transport/Compositions/Agree/Transport_Compositions_Agree_Order_Equivalence.thy
+++ b/thys/Transport/Transport/Compositions/Agree/Transport_Compositions_Agree_Order_Equivalence.thy
@@ -1,131 +1,131 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Order Equivalence\<close>
 theory Transport_Compositions_Agree_Order_Equivalence
   imports
     Transport_Compositions_Agree_Monotone
 begin
 
 context transport_comp_agree
 begin
 
 subsubsection \<open>Unit\<close>
 paragraph \<open>Inflationary\<close>
 
 lemma inflationary_on_unitI:
   assumes mono_l1: "([P] \<Rrightarrow>\<^sub>m P') l1"
   and mono_r1: "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and inflationary_unit1: "inflationary_on P (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and trans_L1: "transitive (\<le>\<^bsub>L1\<^esub>)"
   and inflationary_unit2: "inflationary_on P' (\<le>\<^bsub>L2\<^esub>) \<eta>\<^sub>2"
   and L2_le_R1: "\<And>x. P x \<Longrightarrow> l1 x \<le>\<^bsub>L2\<^esub> r2 (l x) \<Longrightarrow> l1 x \<le>\<^bsub>R1\<^esub> r2 (l x)"
   shows "inflationary_on P (\<le>\<^bsub>L\<^esub>) \<eta>"
 proof (rule inflationary_onI)
   fix x assume "P x"
   with mono_l1 have "P' (l1 x)" by blast
   with inflationary_unit2 have "l1 x \<le>\<^bsub>L2\<^esub> r2 (l x)" by auto
   with L2_le_R1 \<open>P x\<close> have "l1 x \<le>\<^bsub>R1\<^esub> r2 (l x)" by blast
   with mono_r1 have "\<eta>\<^sub>1 x \<le>\<^bsub>L1\<^esub> \<eta> x" by auto
   moreover from inflationary_unit1 \<open>P x\<close> have "x \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x" by auto
   ultimately show "x \<le>\<^bsub>L\<^esub> \<eta> x" using trans_L1 by blast
 qed
 
 corollary inflationary_on_in_field_unitI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) l1"
   and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "inflationary_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "inflationary_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>) \<eta>\<^sub>2"
   and "\<And>x. in_field (\<le>\<^bsub>L1\<^esub>) x \<Longrightarrow> l1 x \<le>\<^bsub>L2\<^esub> r2 (l x) \<Longrightarrow> l1 x \<le>\<^bsub>R1\<^esub> r2 (l x)"
   shows "inflationary_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
-  using assms by (intro inflationary_on_unitI dep_mono_wrt_predI) auto
+  using assms by (intro inflationary_on_unitI dep_mono_wrt_predI) (auto 5 0)
 
 
 paragraph \<open>Deflationary\<close>
 
 context
 begin
 
 interpretation inv :
   transport_comp_agree "(\<ge>\<^bsub>L1\<^esub>)" "(\<ge>\<^bsub>R1\<^esub>)" l1 r1 "(\<ge>\<^bsub>L2\<^esub>)" "(\<ge>\<^bsub>R2\<^esub>)" l2 r2
   rewrites "\<And>R S. (R\<inverse> \<Rrightarrow>\<^sub>m S\<inverse>) \<equiv> (R \<Rrightarrow>\<^sub>m S)"
   and "\<And>R. inflationary_on P R\<inverse> \<equiv> deflationary_on P R"
   and "\<And>R. transitive R\<inverse> \<equiv> transitive R"
   and "\<And>R. in_field R\<inverse> \<equiv> in_field R"
   by simp_all
 
 lemma deflationary_on_in_field_unitI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) l1"
   and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "deflationary_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "deflationary_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>) \<eta>\<^sub>2"
   and "\<And>x. in_field (\<le>\<^bsub>L1\<^esub>) x \<Longrightarrow> r2 (l x) \<le>\<^bsub>L2\<^esub> l1 x \<Longrightarrow> r2 (l x) \<le>\<^bsub>R1\<^esub> l1 x"
   shows "deflationary_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   using assms by (intro inv.inflationary_on_in_field_unitI[simplified rel_inv_iff_rel])
   auto
 
 end
 
 
 text \<open>Relational Equivalence\<close>
 
 corollary rel_equivalence_on_in_field_unitI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) l1"
   and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "rel_equivalence_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "rel_equivalence_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>) \<eta>\<^sub>2"
   and "\<And>x. in_field (\<le>\<^bsub>L1\<^esub>) x \<Longrightarrow> l1 x \<le>\<^bsub>L2\<^esub> r2 (l x) \<Longrightarrow> l1 x \<le>\<^bsub>R1\<^esub> r2 (l x)"
   and "\<And>x. in_field (\<le>\<^bsub>L1\<^esub>) x \<Longrightarrow> r2 (l x) \<le>\<^bsub>L2\<^esub> l1 x \<Longrightarrow> r2 (l x) \<le>\<^bsub>R1\<^esub> l1 x"
   shows "rel_equivalence_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   using assms by (intro rel_equivalence_onI
     inflationary_on_in_field_unitI deflationary_on_in_field_unitI)
   auto
 
 
 subsubsection \<open>Counit\<close>
 
 text \<open>Corresponding lemmas for the counit can be obtained by flipping the
 interpretation of the locale.\<close>
 
 
 subsubsection \<open>Order Equivalence\<close>
 
 interpretation flip : transport_comp_agree R2 L2 r2 l2 R1 L1 r1 l1
   rewrites "flip.g1.unit \<equiv> \<epsilon>\<^sub>2" and "flip.g2.unit \<equiv> \<epsilon>\<^sub>1" and "flip.unit \<equiv> \<epsilon>"
   by (simp_all only: g1.flip_unit_eq_counit g2.flip_unit_eq_counit flip_unit_eq_counit)
 
 lemma order_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   and "transitive (\<le>\<^bsub>R2\<^esub>)"
   and "\<And>x y. x \<le>\<^bsub>L1\<^esub> y \<Longrightarrow> l1 x \<le>\<^bsub>R1\<^esub> l1 y \<Longrightarrow> l1 x \<le>\<^bsub>L2\<^esub> l1 y"
   and "\<And>x y. x \<le>\<^bsub>R2\<^esub> y \<Longrightarrow> r2 x \<le>\<^bsub>L2\<^esub> r2 y \<Longrightarrow> r2 x \<le>\<^bsub>R1\<^esub> r2 y"
   and "\<And>x. in_field (\<le>\<^bsub>L1\<^esub>) x \<Longrightarrow> l1 x \<le>\<^bsub>L2\<^esub> r2 (l x) \<Longrightarrow> l1 x \<le>\<^bsub>R1\<^esub> r2 (l x)"
   and "\<And>x. in_field (\<le>\<^bsub>L1\<^esub>) x \<Longrightarrow> r2 (l x) \<le>\<^bsub>L2\<^esub> l1 x \<Longrightarrow> r2 (l x) \<le>\<^bsub>R1\<^esub> l1 x"
   and "\<And>x. in_field (\<le>\<^bsub>R2\<^esub>) x \<Longrightarrow> r2 x \<le>\<^bsub>R1\<^esub> l1 (r x) \<Longrightarrow> r2 x \<le>\<^bsub>L2\<^esub> l1 (r x)"
   and "\<And>x. in_field (\<le>\<^bsub>R2\<^esub>) x \<Longrightarrow> l1 (r x) \<le>\<^bsub>R1\<^esub> r2 x \<Longrightarrow> l1 (r x) \<le>\<^bsub>L2\<^esub> r2 x"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro order_equivalenceI rel_equivalence_on_in_field_unitI
     flip.rel_equivalence_on_in_field_unitI
     mono_wrt_rel_leftI flip.mono_wrt_rel_leftI dep_mono_wrt_relI)
   (auto elim!: g1.order_equivalenceE g2.order_equivalenceE)
 
 end
 
 context transport_comp_same
 begin
 
 lemma order_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>R1\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   and "transitive (\<le>\<^bsub>R2\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (rule order_equivalenceI) auto
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Base.thy b/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Base.thy
--- a/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Base.thy
+++ b/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Base.thy
@@ -1,588 +1,589 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 section \<open>Generic Compositions\<close>
 subsection \<open>Basic Setup\<close>
 theory Transport_Compositions_Generic_Base
   imports
+    Equivalence_Relations
     Transport_Base
 begin
 
 locale transport_comp =
   t1 : transport L1 R1 l1 r1 + t2 : transport L2 R2 l2 r2
   for L1 :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
   and R1 :: "'b \<Rightarrow> 'b \<Rightarrow> bool"
   and l1 :: "'a \<Rightarrow> 'b"
   and r1 :: "'b \<Rightarrow> 'a"
   and L2 :: "'b \<Rightarrow> 'b \<Rightarrow> bool"
   and R2 :: "'c \<Rightarrow> 'c \<Rightarrow> bool"
   and l2 :: "'b \<Rightarrow> 'c"
   and r2 :: "'c \<Rightarrow> 'b"
 begin
 
 text \<open>This locale collects results about the composition of transportable
 components under some generic compatibility conditions on @{term "R1"} and
 @{term "L2"} (cf. below). The composition is rather subtle, but in return can
 cover quite general cases.
 
 Explanations and intuition about the construction can be found in \<^cite>\<open>"transport"\<close>.\<close>
 
 notation L1 (infix "\<le>\<^bsub>L1\<^esub>" 50)
 notation R1 (infix "\<le>\<^bsub>R1\<^esub>" 50)
 notation L2 (infix "\<le>\<^bsub>L2\<^esub>" 50)
 notation R2 (infix "\<le>\<^bsub>R2\<^esub>" 50)
 
 notation t1.ge_left (infix "\<ge>\<^bsub>L1\<^esub>" 50)
 notation t1.ge_right (infix "\<ge>\<^bsub>R1\<^esub>" 50)
 notation t2.ge_left (infix "\<ge>\<^bsub>L2\<^esub>" 50)
 notation t2.ge_right (infix "\<ge>\<^bsub>R2\<^esub>" 50)
 
 notation t1.left_Galois (infix "\<^bsub>L1\<^esub>\<lessapprox>" 50)
 notation t1.right_Galois (infix "\<^bsub>R1\<^esub>\<lessapprox>" 50)
 notation t2.left_Galois (infix "\<^bsub>L2\<^esub>\<lessapprox>" 50)
 notation t2.right_Galois (infix "\<^bsub>R2\<^esub>\<lessapprox>" 50)
 
 notation t1.ge_Galois_left (infix "\<greaterapprox>\<^bsub>L1\<^esub>" 50)
 notation t1.ge_Galois_right (infix "\<greaterapprox>\<^bsub>R1\<^esub>" 50)
 notation t2.ge_Galois_left (infix "\<greaterapprox>\<^bsub>L2\<^esub>" 50)
 notation t2.ge_Galois_right (infix "\<greaterapprox>\<^bsub>R2\<^esub>" 50)
 
 notation t1.right_ge_Galois (infix "\<^bsub>R1\<^esub>\<greaterapprox>" 50)
 notation t1.Galois_right (infix "\<lessapprox>\<^bsub>R1\<^esub>" 50)
 notation t2.right_ge_Galois (infix "\<^bsub>R2\<^esub>\<greaterapprox>" 50)
 notation t2.Galois_right (infix "\<lessapprox>\<^bsub>R2\<^esub>" 50)
 
 notation t1.left_ge_Galois (infix "\<^bsub>L1\<^esub>\<greaterapprox>" 50)
 notation t1.Galois_left (infix "\<lessapprox>\<^bsub>L1\<^esub>" 50)
 notation t2.left_ge_Galois (infix "\<^bsub>L2\<^esub>\<greaterapprox>" 50)
 notation t2.Galois_left (infix "\<lessapprox>\<^bsub>L2\<^esub>" 50)
 
 notation t1.unit ("\<eta>\<^sub>1")
 notation t1.counit ("\<epsilon>\<^sub>1")
 notation t2.unit ("\<eta>\<^sub>2")
 notation t2.counit ("\<epsilon>\<^sub>2")
 
 definition "L \<equiv> (\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<^bsub>R1\<^esub>\<lessapprox>)"
 
 lemma left_rel_eq_comp: "L = (\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<^bsub>R1\<^esub>\<lessapprox>)"
   unfolding L_def ..
 
 definition "l \<equiv> l2 \<circ> l1"
 
 lemma left_eq_comp: "l = l2 \<circ> l1"
   unfolding l_def ..
 
 lemma left_eq [simp]: "l x = l2 (l1 x)"
   unfolding left_eq_comp by simp
 
 context
 begin
 
 interpretation flip : transport_comp R2 L2 r2 l2 R1 L1 r1 l1 .
 
 abbreviation "R \<equiv> flip.L"
 abbreviation "r \<equiv> flip.l"
 
 lemma right_rel_eq_comp: "R = (\<^bsub>R2\<^esub>\<lessapprox>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>)"
   unfolding flip.L_def ..
 
 lemma right_eq_comp: "r = r1 \<circ> r2"
   unfolding flip.l_def ..
 
 lemma right_eq [simp]: "r z = r1 (r2 z)"
   unfolding right_eq_comp by simp
 
 lemmas transport_defs = left_rel_eq_comp left_eq_comp right_rel_eq_comp right_eq_comp
 
 end
 
 sublocale transport L R l r .
 
 (*FIXME: somehow the notation for the fixed parameters L and R, defined in
 Order_Functions_Base.thy, is lost. We hence re-declare it here.*)
 notation L (infix "\<le>\<^bsub>L\<^esub>" 50)
 notation R (infix "\<le>\<^bsub>R\<^esub>" 50)
 
 lemma left_relI [intro]:
   assumes "x \<^bsub>L1\<^esub>\<lessapprox> y"
   and "y \<le>\<^bsub>L2\<^esub> y'"
   and "y' \<^bsub>R1\<^esub>\<lessapprox> x'"
   shows "x \<le>\<^bsub>L\<^esub> x'"
   unfolding left_rel_eq_comp using assms by blast
 
 lemma left_relE [elim]:
   assumes "x \<le>\<^bsub>L\<^esub> x'"
   obtains y y' where "x \<^bsub>L1\<^esub>\<lessapprox> y" "y \<le>\<^bsub>L2\<^esub> y'" "y' \<^bsub>R1\<^esub>\<lessapprox> x'"
   using assms unfolding left_rel_eq_comp by blast
 
 context
 begin
 
 interpretation flip : transport_comp R2 L2 r2 l2 R1 L1 r1 l1 .
 interpretation inv : transport_comp "(\<ge>\<^bsub>L1\<^esub>)" "(\<ge>\<^bsub>R1\<^esub>)" l1 r1 "(\<ge>\<^bsub>L2\<^esub>)" "(\<ge>\<^bsub>R2\<^esub>)" l2 r2 .
 
 lemma ge_left_rel_eq_left_rel_inv_if_galois_prop [simp]:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1" "((\<le>\<^bsub>R1\<^esub>) \<unlhd> (\<le>\<^bsub>L1\<^esub>)) r1 l1"
   shows "(\<ge>\<^bsub>L\<^esub>) = transport_comp.L (\<ge>\<^bsub>L1\<^esub>) (\<ge>\<^bsub>R1\<^esub>) l1 r1 (\<ge>\<^bsub>L2\<^esub>)"
   using assms unfolding left_rel_eq_comp inv.left_rel_eq_comp
   by (simp add: rel_comp_assoc)
 
 corollary left_rel_inv_iff_left_rel_if_galois_prop [iff]:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1" "((\<le>\<^bsub>R1\<^esub>) \<unlhd> (\<le>\<^bsub>L1\<^esub>)) r1 l1"
   shows "(transport_comp.L (\<ge>\<^bsub>L1\<^esub>) (\<ge>\<^bsub>R1\<^esub>) l1 r1 (\<ge>\<^bsub>L2\<^esub>)) x x' \<longleftrightarrow> x' \<le>\<^bsub>L\<^esub> x"
   using assms by (simp flip: ge_left_rel_eq_left_rel_inv_if_galois_prop)
 
 
 subsubsection \<open>Simplification of Relations\<close>
 
 lemma left_rel_le_left_rel1I:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>R1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L1\<^esub>)) r1 l1"
   and trans_L1: "transitive (\<le>\<^bsub>L1\<^esub>)"
   and mono_l1: "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))) l1"
   shows "(\<le>\<^bsub>L\<^esub>) \<le> (\<le>\<^bsub>L1\<^esub>)"
 proof (rule le_relI)
   fix x x' assume "x \<le>\<^bsub>L\<^esub> x'"
   with mono_l1 obtain y where "l1 x \<le>\<^bsub>R1\<^esub> y" "y \<le>\<^bsub>R1\<^esub> l1 x'" by blast
   with \<open>((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1\<close> \<open>x \<le>\<^bsub>L\<^esub> x'\<close> have "x \<le>\<^bsub>L1\<^esub> r1 y" by blast
   moreover from \<open>((\<le>\<^bsub>R1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L1\<^esub>)) r1 l1\<close> \<open>y \<le>\<^bsub>R1\<^esub> l1 x'\<close> \<open>x \<le>\<^bsub>L\<^esub> x'\<close>
     have "... \<le>\<^bsub>L1\<^esub> x'" by blast
   ultimately show "x \<le>\<^bsub>L1\<^esub> x'" using trans_L1 by blast
 qed
 
 lemma left_rel1_le_left_relI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and mono_l1: "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))) l1"
   shows "(\<le>\<^bsub>L1\<^esub>) \<le> (\<le>\<^bsub>L\<^esub>)"
 proof (rule le_relI)
   fix x x' assume "x \<le>\<^bsub>L1\<^esub> x'"
   with mono_l1 obtain y y' where
     "l1 x \<le>\<^bsub>R1\<^esub> y" "y \<le>\<^bsub>L2\<^esub> y'" "y' \<le>\<^bsub>R1\<^esub> l1 x'" by blast
   with \<open>((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1\<close> \<open>x \<le>\<^bsub>L1\<^esub> x'\<close> have "x \<^bsub>L1\<^esub>\<lessapprox> y" by blast
   moreover note \<open>y \<le>\<^bsub>L2\<^esub> y'\<close>
   moreover from \<open>y' \<le>\<^bsub>R1\<^esub> l1 x'\<close> \<open>x \<le>\<^bsub>L1\<^esub> x'\<close> have "y' \<^bsub>R1\<^esub>\<lessapprox> x'" by blast
   ultimately show "x \<le>\<^bsub>L\<^esub> x'" by blast
 qed
 
 corollary left_rel_eq_left_rel1I:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>R1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L1\<^esub>)) r1 l1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))) l1"
   shows "(\<le>\<^bsub>L\<^esub>) = (\<le>\<^bsub>L1\<^esub>)"
   using assms by (intro antisym left_rel_le_left_rel1I left_rel1_le_left_relI)
 
 text \<open>Note that we may not necessarily have @{term "(\<le>\<^bsub>L\<^esub>) = (\<le>\<^bsub>L1\<^esub>)"}, even in
 case of equivalence relations. Depending on the use case, one thus may wish to
 use an alternative composition operation.\<close>
 
 lemma ex_order_equiv_left_rel_neq_left_rel1:
   "\<exists>(L1 :: bool \<Rightarrow> _) (R1 :: bool \<Rightarrow> _) l1 r1
     (L2 :: bool \<Rightarrow> _) (R2 :: bool \<Rightarrow> _) l2 r2.
     (L1 \<equiv>\<^sub>o R1) l1 r1
     \<and> equivalence_rel L1 \<and> equivalence_rel R1
     \<and> (L2 \<equiv>\<^sub>o R2) l2 r2
     \<and> equivalence_rel L2 \<and> equivalence_rel R2
     \<and> transport_comp.L L1 R1 l1 r1 L2 \<noteq> L1"
 proof (intro exI conjI)
   let ?L1 = "(=) :: bool \<Rightarrow> _" let ?R1 = ?L1 let ?l1 = id let ?r1 = ?l1
   let ?L2 = "\<top> :: bool \<Rightarrow> bool \<Rightarrow> bool" let ?R2 = ?L2 let ?l2 = id let ?r2 = ?l2
   interpret tc : transport_comp ?L1 ?R1 ?l1 ?r1 ?L2 ?R2 ?l2 ?r2 .
   show "(?L1 \<equiv>\<^sub>o ?R1) ?l1 ?r1" by fastforce
   show "equivalence_rel ?L1" "equivalence_rel ?R1" by (fact equivalence_eq)+
   show "(?L2 \<equiv>\<^sub>o ?R2) ?l2 ?r2" by fastforce
   show "equivalence_rel ?L2" "equivalence_rel ?R2" by (fact equivalence_top)+
   show "tc.L \<noteq> ?L1"
   proof -
     have "\<not>(?L1 False True)" by blast
     moreover have "tc.L False True" by (intro tc.left_relI) auto
     ultimately show ?thesis by auto
   qed
 qed
 
 end
 
 
 subsubsection \<open>Generic Left to Right Introduction Rules\<close>
 
 text \<open>The following lemmas generalise the proof outline used, for example,
 when proving monotonicity and the Galois property (cf. the paper \<^cite>\<open>"transport"\<close>).\<close>
 
 interpretation flip : transport_comp R2 L2 r2 l2 R1 L1 r1 l1 .
 
 lemma right_rel_if_left_relI:
   assumes "x \<le>\<^bsub>L\<^esub> x'"
   and l1_R1_if_L1_r1: "\<And>y. in_codom (\<le>\<^bsub>R1\<^esub>) y \<Longrightarrow> x \<le>\<^bsub>L1\<^esub> r1 y \<Longrightarrow> l1 x \<le>\<^bsub>R1\<^esub> y"
   and t_R1_if_l1_R1: "\<And>y. l1 x \<le>\<^bsub>R1\<^esub> y \<Longrightarrow> t y \<le>\<^bsub>R1\<^esub> y"
   and R2_l2_if_t_L2_if_l1_R1:
     "\<And>y y'. l1 x \<le>\<^bsub>R1\<^esub> y \<Longrightarrow> t y \<le>\<^bsub>L2\<^esub> y' \<Longrightarrow> z \<le>\<^bsub>R2\<^esub> l2 y'"
   and R1_b_if_R1_l1_if_R1_l1:
     "\<And>y y'. y \<le>\<^bsub>R1\<^esub> l1 x' \<Longrightarrow> y' \<le>\<^bsub>R1\<^esub> l1 x' \<Longrightarrow> y' \<le>\<^bsub>R1\<^esub> b y"
   and b_L2_r2_if_in_codom_L2_b_if_R1_l1:
     "\<And>y. y \<le>\<^bsub>R1\<^esub> l1 x' \<Longrightarrow> in_codom (\<le>\<^bsub>L2\<^esub>) (b y) \<Longrightarrow> b y \<le>\<^bsub>L2\<^esub> r2 z'"
   and in_codom_R2_if_in_codom_L2_b_if_R1_l1:
     "\<And>y. y \<le>\<^bsub>R1\<^esub> l1 x' \<Longrightarrow> in_codom (\<le>\<^bsub>L2\<^esub>) (b y) \<Longrightarrow> in_codom (\<le>\<^bsub>R2\<^esub>) z'"
   and rel_comp_le: "(\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<le> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)"
   and in_codom_rel_comp_le: "in_codom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_codom (\<le>\<^bsub>L2\<^esub>)"
   shows "z \<le>\<^bsub>R\<^esub> z'"
 proof -
   from \<open>x \<le>\<^bsub>L\<^esub> x'\<close> obtain yl yl' where "l1 x \<le>\<^bsub>R1\<^esub> yl" "yl \<le>\<^bsub>L2\<^esub> yl'" "yl' \<le>\<^bsub>R1\<^esub> l1 x'"
     using l1_R1_if_L1_r1 by blast
   moreover then have "t yl \<le>\<^bsub>R1\<^esub> yl" by (intro t_R1_if_l1_R1)
   ultimately have "((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) (t yl) (l1 x')" using rel_comp_le by blast
   then obtain y where "t yl \<le>\<^bsub>L2\<^esub> y" "y \<le>\<^bsub>R1\<^esub> l1 x'" by blast
   show "z \<le>\<^bsub>R\<^esub> z'"
   proof (rule flip.left_relI)
     from \<open>t yl \<le>\<^bsub>L2\<^esub> y\<close> \<open>l1 x \<le>\<^bsub>R1\<^esub> yl\<close> show "z \<^bsub>R2\<^esub>\<lessapprox> y"
       by (auto intro: R2_l2_if_t_L2_if_l1_R1)
     from \<open>yl' \<le>\<^bsub>R1\<^esub> l1 x'\<close> \<open>y \<le>\<^bsub>R1\<^esub> l1 x'\<close> show "y \<le>\<^bsub>R1\<^esub> b yl'"
       by (rule R1_b_if_R1_l1_if_R1_l1)
     show "b yl' \<^bsub>L2\<^esub>\<lessapprox> z'"
     proof (rule t2.left_GaloisI)
       from \<open>yl' \<le>\<^bsub>R1\<^esub> l1 x'\<close> have "yl' \<le>\<^bsub>R1\<^esub> b yl'"
         by (intro R1_b_if_R1_l1_if_R1_l1)
       with \<open>l1 x \<le>\<^bsub>R1\<^esub> yl\<close> \<open>yl \<le>\<^bsub>L2\<^esub> yl'\<close> in_codom_rel_comp_le
         have "in_codom (\<le>\<^bsub>L2\<^esub>) (b yl')" by blast
       with \<open>yl' \<le>\<^bsub>R1\<^esub> l1 x'\<close> show "b yl' \<le>\<^bsub>L2\<^esub> r2 z'" "in_codom (\<le>\<^bsub>R2\<^esub>) z'"
         by (auto intro: b_L2_r2_if_in_codom_L2_b_if_R1_l1
           in_codom_R2_if_in_codom_L2_b_if_R1_l1)
     qed
   qed
 qed
 
 lemma right_rel_if_left_relI':
   assumes "x \<le>\<^bsub>L\<^esub> x'"
   and l1_R1_if_L1_r1: "\<And>y. in_codom (\<le>\<^bsub>R1\<^esub>) y \<Longrightarrow> x \<le>\<^bsub>L1\<^esub> r1 y \<Longrightarrow> l1 x \<le>\<^bsub>R1\<^esub> y"
   and R1_b_if_R1_l1: "\<And>y. y \<le>\<^bsub>R1\<^esub> l1 x' \<Longrightarrow> y \<le>\<^bsub>R1\<^esub> b y"
   and L2_r2_if_L2_b_if_R1_l1:
     "\<And>y y'. y \<le>\<^bsub>R1\<^esub> l1 x' \<Longrightarrow> y' \<le>\<^bsub>L2\<^esub> b y \<Longrightarrow> y' \<le>\<^bsub>L2\<^esub> r2 z'"
   and in_codom_R2_if_L2_b_if_R1_l1:
     "\<And>y y'. y \<le>\<^bsub>R1\<^esub> l1 x' \<Longrightarrow> y' \<le>\<^bsub>L2\<^esub> b y \<Longrightarrow> in_codom (\<le>\<^bsub>R2\<^esub>) z'"
   and t_R1_if_R1_l1_if_l1_R1:
     "\<And>y y' y''. l1 x \<le>\<^bsub>R1\<^esub> y \<Longrightarrow> l1 x \<le>\<^bsub>R1\<^esub> y' \<Longrightarrow> t y \<le>\<^bsub>R1\<^esub> y'"
   and R2_l2_t_if_in_dom_L2_t_if_l1_R1:
     "\<And>y y'. l1 x \<le>\<^bsub>R1\<^esub> y \<Longrightarrow> in_dom (\<le>\<^bsub>L2\<^esub>) (t y) \<Longrightarrow> z \<le>\<^bsub>R2\<^esub> l2 (t y)"
   and in_codom_L2_t_if_in_dom_L2_t_if_l1_R1:
     "\<And>y y'. l1 x \<le>\<^bsub>R1\<^esub> y \<Longrightarrow> in_dom (\<le>\<^bsub>L2\<^esub>) (t y) \<Longrightarrow> in_codom (\<le>\<^bsub>L2\<^esub>) (t y)"
   and rel_comp_le: "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   and in_dom_rel_comp_le: "in_dom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_dom (\<le>\<^bsub>L2\<^esub>)"
   shows "z \<le>\<^bsub>R\<^esub> z'"
 proof -
   from \<open>x \<le>\<^bsub>L\<^esub> x'\<close> obtain yl yl' where "l1 x \<le>\<^bsub>R1\<^esub> yl" "yl \<le>\<^bsub>L2\<^esub> yl'" "yl' \<le>\<^bsub>R1\<^esub> l1 x'"
     using l1_R1_if_L1_r1 by blast
   moreover then have "yl' \<le>\<^bsub>R1\<^esub> b yl'" by (intro R1_b_if_R1_l1)
   ultimately have "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) (l1 x) (b yl')" using rel_comp_le by blast
   then obtain y where "l1 x \<le>\<^bsub>R1\<^esub> y" "y \<le>\<^bsub>L2\<^esub> b yl'" by blast
   show "z \<le>\<^bsub>R\<^esub> z'"
   proof (rule flip.left_relI)
     from \<open>yl' \<le>\<^bsub>R1\<^esub> l1 x'\<close> \<open>y \<le>\<^bsub>L2\<^esub> b yl'\<close>
       have "in_codom (\<le>\<^bsub>R2\<^esub>) z'" "y \<le>\<^bsub>L2\<^esub> r2 z'"
       by (auto intro: in_codom_R2_if_L2_b_if_R1_l1 L2_r2_if_L2_b_if_R1_l1)
     then show "y \<^bsub>L2\<^esub>\<lessapprox> z'" by blast
     from \<open>l1 x \<le>\<^bsub>R1\<^esub> yl\<close> \<open>l1 x \<le>\<^bsub>R1\<^esub> y\<close> show "t yl \<le>\<^bsub>R1\<^esub> y" by (rule t_R1_if_R1_l1_if_l1_R1)
     show "z \<^bsub>R2\<^esub>\<lessapprox> t yl"
     proof (rule flip.t1.left_GaloisI)
       from \<open>l1 x \<le>\<^bsub>R1\<^esub> yl\<close> have "t yl \<le>\<^bsub>R1\<^esub> yl" by (intro t_R1_if_R1_l1_if_l1_R1)
       with \<open>yl \<le>\<^bsub>L2\<^esub> yl'\<close> \<open>yl' \<le>\<^bsub>R1\<^esub> l1 x'\<close> in_dom_rel_comp_le have "in_dom (\<le>\<^bsub>L2\<^esub>) (t yl)"
         by blast
       with \<open>l1 x \<le>\<^bsub>R1\<^esub> yl\<close>
         show "z \<le>\<^bsub>R2\<^esub> l2 (t yl)" "in_codom (\<le>\<^bsub>L2\<^esub>) (t yl)" by (auto intro:
           R2_l2_t_if_in_dom_L2_t_if_l1_R1 in_codom_L2_t_if_in_dom_L2_t_if_l1_R1)
     qed
   qed
 qed
 
 
 subsubsection \<open>Simplification of Monotonicity Assumptions\<close>
 
 text \<open>Some sufficient conditions for monotonicity assumptions that repeatedly
 arise in various places.\<close>
 
 lemma mono_in_dom_left_rel_left1_if_in_dom_rel_comp_le:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "in_dom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_dom (\<le>\<^bsub>L2\<^esub>)"
   shows "([in_dom (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m in_dom (\<le>\<^bsub>L2\<^esub>)) l1"
   using assms by (intro dep_mono_wrt_predI) blast
 
 lemma mono_in_codom_left_rel_left1_if_in_codom_rel_comp_le:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "in_codom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_codom (\<le>\<^bsub>L2\<^esub>)"
   shows "([in_codom (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m in_codom (\<le>\<^bsub>L2\<^esub>)) l1"
   using assms by (intro dep_mono_wrt_predI) blast
 
 
 subsubsection \<open>Simplification of Compatibility Conditions\<close>
 
 text \<open>Most results will depend on certain compatibility conditions between
 @{term "(\<le>\<^bsub>R1\<^esub>)"} and @{term "(\<le>\<^bsub>L2\<^esub>)"}. We next derive some sufficient assumptions
 for these conditions.\<close>
 
 end
 
 lemma rel_comp_comp_le_rel_comp_if_rel_comp_comp_if_in_dom_leI:
   assumes trans_R: "transitive R"
   and refl_S: "reflexive_on P S"
   and in_dom_le: "in_dom (R \<circ>\<circ> S \<circ>\<circ> R) \<le> P"
   and rel_comp_le: "(S \<circ>\<circ> R \<circ>\<circ> S) \<le> (S \<circ>\<circ> R)"
   shows "(R \<circ>\<circ> S \<circ>\<circ> R) \<le> (S \<circ>\<circ> R)"
 proof (intro le_relI)
   fix x y assume "(R \<circ>\<circ> S \<circ>\<circ> R) x y"
   moreover with in_dom_le refl_S have "S x x" by blast
   ultimately have "((S \<circ>\<circ> R \<circ>\<circ> S) \<circ>\<circ> R) x y" by blast
   with rel_comp_le have "(S \<circ>\<circ> R \<circ>\<circ> R) x y" by blast
   with trans_R show "(S \<circ>\<circ> R) x y" by blast
 qed
 
 lemma rel_comp_comp_le_rel_comp_if_rel_comp_comp_if_in_codom_leI:
   assumes trans_R: "transitive R"
   and refl_S: "reflexive_on P S"
   and in_codom_le: "in_codom (R \<circ>\<circ> S \<circ>\<circ> R) \<le> P"
   and rel_comp_le: "(S \<circ>\<circ> R \<circ>\<circ> S) \<le> (R \<circ>\<circ> S)"
   shows "(R \<circ>\<circ> S \<circ>\<circ> R) \<le> (R \<circ>\<circ> S)"
 proof (intro le_relI)
   fix x y assume "(R \<circ>\<circ> S \<circ>\<circ> R) x y"
   moreover with in_codom_le refl_S have "S y y" by blast
   ultimately have "(R \<circ>\<circ> (S \<circ>\<circ> R \<circ>\<circ> S)) x y" by blast
   with rel_comp_le have "(R \<circ>\<circ> R \<circ>\<circ> S) x y" by blast
   with trans_R show "(R \<circ>\<circ> S) x y" by blast
 qed
 
 lemma rel_comp_comp_le_rel_comp_if_rel_comp_le_if_transitive:
   assumes trans_R: "transitive R"
   and R_S_le: "(R \<circ>\<circ> S) \<le> (S \<circ>\<circ> R)"
   shows "(R \<circ>\<circ> S \<circ>\<circ> R) \<le> (S \<circ>\<circ> R)"
 proof -
   from trans_R have R_R_le: "(R \<circ>\<circ> R) \<le> R" by (intro rel_comp_le_self_if_transitive)
   have "(R \<circ>\<circ> S \<circ>\<circ> R) \<le> (S \<circ>\<circ> R \<circ>\<circ> R)"
     using monoD[OF mono_rel_comp1 R_S_le] by blast
   also have "... \<le> (S \<circ>\<circ> R)"
     using monoD[OF mono_rel_comp2 R_R_le] by (auto simp flip: rel_comp_assoc)
   finally show ?thesis .
 qed
 
 lemma rel_comp_comp_le_rel_comp_if_rel_comp_le_if_transitive':
   assumes trans_R: "transitive R"
   and S_R_le: "(S \<circ>\<circ> R) \<le> (R \<circ>\<circ> S)"
   shows "(R \<circ>\<circ> S \<circ>\<circ> R) \<le> (R \<circ>\<circ> S)"
 proof -
   from trans_R have R_R_le: "(R \<circ>\<circ> R) \<le> R" by (intro rel_comp_le_self_if_transitive)
   have "(R \<circ>\<circ> S \<circ>\<circ> R) \<le> (R \<circ>\<circ> R \<circ>\<circ> S)"
     using monoD[OF mono_rel_comp2 S_R_le] by (auto simp flip: rel_comp_assoc)
   also have "... \<le> (R \<circ>\<circ> S)" using monoD[OF mono_rel_comp1 R_R_le] by blast
   finally show ?thesis .
 qed
 
 lemma rel_comp_eq_rel_comp_if_le_if_transitive_if_reflexive:
   assumes refl_R: "reflexive_on (in_field S) R"
   and trans_S: "transitive S"
   and R_le: "R \<le> S \<squnion> (=)"
   shows "(R \<circ>\<circ> S) = (S \<circ>\<circ> R)"
 proof (intro ext iffI)
   fix x y assume "(R \<circ>\<circ> S) x y"
   then obtain z where "R x z" "S z y" by blast
   with R_le have "(S \<squnion> (=)) x z" by blast
   with \<open>S z y\<close> trans_S have "S x y" by auto
   moreover from \<open>S z y\<close> refl_R have "R y y" by blast
   ultimately show "(S \<circ>\<circ> R) x y" by blast
 next
   fix x y assume "(S \<circ>\<circ> R) x y"
   then obtain z where "S x z" "R z y" by blast
   with R_le have "(S \<squnion> (=)) z y" by blast
   with \<open>S x z\<close> trans_S have "S x y" by auto
   moreover from \<open>S x y\<close> refl_R have "R x x" by blast
   ultimately show "(R \<circ>\<circ> S) x y" by blast
 qed
 
 lemma rel_comp_eq_rel_comp_if_in_field_le_if_le_eq:
   assumes le_eq: "R \<le> (=)"
   and in_field_le: "in_field S \<le> in_field R"
   shows "(R \<circ>\<circ> S) = (S \<circ>\<circ> R)"
 proof (intro ext iffI)
   fix x y assume "(R \<circ>\<circ> S) x y"
   then obtain z where "R x z" "S z y" by blast
   with le_eq have "S x y" by blast
   with assms show "(S \<circ>\<circ> R) x y" by blast
 next
   fix x y assume "(S \<circ>\<circ> R) x y"
   then obtain z where "S x z" "R z y" by blast
   with le_eq have "S x y" by blast
   with assms show "(R \<circ>\<circ> S) x y" by blast
 qed
 
 context transport_comp
 begin
 
 lemma left2_right1_left2_le_left2_right1_if_right1_left2_right1_le_left2_right1:
   assumes "reflexive_on (in_codom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   and "in_codom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_codom (\<le>\<^bsub>R1\<^esub>)"
   shows "((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   using assms by (intro rel_comp_comp_le_rel_comp_if_rel_comp_comp_if_in_codom_leI)
   auto
 
 lemma left2_right1_left2_le_right1_left2_if_right1_left2_right1_le_right1_left2I:
   assumes "reflexive_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   and "in_dom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_dom (\<le>\<^bsub>R1\<^esub>)"
   shows "((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   using assms by (intro rel_comp_comp_le_rel_comp_if_rel_comp_comp_if_in_dom_leI)
   auto
 
 lemma in_dom_right1_left2_right1_le_if_right1_left2_right1_le:
   assumes "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   shows "in_dom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_dom (\<le>\<^bsub>L2\<^esub>)"
   using monoD[OF mono_in_dom assms] by (auto intro: in_dom_if_in_dom_rel_comp)
 
 lemma in_codom_right1_left2_right1_le_if_right1_left2_right1_le:
   assumes "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   shows "in_codom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_codom (\<le>\<^bsub>L2\<^esub>)"
   using monoD[OF mono_in_codom assms]
   by (auto intro: in_codom_if_in_codom_rel_comp)
 
 text \<open>Our main results will be derivable for two different sets of compatibility
 conditions. The next two lemmas show the equivalence between those two sets
 under certain assumptions. In cases where these assumptions are met, we will
 only state the result for one of the two compatibility conditions. The other one
 will then be derivable using one of the following lemmas.\<close>
 
 definition "middle_compatible_dom \<equiv>
   (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<le> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)
   \<and> in_dom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_dom (\<le>\<^bsub>L2\<^esub>)
   \<and> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))
   \<and> in_dom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_dom (\<le>\<^bsub>R1\<^esub>)"
 
 lemma middle_compatible_domI [intro]:
   assumes "(\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<le> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)"
   and "in_dom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_dom (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   and "in_dom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_dom (\<le>\<^bsub>R1\<^esub>)"
   shows "middle_compatible_dom"
   unfolding middle_compatible_dom_def using assms by blast
 
 lemma middle_compatible_domE [elim]:
   assumes "middle_compatible_dom"
   obtains "(\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<le> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)"
   and "in_dom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_dom (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   and "in_dom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_dom (\<le>\<^bsub>R1\<^esub>)"
   using assms unfolding middle_compatible_dom_def by blast
 
 definition "middle_compatible_codom \<equiv>
   ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))
   \<and> in_codom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_codom (\<le>\<^bsub>L2\<^esub>)
   \<and> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<le> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)
   \<and> in_codom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_codom (\<le>\<^bsub>R1\<^esub>)"
 
 lemma middle_compatible_codomI [intro]:
   assumes "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   and "in_codom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_codom (\<le>\<^bsub>L2\<^esub>)"
   and "(\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<le> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)"
   and "in_codom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_codom (\<le>\<^bsub>R1\<^esub>)"
   shows "middle_compatible_codom"
   unfolding middle_compatible_codom_def using assms by blast
 
 lemma middle_compatible_codomE [elim]:
   assumes "middle_compatible_codom"
   obtains "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   and "in_codom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_codom (\<le>\<^bsub>L2\<^esub>)"
   and "(\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<le> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)"
   and "in_codom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_codom (\<le>\<^bsub>R1\<^esub>)"
   using assms unfolding middle_compatible_codom_def by blast
 
 context
 begin
 
 interpretation flip : transport_comp R2 L2 r2 l2 R1 L1 r1 l1 .
 
 lemma rel_comp_comp_le_assms_if_in_codom_rel_comp_comp_leI:
   assumes "preorder_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "preorder_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and "middle_compatible_codom"
   shows "middle_compatible_dom"
   using assms by (intro middle_compatible_domI)
   (auto intro!:
     left2_right1_left2_le_left2_right1_if_right1_left2_right1_le_left2_right1
     flip.left2_right1_left2_le_left2_right1_if_right1_left2_right1_le_left2_right1
     in_dom_right1_left2_right1_le_if_right1_left2_right1_le
     flip.in_dom_right1_left2_right1_le_if_right1_left2_right1_le
     intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_codom)
 
 lemma rel_comp_comp_le_assms_if_in_dom_rel_comp_comp_leI:
   assumes "preorder_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "preorder_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and "middle_compatible_dom"
   shows "middle_compatible_codom"
   using assms by (intro middle_compatible_codomI)
   (auto intro!:
     left2_right1_left2_le_right1_left2_if_right1_left2_right1_le_right1_left2I
     flip.left2_right1_left2_le_right1_left2_if_right1_left2_right1_le_right1_left2I
     in_codom_right1_left2_right1_le_if_right1_left2_right1_le
     flip.in_codom_right1_left2_right1_le_if_right1_left2_right1_le
     intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_dom)
 
 lemma middle_compatible_dom_iff_middle_compatible_codom_if_preorder_on:
   assumes "preorder_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "preorder_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   shows "middle_compatible_dom \<longleftrightarrow> middle_compatible_codom"
   using assms by (intro iffI rel_comp_comp_le_assms_if_in_codom_rel_comp_comp_leI)
   (auto intro!: rel_comp_comp_le_assms_if_in_dom_rel_comp_comp_leI)
 
 end
 
 text \<open>Finally we derive some sufficient assumptions for the compatibility
 conditions.\<close>
 
 lemma right1_left2_right1_le_assms_if_right1_left2_eqI:
   assumes "transitive (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) = ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   shows "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   using assms rel_comp_comp_le_rel_comp_if_rel_comp_le_if_transitive[of R1 L2]
   by auto
 
 interpretation flip : transport_comp R2 L2 r2 l2 R1 L1 r1 l1
   rewrites "((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) = ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<equiv> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) = ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   by (simp only: eq_commute)
 
 lemma middle_compatible_codom_if_rel_comp_eq_if_transitive:
   assumes "transitive (\<le>\<^bsub>R1\<^esub>)" "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) = ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   shows "middle_compatible_codom"
   using assms by (intro middle_compatible_codomI
     in_codom_right1_left2_right1_le_if_right1_left2_right1_le
     flip.in_codom_right1_left2_right1_le_if_right1_left2_right1_le
     right1_left2_right1_le_assms_if_right1_left2_eqI
     flip.right1_left2_right1_le_assms_if_right1_left2_eqI)
   auto
 
 lemma middle_compatible_codom_if_right1_le_left2_eqI:
   assumes "preorder_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)" "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "(\<le>\<^bsub>R1\<^esub>) \<le> (\<le>\<^bsub>L2\<^esub>) \<squnion> (=)"
   and "in_field (\<le>\<^bsub>L2\<^esub>) \<le> in_field (\<le>\<^bsub>R1\<^esub>)"
   shows "middle_compatible_codom"
   using assms by (intro middle_compatible_codomI
     in_codom_right1_left2_right1_le_if_right1_left2_right1_le
     flip.in_codom_right1_left2_right1_le_if_right1_left2_right1_le
     right1_left2_right1_le_assms_if_right1_left2_eqI
     flip.right1_left2_right1_le_assms_if_right1_left2_eqI
     rel_comp_eq_rel_comp_if_le_if_transitive_if_reflexive)
   (auto intro: reflexive_on_if_le_pred_if_reflexive_on)
 
 lemma middle_compatible_codom_if_right1_le_eqI:
   assumes "(\<le>\<^bsub>R1\<^esub>) \<le> (=)"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "in_field (\<le>\<^bsub>L2\<^esub>) \<le> in_field (\<le>\<^bsub>R1\<^esub>)"
   shows "middle_compatible_codom"
   using assms by (intro middle_compatible_codomI
     in_codom_right1_left2_right1_le_if_right1_left2_right1_le
     flip.in_codom_right1_left2_right1_le_if_right1_left2_right1_le
     right1_left2_right1_le_assms_if_right1_left2_eqI
     flip.right1_left2_right1_le_assms_if_right1_left2_eqI
     rel_comp_eq_rel_comp_if_in_field_le_if_le_eq)
   auto
 
 end
 
 
 end
diff --git a/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Galois_Relator.thy b/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Galois_Relator.thy
--- a/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Galois_Relator.thy
+++ b/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Galois_Relator.thy
@@ -1,151 +1,151 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Galois Relator\<close>
 theory Transport_Compositions_Generic_Galois_Relator
   imports
     Transport_Compositions_Generic_Base
 begin
 
 context transport_comp
 begin
 
 interpretation flip : transport_comp R2 L2 r2 l2 R1 L1 r1 l1
   rewrites "flip.t2.unit \<equiv> \<epsilon>\<^sub>1"
   by (simp only: t1.flip_unit_eq_counit)
 
 lemma left_Galois_le_comp_left_GaloisI:
   assumes mono_r1: "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and galois_prop1: "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and preorder_R1: "preorder_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and rel_comp_le: "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   and mono_in_codom_r2: "([in_codom (\<le>\<^bsub>R\<^esub>)] \<Rrightarrow>\<^sub>m in_codom (\<le>\<^bsub>R1\<^esub>)) r2"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) \<le> ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
 proof (rule le_relI)
   fix x z assume "x \<^bsub>L\<^esub>\<lessapprox> z"
   then have "in_codom (\<le>\<^bsub>R\<^esub>) z" "x \<le>\<^bsub>L\<^esub> r z" by auto
   with galois_prop1 obtain y y' where "in_dom (\<le>\<^bsub>L1\<^esub>) x" "l1 x \<le>\<^bsub>R1\<^esub> y" "y \<le>\<^bsub>L2\<^esub> y'" "y' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 (r2 z)"
     by (auto elim!: left_relE)
   moreover  have "\<epsilon>\<^sub>1 (r2 z) \<le>\<^bsub>R1\<^esub> r2 z"
   proof -
     from mono_in_codom_r2 \<open>in_codom (\<le>\<^bsub>R\<^esub>) z\<close> have "in_codom (\<le>\<^bsub>R1\<^esub>) (r2 z)" by blast
     with mono_r1 galois_prop1 preorder_R1 show ?thesis by (blast intro!:
       t1.counit_rel_if_reflexive_on_if_half_galois_prop_left_if_mono_wrt_rel)
   qed
   ultimately have "y' \<le>\<^bsub>R1\<^esub> r2 z" using preorder_R1 by blast
   with \<open>l1 x \<le>\<^bsub>R1\<^esub> y\<close> \<open>y \<le>\<^bsub>L2\<^esub> y'\<close> have "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) (l1 x) (r2 z)"
     by blast
   with rel_comp_le obtain y'' where "l1 x \<le>\<^bsub>R1\<^esub> y''" "y'' \<le>\<^bsub>L2\<^esub> r2 z" by blast
   with galois_prop1 \<open>in_dom (\<le>\<^bsub>L1\<^esub>) x\<close>  have "x \<^bsub>L1\<^esub>\<lessapprox> y''"
     by (intro t1.left_Galois_if_Galois_right_if_half_galois_prop_right t1.left_GaloisI)
     auto
   moreover from \<open>in_codom (\<le>\<^bsub>R\<^esub>) z\<close> \<open>y'' \<le>\<^bsub>L2\<^esub> r2 z\<close> have "y'' \<^bsub>L2\<^esub>\<lessapprox> z"
     by (intro t2.left_GaloisI) auto
   ultimately show "((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>)) x z" by blast
 qed
 
 lemma comp_left_Galois_le_left_GaloisI:
   assumes mono_r1: "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and half_galois_prop_left1: "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and half_galois_prop_right1: "((\<le>\<^bsub>R1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>L1\<^esub>)) r1 l1"
   and refl_R1: "reflexive_on (in_codom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and mono_l2: "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and refl_L2: "reflexive_on (in_dom (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and in_codom_rel_comp_le: "in_codom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_codom (\<le>\<^bsub>R1\<^esub>)"
   shows "((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>)) \<le> (\<^bsub>L\<^esub>\<lessapprox>)"
 proof (intro le_relI left_GaloisI)
   fix x z assume "((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>)) x z"
   from \<open>((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>)) x z\<close> obtain y where "x \<^bsub>L1\<^esub>\<lessapprox> y" "y \<^bsub>L2\<^esub>\<lessapprox> z" by blast
   with half_galois_prop_left1 have "l1 x \<le>\<^bsub>R1\<^esub> y" "y \<le>\<^bsub>L2\<^esub> r2 z" by auto
   with refl_R1 refl_L2 have "y \<le>\<^bsub>R1\<^esub> y" "y \<le>\<^bsub>L2\<^esub> y" by auto
   show "in_codom (\<le>\<^bsub>R\<^esub>) z"
   proof (intro in_codomI flip.left_relI)
     from mono_l2 \<open>y \<le>\<^bsub>L2\<^esub> y\<close> show "l2 y \<^bsub>R2\<^esub>\<lessapprox> y" by blast
     show "y \<le>\<^bsub>R1\<^esub> y" "y \<^bsub>L2\<^esub>\<lessapprox> z" by fact+
   qed
   show "x \<le>\<^bsub>L\<^esub> r z"
   proof (intro left_relI)
     show "x \<^bsub>L1\<^esub>\<lessapprox> y" "y \<le>\<^bsub>L2\<^esub> r2 z" by fact+
     show "r2 z \<^bsub>R1\<^esub>\<lessapprox> r z"
     proof (intro flip.t2.left_GaloisI)
       from \<open>y \<le>\<^bsub>L2\<^esub> y\<close> \<open>y \<le>\<^bsub>R1\<^esub> y\<close> \<open>y \<le>\<^bsub>L2\<^esub> r2 z\<close> have "((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) y (r2 z)"
         by blast
       with in_codom_rel_comp_le have "in_codom (\<le>\<^bsub>R1\<^esub>) (r2 z)" by blast
       with refl_R1 have "r2 z \<le>\<^bsub>R1\<^esub> r2 z" by blast
       with mono_r1 show "in_codom (\<le>\<^bsub>L1\<^esub>) (r z)" by auto
       with \<open>r2 z \<le>\<^bsub>R1\<^esub> r2 z\<close>  half_galois_prop_right1 mono_r1
-        show "r2 z \<le>\<^bsub>R1\<^esub> l1 (r z)" by (auto intro:
+        show "r2 z \<le>\<^bsub>R1\<^esub> l1 (r z)" by (fastforce intro:
         flip.t2.rel_unit_if_left_rel_if_half_galois_prop_right_if_mono_wrt_rel)
     qed
   qed
 qed
 
 corollary left_Galois_eq_comp_left_GaloisI:
   assumes "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>R1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>L1\<^esub>)) r1 l1"
   and "preorder_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and "reflexive_on (in_dom (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   and "([in_codom (\<le>\<^bsub>R\<^esub>)] \<Rrightarrow>\<^sub>m in_codom (\<le>\<^bsub>R1\<^esub>)) r2"
   and "in_codom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_codom (\<le>\<^bsub>R1\<^esub>)"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
   using assms
   by (intro antisym left_Galois_le_comp_left_GaloisI comp_left_Galois_le_left_GaloisI)
   (auto elim!: preorder_on_in_fieldE
     intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_codom)
 
 corollary left_Galois_eq_comp_left_GaloisI':
   assumes "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>R1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>L1\<^esub>)) r1 l1"
   and "preorder_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and "((\<le>\<^bsub>R2\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L2\<^esub>)) r2 l2"
   and "reflexive_on (in_dom (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   and "in_codom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_codom (\<le>\<^bsub>R1\<^esub>)"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
   using assms by (intro left_Galois_eq_comp_left_GaloisI
     flip.mono_in_codom_left_rel_left1_if_in_codom_rel_comp_le)
   auto
 
 theorem left_Galois_eq_comp_left_Galois_if_galois_connection_if_galois_equivalenceI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "preorder_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>R2\<^esub>) \<stileturn> (\<le>\<^bsub>L2\<^esub>)) r2 l2"
   and "reflexive_on (in_dom (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   and "in_codom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_codom (\<le>\<^bsub>R1\<^esub>)"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
   using assms by (intro left_Galois_eq_comp_left_GaloisI')
   (auto elim!: t1.galois_equivalenceE)
 
 corollary left_Galois_eq_comp_left_Galois_if_galois_connection_if_galois_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "preorder_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>R2\<^esub>) \<stileturn> (\<le>\<^bsub>L2\<^esub>)) r2 l2"
   and "reflexive_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and "in_codom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_codom (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   and "in_codom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_codom (\<le>\<^bsub>R1\<^esub>)"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
   using assms
   by (intro left_Galois_eq_comp_left_Galois_if_galois_connection_if_galois_equivalenceI'
     flip.left2_right1_left2_le_left2_right1_if_right1_left2_right1_le_left2_right1)
   auto
 
 corollary left_Galois_eq_comp_left_Galois_if_preorder_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>R2\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>L2\<^esub>)) r2 l2"
   and "in_codom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_codom (\<le>\<^bsub>L2\<^esub>)"
   and "(\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<le> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)"
   and "in_codom ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) \<le> in_codom (\<le>\<^bsub>R1\<^esub>)"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<circ>\<circ> (\<^bsub>L2\<^esub>\<lessapprox>))"
   using assms by (intro
     left_Galois_eq_comp_left_Galois_if_galois_connection_if_galois_equivalenceI)
   auto
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Monotone.thy b/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Monotone.thy
--- a/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Monotone.thy
+++ b/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Monotone.thy
@@ -1,57 +1,57 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Monotonicity\<close>
 theory Transport_Compositions_Generic_Monotone
   imports
     Transport_Compositions_Generic_Base
 begin
 
 context transport_comp
 begin
 
 lemma mono_wrt_rel_leftI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and inflationary_unit2: "inflationary_on (in_codom (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>) \<eta>\<^sub>2"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   and "in_codom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_codom (\<le>\<^bsub>L2\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
 proof (rule dep_mono_wrt_relI)
   fix x x' assume "x \<le>\<^bsub>L\<^esub> x'"
   then show "l x \<le>\<^bsub>R\<^esub> l x'"
   proof (rule right_rel_if_left_relI)
     fix y' assume "l1 x \<le>\<^bsub>L2\<^esub> y'"
     with \<open>((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2\<close> show "l x \<le>\<^bsub>R2\<^esub> l2 y'" by auto
   next
     assume "in_codom (\<le>\<^bsub>L2\<^esub>) (l1 x')"
     with inflationary_unit2 show "l1 x' \<le>\<^bsub>L2\<^esub> r2 (l x')" by auto
     from \<open>in_codom (\<le>\<^bsub>L2\<^esub>) (l1 x')\<close> \<open>((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2\<close>
-      show "in_codom (\<le>\<^bsub>R2\<^esub>) (l x')" by auto
+      show "in_codom (\<le>\<^bsub>R2\<^esub>) (l x')" by fastforce
   qed (insert assms, auto)
 qed
 
 lemma mono_wrt_rel_leftI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and "((\<le>\<^bsub>L2\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   and refl_L2: "reflexive_on (in_dom (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   and "in_dom ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> in_dom (\<le>\<^bsub>L2\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
 proof (rule dep_mono_wrt_relI)
   fix x x' assume "x \<le>\<^bsub>L\<^esub> x'"
   then show "l x \<le>\<^bsub>R\<^esub> l x'"
   proof (rule right_rel_if_left_relI')
     fix y' assume "y' \<le>\<^bsub>L2\<^esub> l1 x'"
     moreover with \<open>((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2\<close> have "l2 y' \<le>\<^bsub>R2\<^esub> l x'" by auto
     ultimately show "in_codom (\<le>\<^bsub>R2\<^esub>) (l x')" "y' \<le>\<^bsub>L2\<^esub> r2 (l x')"
       using \<open>((\<le>\<^bsub>L2\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R2\<^esub>)) l2 r2\<close> by auto
   next
     assume "in_dom (\<le>\<^bsub>L2\<^esub>) (l1 x)"
     with refl_L2 \<open>((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2\<close> show "l x \<le>\<^bsub>R2\<^esub> l2 (l1 x)" by auto
   qed (insert assms, auto)
 qed
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Order_Base.thy b/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Order_Base.thy
--- a/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Order_Base.thy
+++ b/thys/Transport/Transport/Compositions/Generic/Transport_Compositions_Generic_Order_Base.thy
@@ -1,237 +1,237 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Basic Order Properties\<close>
 theory Transport_Compositions_Generic_Order_Base
   imports
    Transport_Compositions_Generic_Base
 begin
 
 context transport_comp
 begin
 
 interpretation flip1 : galois R1 L1 r1 l1 .
 
 subsubsection \<open>Reflexivity\<close>
 
 lemma reflexive_on_in_dom_leftI:
   assumes galois_prop: "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and in_dom_L1_le: "in_dom (\<le>\<^bsub>L1\<^esub>) \<le> in_codom (\<le>\<^bsub>L1\<^esub>)"
   and refl_R1: "reflexive_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and refl_L2: "reflexive_on (in_dom (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and mono_in_dom_l1: "([in_dom (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m in_dom (\<le>\<^bsub>L2\<^esub>)) l1"
   shows "reflexive_on (in_dom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
 proof (rule reflexive_onI)
   fix x assume "in_dom (\<le>\<^bsub>L\<^esub>) x"
   then obtain x' where "x \<le>\<^bsub>L\<^esub> x'" "in_dom (\<le>\<^bsub>L1\<^esub>) x" by blast
   show "x \<le>\<^bsub>L\<^esub> x"
   proof (rule left_relI)
     from refl_R1 have "l1 x \<le>\<^bsub>R1\<^esub> l1 x"
     proof (rule reflexive_onD)
       from \<open>x \<le>\<^bsub>L\<^esub> x'\<close> galois_prop show "in_dom (\<le>\<^bsub>R1\<^esub>) (l1 x)" by blast
     qed
     then show "x \<^bsub>L1\<^esub>\<lessapprox> l1 x"
     proof (intro t1.left_GaloisI)
       from galois_prop \<open>in_dom (\<le>\<^bsub>L1\<^esub>) x\<close> \<open>l1 x \<le>\<^bsub>R1\<^esub> l1 x\<close> show "x \<le>\<^bsub>L1\<^esub> r1 (l1 x)" by blast
     qed blast
     from refl_L2 show "l1 x \<le>\<^bsub>L2\<^esub> l1 x"
     proof (rule reflexive_onD)
       from mono_in_dom_l1 \<open>x \<le>\<^bsub>L\<^esub> x'\<close> show "in_dom (\<le>\<^bsub>L2\<^esub>) (l1 x)" by blast
     qed
     from \<open>l1 x \<le>\<^bsub>R1\<^esub> l1 x\<close> show "l1 x \<^bsub>R1\<^esub>\<lessapprox> x"
     proof (intro flip1.left_GaloisI)
       from \<open>in_dom (\<le>\<^bsub>L1\<^esub>) x\<close> in_dom_L1_le show "in_codom (\<le>\<^bsub>L1\<^esub>) x" by blast
     qed
   qed
 qed
 
 lemma reflexive_on_in_codom_leftI:
   assumes L1_r1_l1I: "\<And>x. in_dom (\<le>\<^bsub>L1\<^esub>) x \<Longrightarrow> l1 x \<le>\<^bsub>R1\<^esub> l1 x \<Longrightarrow> x \<le>\<^bsub>L1\<^esub> r1 (l1 x)"
   and in_codom_L1_le: "in_codom (\<le>\<^bsub>L1\<^esub>) \<le> in_dom (\<le>\<^bsub>L1\<^esub>)"
   and refl_R1: "reflexive_on (in_codom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and refl_L2: "reflexive_on (in_codom (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and mono_in_codom_l1: "([in_codom (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m in_codom (\<le>\<^bsub>L2\<^esub>)) l1"
   shows "reflexive_on (in_codom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
 proof (rule reflexive_onI)
   fix x assume "in_codom (\<le>\<^bsub>L\<^esub>) x"
   then obtain x' where "x' \<le>\<^bsub>L\<^esub> x" "in_codom (\<le>\<^bsub>L1\<^esub>) x" "in_codom (\<le>\<^bsub>R1\<^esub>) (l1 x)"
     by blast
   show "x \<le>\<^bsub>L\<^esub> x"
   proof (rule left_relI)
     from refl_R1 \<open>in_codom (\<le>\<^bsub>R1\<^esub>) (l1 x)\<close> have "l1 x \<le>\<^bsub>R1\<^esub> l1 x" by blast
     show "x \<^bsub>L1\<^esub>\<lessapprox> l1 x"
     proof (rule t1.left_GaloisI)
       from in_codom_L1_le \<open>in_codom (\<le>\<^bsub>L1\<^esub>) x\<close> have "in_dom (\<le>\<^bsub>L1\<^esub>) x" by blast
       with \<open>l1 x \<le>\<^bsub>R1\<^esub> l1 x\<close> show "x \<le>\<^bsub>L1\<^esub> r1 (l1 x)" by (intro L1_r1_l1I)
     qed fact
     from refl_L2 show "l1 x \<le>\<^bsub>L2\<^esub> l1 x"
     proof (rule reflexive_onD)
       from mono_in_codom_l1 \<open>x' \<le>\<^bsub>L\<^esub> x\<close> show "in_codom (\<le>\<^bsub>L2\<^esub>) (l1 x)" by blast
     qed
     show "l1 x \<^bsub>R1\<^esub>\<lessapprox> x" by (rule flip1.left_GaloisI) fact+
   qed
 qed
 
 corollary reflexive_on_in_field_leftI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "in_codom (\<le>\<^bsub>L1\<^esub>) = in_dom (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and "([in_field (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m in_field (\<le>\<^bsub>L2\<^esub>)) l1"
   shows "reflexive_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
 proof -
   from assms have "reflexive_on (in_dom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
     by (intro reflexive_on_in_dom_leftI)
-    (auto 0 4 intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_dom)
+    (auto 0 5 intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_dom)
   moreover from assms have "reflexive_on (in_codom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
     by (intro reflexive_on_in_codom_leftI)
-    (auto 0 4 intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_codom)
+    (auto 0 5 intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_codom)
   ultimately show ?thesis by (auto iff: in_field_iff_in_dom_or_in_codom)
 qed
 
 
 subsubsection \<open>Transitivity\<close>
 
 text\<open>There are many similar proofs for transitivity. They slightly differ in
 their assumptions, particularly which of @{term "(\<le>\<^bsub>R1\<^esub>)"} and @{term "(\<le>\<^bsub>L2\<^esub>)"} has
 to be transitive and the order of commutativity for the relations.
 
 In the following, we just give two of them that suffice for many purposes.\<close>
 
 lemma transitive_leftI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and trans_L2: "transitive (\<le>\<^bsub>L2\<^esub>)"
   and R1_L2_R1_le: "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   shows "transitive (\<le>\<^bsub>L\<^esub>)"
 proof (rule transitiveI)
   fix x1 x2 x3 assume "x1 \<le>\<^bsub>L\<^esub> x2" "x2 \<le>\<^bsub>L\<^esub> x3"
   from \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> obtain y1 y2 where "x1 \<^bsub>L1\<^esub>\<lessapprox> y1" "y1 \<le>\<^bsub>L2\<^esub> y2" "y2 \<le>\<^bsub>R1\<^esub> l1 x2"
     by blast
   from \<open>x2 \<le>\<^bsub>L\<^esub> x3\<close> \<open>((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1\<close> obtain y3 y4 where
     "l1 x2 \<le>\<^bsub>R1\<^esub> y3" "y3 \<le>\<^bsub>L2\<^esub> y4" "y4 \<le>\<^bsub>R1\<^esub> l1 x3" "in_codom (\<le>\<^bsub>L1\<^esub>) x3" by blast
   with R1_L2_R1_le have "((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) (l1 x2) (l1 x3)" by blast
   then obtain y where "l1 x2 \<le>\<^bsub>L2\<^esub> y" "y \<le>\<^bsub>R1\<^esub> l1 x3" by blast
   with \<open>y2 \<le>\<^bsub>R1\<^esub> l1 x2\<close> R1_L2_R1_le have "((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) y2 (l1 x3)" by blast
   then obtain y' where "y2 \<le>\<^bsub>L2\<^esub> y'" "y' \<le>\<^bsub>R1\<^esub> l1 x3" by blast
   with \<open>y1 \<le>\<^bsub>L2\<^esub> y2\<close> have "y1 \<le>\<^bsub>L2\<^esub> y'" using trans_L2 by blast
   show "x1 \<le>\<^bsub>L\<^esub> x3"
   proof (rule left_relI)
     show "x1 \<^bsub>L1\<^esub>\<lessapprox> y1" "y1 \<le>\<^bsub>L2\<^esub> y'" by fact+
     show "y' \<^bsub>R1\<^esub>\<lessapprox> x3" by (rule flip1.left_GaloisI) fact+
   qed
 qed
 
 lemma transitive_leftI':
   assumes galois_prop: "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and trans_L2: "transitive (\<le>\<^bsub>L2\<^esub>)"
   and R1_L2_R1_le: "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   shows "transitive (\<le>\<^bsub>L\<^esub>)"
 proof (rule transitiveI)
   fix x1 x2 x3 assume "x1 \<le>\<^bsub>L\<^esub> x2" "x2 \<le>\<^bsub>L\<^esub> x3"
   from \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> galois_prop obtain y1 y2 where
     "in_dom (\<le>\<^bsub>L1\<^esub>) x1" "l1 x1 \<le>\<^bsub>R1\<^esub> y1" "y1 \<le>\<^bsub>L2\<^esub> y2" "y2 \<le>\<^bsub>R1\<^esub> l1 x2" by blast
   with R1_L2_R1_le have "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) (l1 x1) (l1 x2)" by blast
   then obtain y where "l1 x1 \<le>\<^bsub>R1\<^esub> y" "y \<le>\<^bsub>L2\<^esub> l1 x2" by blast
   moreover from \<open>x2 \<le>\<^bsub>L\<^esub> x3\<close> galois_prop obtain y3 y4 where
     "l1 x2 \<le>\<^bsub>R1\<^esub> y3" "y3 \<le>\<^bsub>L2\<^esub> y4" "y4 \<^bsub>R1\<^esub>\<lessapprox> x3" by blast
   moreover note R1_L2_R1_le
   ultimately have "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>)) (l1 x1) y3" by blast
   then obtain y' where "l1 x1 \<le>\<^bsub>R1\<^esub> y'" "y' \<le>\<^bsub>L2\<^esub> y3" by blast
   with \<open>y3 \<le>\<^bsub>L2\<^esub> y4\<close> have "y' \<le>\<^bsub>L2\<^esub> y4" using trans_L2 by blast
   show "x1 \<le>\<^bsub>L\<^esub> x3"
   proof (rule left_relI)
     from \<open>in_dom (\<le>\<^bsub>L1\<^esub>) x1\<close> \<open>l1 x1 \<le>\<^bsub>R1\<^esub> y'\<close> galois_prop show "x1 \<^bsub>L1\<^esub>\<lessapprox> y'"
       by (intro t1.left_Galois_if_Galois_right_if_half_galois_prop_right t1.left_GaloisI)
       auto
     show "y' \<le>\<^bsub>L2\<^esub> y4" by fact
     from \<open>y' \<le>\<^bsub>L2\<^esub> y4\<close> \<open>y4 \<^bsub>R1\<^esub>\<lessapprox> x3\<close> show "y4 \<^bsub>R1\<^esub>\<lessapprox> x3" by blast
   qed
 qed
 
 
 subsubsection \<open>Preorders\<close>
 
 lemma preorder_on_in_field_leftI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "in_codom (\<le>\<^bsub>L1\<^esub>) = in_dom (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "preorder_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and mono_in_codom_l1: "([in_codom (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m in_codom (\<le>\<^bsub>L2\<^esub>)) l1"
   and R1_L2_R1_le: "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   shows "preorder_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
 proof -
   have "([in_field (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m in_field (\<le>\<^bsub>L2\<^esub>)) l1"
   proof -
     from \<open>((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1\<close> R1_L2_R1_le
       have "([in_dom (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m in_dom (\<le>\<^bsub>L2\<^esub>)) l1"
       by (intro mono_in_dom_left_rel_left1_if_in_dom_rel_comp_le
         in_dom_right1_left2_right1_le_if_right1_left2_right1_le)
       auto
     with mono_in_codom_l1 show ?thesis by (intro dep_mono_wrt_predI) blast
   qed
   with assms show ?thesis by (intro preorder_onI)
     (auto intro: reflexive_on_in_field_leftI transitive_leftI)
 qed
 
 lemma preorder_on_in_field_leftI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "in_codom (\<le>\<^bsub>L1\<^esub>) = in_dom (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "preorder_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>)"
   and mono_in_dom_l1: "([in_dom (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m in_dom (\<le>\<^bsub>L2\<^esub>)) l1"
   and R1_L2_R1_le: "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   shows "preorder_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
 proof -
   have "([in_field (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m in_field (\<le>\<^bsub>L2\<^esub>)) l1"
   proof -
     from \<open>((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1\<close> R1_L2_R1_le
       have "([in_codom (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m in_codom (\<le>\<^bsub>L2\<^esub>)) l1"
       by (intro mono_in_codom_left_rel_left1_if_in_codom_rel_comp_le
         in_codom_right1_left2_right1_le_if_right1_left2_right1_le)
       auto
     with mono_in_dom_l1 show ?thesis by (intro dep_mono_wrt_predI) blast
   qed
   with assms show ?thesis by (intro preorder_onI)
     (auto intro: reflexive_on_in_field_leftI transitive_leftI')
 qed
 
 
 subsubsection \<open>Symmetry\<close>
 
 lemma symmetric_leftI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "in_codom (\<le>\<^bsub>L1\<^esub>) = in_dom (\<le>\<^bsub>L1\<^esub>)"
   and "symmetric (\<le>\<^bsub>R1\<^esub>)"
   and "symmetric (\<le>\<^bsub>L2\<^esub>)"
   shows "symmetric (\<le>\<^bsub>L\<^esub>)"
 proof -
   from assms have "(\<greaterapprox>\<^bsub>R1\<^esub>) = (\<^bsub>L1\<^esub>\<lessapprox>)" by (intro
     t1.ge_Galois_right_eq_left_Galois_if_symmetric_if_in_codom_eq_in_dom_if_galois_prop)
   moreover then have "(\<^bsub>R1\<^esub>\<lessapprox>) = (\<greaterapprox>\<^bsub>L1\<^esub>)"
     by (subst rel_inv_eq_iff_eq[symmetric]) simp
   ultimately show ?thesis using assms unfolding left_rel_eq_comp
     by (subst symmetric_iff_rel_inv_eq_self) (simp add: rel_comp_assoc)
 qed
 
 lemma partial_equivalence_rel_leftI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "in_codom (\<le>\<^bsub>L1\<^esub>) = in_dom (\<le>\<^bsub>L1\<^esub>)"
   and "symmetric (\<le>\<^bsub>R1\<^esub>)"
   and "partial_equivalence_rel (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>))"
   shows "partial_equivalence_rel (\<le>\<^bsub>L\<^esub>)"
   using assms by (intro partial_equivalence_relI transitive_leftI symmetric_leftI)
   auto
 
 lemma partial_equivalence_rel_leftI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "in_codom (\<le>\<^bsub>L1\<^esub>) = in_dom (\<le>\<^bsub>L1\<^esub>)"
   and "symmetric (\<le>\<^bsub>R1\<^esub>)"
   and "partial_equivalence_rel (\<le>\<^bsub>L2\<^esub>)"
   and "((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>) \<circ>\<circ> (\<le>\<^bsub>R1\<^esub>)) \<le> ((\<le>\<^bsub>R1\<^esub>) \<circ>\<circ> (\<le>\<^bsub>L2\<^esub>))"
   shows "partial_equivalence_rel (\<le>\<^bsub>L\<^esub>)"
   using assms by (intro partial_equivalence_relI transitive_leftI' symmetric_leftI)
   auto
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Examples/Prototype/Transport_Prototype.thy b/thys/Transport/Transport/Examples/Prototype/Transport_Prototype.thy
--- a/thys/Transport/Transport/Examples/Prototype/Transport_Prototype.thy
+++ b/thys/Transport/Transport/Examples/Prototype/Transport_Prototype.thy
@@ -1,168 +1,168 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 section \<open>Transport via Equivalences on PERs (Prototype)\<close>
 theory Transport_Prototype
   imports
     Transport_Rel_If
     ML_Unification.ML_Unification_HOL_Setup
     ML_Unification.Unify_Resolve_Tactics
   keywords "trp_term" :: thy_goal_defn
 begin
 
 paragraph \<open>Summary\<close>
 text \<open>We implement a simple Transport prototype. The prototype is restricted
 to work with equivalences on partial equivalence relations.
 It is also not forming the compositions of equivalences so far.
 The support for dependent function relators is restricted to the form
 described in
 @{thm transport_Dep_Fun_Rel_no_dep_fun.partial_equivalence_rel_equivalenceI}:
 The relations can be dependent, but the functions must be simple.
 This is not production ready, but a proof of concept.
 
 The package provides a command @{command trp_term}, which sets up the
 required goals to prove a given term. See the examples in this directory for
 some use cases and refer to \<^cite>\<open>"transport"\<close> for more details.\<close>
 
 paragraph \<open>Theorem Setups\<close>
 
 context transport
 begin
 
 lemma left_Galois_left_if_left_rel_if_partial_equivalence_rel_equivalence:
   assumes "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   and "x \<le>\<^bsub>L\<^esub> x'"
   shows "x \<^bsub>L\<^esub>\<lessapprox> l x"
   using assms by (intro left_Galois_left_if_left_rel_if_inflationary_on_in_fieldI)
   (blast elim: preorder_equivalence_order_equivalenceE)+
 
 definition "transport_per x y \<equiv> ((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r \<and> x \<^bsub>L\<^esub>\<lessapprox> y"
 
 text \<open>The choice of @{term "x'"} is arbitrary. All we need is @{term "in_dom (\<le>\<^bsub>L\<^esub>) x"}.\<close>
 lemma transport_per_start:
   assumes "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   and "x \<le>\<^bsub>L\<^esub> x'"
   shows "transport_per x (l x)"
   using assms unfolding transport_per_def
   by (blast intro: left_Galois_left_if_left_rel_if_partial_equivalence_rel_equivalence)
 
 lemma left_Galois_if_transport_per:
   assumes "transport_per x y"
   shows "x \<^bsub>L\<^esub>\<lessapprox> y"
   using assms unfolding transport_per_def by blast
 
 end
 
 context transport_Fun_Rel
 begin
 
 text \<open>Simplification of Galois relator for simple function relator.\<close>
 
 corollary left_Galois_eq_Fun_Rel_left_Galois:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>L2\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>))"
 proof (intro ext)
   fix f g
   show "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>)) f g"
   proof
     assume "f \<^bsub>L\<^esub>\<lessapprox> g"
     moreover have "g \<le>\<^bsub>R\<^esub> g"
     proof -
       from assms have per: "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
         by (intro partial_equivalence_rel_equivalenceI) auto
       with \<open>f \<^bsub>L\<^esub>\<lessapprox> g\<close> show ?thesis by blast
     qed
     ultimately show "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>)) f g" using assms
       by (intro Fun_Rel_left_Galois_if_left_GaloisI)
       (auto elim!: tdfrs.t1.partial_equivalence_rel_equivalenceE
         tdfrs.t1.preorder_equivalence_galois_equivalenceE
         tdfrs.t1.galois_equivalenceE
         intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_dom)
   next
     assume "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>)) f g"
     with assms have "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub> f g"
       by (subst Fun_Rel_left_Galois_restrict_left_right_eq_Fun_Rel_left_GaloisI) blast+
     with assms show "f \<^bsub>L\<^esub>\<lessapprox> g"
       by (intro left_Galois_if_Fun_Rel_left_GaloisI) blast+
   qed
 qed
 
 end
 
 lemmas related_Fun_Rel_combI = Dep_Fun_Rel_relD[where ?S="\<lambda>_ _. S" for S, rotated]
 lemma related_Fun_Rel_lambdaI:
   assumes "\<And>x y. R x y \<Longrightarrow> S (f x) (g y)"
   and "T = (R \<Rrightarrow> S)"
   shows "T f g"
   using assms by blast
 
 
 paragraph \<open>General ML setups\<close>
 ML_file\<open>transport_util.ML\<close>
 
 paragraph \<open>Unification Setup\<close>
 
 ML\<open>
   @{functor_instance struct_name = Transport_Unification_Combine
     and functor_name = Unification_Combine
     and id = Transport_Util.transport_id}
 \<close>
 local_setup \<open>Transport_Unification_Combine.setup_attribute NONE\<close>
 ML\<open>
   @{functor_instance struct_name = Transport_Mixed_Unification
     and functor_name = Mixed_Unification
     and id = Transport_Util.transport_id
     and more_args = \<open>structure UC = Transport_Unification_Combine\<close>}
 \<close>
 
 ML\<open>
   @{functor_instance struct_name = Transport_Unification_Hints
     and functor_name = Term_Index_Unification_Hints
     and id = Transport_Util.transport_id
     and more_args = \<open>
       structure TI = Discrimination_Tree
       val init_args = {
         concl_unifier = SOME Higher_Order_Pattern_Unification.unify,
-        normalisers = SOME Transport_Mixed_Unification.norms_first_higherp_first_comb_higher_unify,
         prems_unifier = SOME (Transport_Mixed_Unification.first_higherp_first_comb_higher_unify
           |> Unification_Combinator.norm_unifier Envir_Normalisation.beta_norm_term_unif),
+        normalisers = SOME Transport_Mixed_Unification.norms_first_higherp_first_comb_higher_unify,
         retrieval = SOME (Term_Index_Unification_Hints_Args.mk_sym_retrieval
           TI.norm_term TI.unifiables),
         hint_preprocessor = SOME (K I)
       }\<close>}
 \<close>
 local_setup \<open>Transport_Unification_Hints.setup_attribute NONE\<close>
 declare [[trp_uhint where hint_preprocessor = \<open>Unification_Hints_Base.obj_logic_hint_preprocessor
   @{thm atomize_eq[symmetric]} (Conv.rewr_conv @{thm eq_eq_True})\<close>]]
 declare [[trp_ucombine add = \<open>Transport_Unification_Combine.eunif_data
   (Transport_Unification_Hints.try_hints
   |> Unification_Combinator.norm_unifier
     (#norm_term Transport_Mixed_Unification.norms_first_higherp_first_comb_higher_unify)
   |> K)
   (Transport_Unification_Combine.default_metadata Transport_Unification_Hints.binding)\<close>]]
 
 paragraph \<open>Prototype\<close>
 ML_file\<open>transport.ML\<close>
 
 declare
   transport_Dep_Fun_Rel.transport_defs[trp_def]
   transport_Fun_Rel.transport_defs[trp_def]
 
 declare
   (*dependent case currently disabled by default since they easily make the
     unifier enumerate many undesired instantiations*)
   (* transport_Dep_Fun_Rel.partial_equivalence_rel_equivalenceI[per_intro] *)
   (* transport.rel_if_partial_equivalence_rel_equivalence_if_iff_if_partial_equivalence_rel_equivalenceI[rotated, per_intro]
   transport_Dep_Fun_Rel_no_dep_fun.partial_equivalence_rel_equivalenceI
     [ML_Krattr \<open>Conversion_Util.move_prems_to_front_conv [1] |> Conversion_Util.thm_conv\<close>,
     ML_Krattr \<open>Conversion_Util.move_prems_to_front_conv [2,3] |> Conversion_Util.thm_conv\<close>,
     per_intro] *)
   transport_Fun_Rel.partial_equivalence_rel_equivalenceI[rotated, per_intro]
   transport_eq_id.partial_equivalence_rel_equivalenceI[per_intro]
   transport_eq_restrict_id.partial_equivalence_rel_equivalence[per_intro]
 
 declare
   transport_id.left_Galois_eq_left[trp_relator_rewrite]
   transport_Fun_Rel.left_Galois_eq_Fun_Rel_left_Galois[trp_relator_rewrite]
 
 
 end
diff --git a/thys/Transport/Transport/Examples/Prototype/Transport_Rel_If.thy b/thys/Transport/Transport/Examples/Prototype/Transport_Rel_If.thy
--- a/thys/Transport/Transport/Examples/Prototype/Transport_Rel_If.thy
+++ b/thys/Transport/Transport/Examples/Prototype/Transport_Rel_If.thy
@@ -1,218 +1,218 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 section \<open>Transport for Dependent Function Relator with Non-Dependent Functions\<close>
 theory Transport_Rel_If
   imports
     Transport
 begin
 
 paragraph \<open>Summary\<close>
 text \<open>We introduce a special case of @{locale transport_Dep_Fun_Rel}.
 The derived theorem is easier to apply and supported by the current prototype.\<close>
 
 context
   fixes P :: "'a \<Rightarrow> bool" and R :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
 begin
 
 lemma reflexive_on_rel_if_if_reflexive_onI [intro]:
   assumes "B \<Longrightarrow> reflexive_on P R"
   shows "reflexive_on P (rel_if B R)"
   using assms by (intro reflexive_onI) blast
 
 lemma transitive_on_rel_if_if_transitive_onI [intro]:
   assumes "B \<Longrightarrow> transitive_on P R"
   shows "transitive_on P (rel_if B R)"
   using assms by (intro transitive_onI) (blast dest: transitive_onD)
 
 lemma preorder_on_rel_if_if_preorder_onI [intro]:
   assumes "B \<Longrightarrow> preorder_on P R"
   shows "preorder_on P (rel_if B R)"
   using assms by (intro preorder_onI) auto
 
 lemma symmetric_on_rel_if_if_symmetric_onI [intro]:
   assumes "B \<Longrightarrow> symmetric_on P R"
   shows "symmetric_on P (rel_if B R)"
   using assms by (intro symmetric_onI) (blast dest: symmetric_onD)
 
 lemma partial_equivalence_rel_on_rel_if_if_partial_equivalence_rel_onI [intro]:
   assumes "B \<Longrightarrow> partial_equivalence_rel_on P R"
   shows "partial_equivalence_rel_on P (rel_if B R)"
   using assms by (intro partial_equivalence_rel_onI)
   auto
 
 lemma rel_if_dep_mono_wrt_rel_if_iff_if_dep_mono_wrt_relI:
   assumes "B \<Longrightarrow> B' \<Longrightarrow> ([x y \<Colon> R] \<Rrightarrow>\<^sub>m S x y) f"
   and "B \<longleftrightarrow> B'"
   shows "([x y \<Colon> (rel_if B R)] \<Rrightarrow>\<^sub>m (rel_if B' (S x y))) f"
   using assms by (intro dep_mono_wrt_relI) auto
 
 end
 
 corollary reflexive_rel_if_if_reflexiveI [intro]:
   assumes "B \<Longrightarrow> reflexive R"
   shows "reflexive (rel_if B R)"
   using assms unfolding reflexive_eq_reflexive_on by blast
 
 corollary transitive_rel_if_if_transitiveI [intro]:
   assumes "B \<Longrightarrow> transitive R"
   shows "transitive (rel_if B R)"
   using assms unfolding transitive_eq_transitive_on by blast
 
 corollary preorder_rel_if_if_preorderI [intro]:
   assumes "B \<Longrightarrow> preorder R"
   shows "preorder (rel_if B R)"
   using assms unfolding preorder_eq_preorder_on by blast
 
 corollary symmetric_rel_if_if_symmetricI [intro]:
   assumes "B \<Longrightarrow> symmetric R"
   shows "symmetric (rel_if B R)"
   using assms unfolding symmetric_eq_symmetric_on by blast
 
 corollary partial_equivalence_rel_rel_if_if_partial_equivalence_relI [intro]:
   assumes "B \<Longrightarrow> partial_equivalence_rel R"
   shows "partial_equivalence_rel (rel_if B R)"
   using assms unfolding partial_equivalence_rel_eq_partial_equivalence_rel_on
   by blast
 
 context galois_prop
 begin
 
 interpretation rel_if : galois_prop "rel_if B (\<le>\<^bsub>L\<^esub>)" "rel_if B' (\<le>\<^bsub>R\<^esub>)" l r .
 interpretation flip_inv : galois_prop "(\<ge>\<^bsub>R\<^esub>)" "(\<ge>\<^bsub>L\<^esub>)" r l .
 
 lemma rel_if_half_galois_prop_left_if_iff_if_half_galois_prop_leftI:
   assumes "B \<Longrightarrow> B' \<Longrightarrow> ((\<le>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   and "B \<longleftrightarrow> B'"
   shows "((rel_if B (\<le>\<^bsub>L\<^esub>)) \<^sub>h\<unlhd> (rel_if B' (\<le>\<^bsub>R\<^esub>))) l r"
   using assms by (intro rel_if.half_galois_prop_leftI) auto
 
 lemma rel_if_half_galois_prop_right_if_iff_if_half_galois_prop_rightI:
   assumes "B \<Longrightarrow> B' \<Longrightarrow> ((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   and "B \<longleftrightarrow> B'"
   shows "((rel_if B (\<le>\<^bsub>L\<^esub>)) \<unlhd>\<^sub>h (rel_if B' (\<le>\<^bsub>R\<^esub>))) l r"
   using assms by (intro rel_if.half_galois_prop_rightI) fastforce
 
 lemma rel_if_galois_prop_if_iff_if_galois_propI:
   assumes "B \<Longrightarrow> B' \<Longrightarrow> ((\<le>\<^bsub>L\<^esub>) \<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   and "B \<longleftrightarrow> B'"
   shows "((rel_if B (\<le>\<^bsub>L\<^esub>)) \<unlhd> (rel_if B' (\<le>\<^bsub>R\<^esub>))) l r"
   using assms by (intro rel_if.galois_propI
     rel_if_half_galois_prop_left_if_iff_if_half_galois_prop_leftI
     rel_if_half_galois_prop_right_if_iff_if_half_galois_prop_rightI)
   auto
 
 end
 
 context galois
 begin
 
 interpretation rel_if : galois "rel_if B (\<le>\<^bsub>L\<^esub>)" "rel_if B' (\<le>\<^bsub>R\<^esub>)" l r .
 
 lemma rel_if_galois_connection_if_iff_if_galois_connectionI:
   assumes "B \<Longrightarrow> B' \<Longrightarrow> ((\<le>\<^bsub>L\<^esub>) \<stileturn> (\<le>\<^bsub>R\<^esub>)) l r"
   and "B \<longleftrightarrow> B'"
   shows "((rel_if B (\<le>\<^bsub>L\<^esub>)) \<stileturn> (rel_if B' (\<le>\<^bsub>R\<^esub>))) l r"
   using assms by (intro rel_if.galois_connectionI
     rel_if_dep_mono_wrt_rel_if_iff_if_dep_mono_wrt_relI
     rel_if_galois_prop_if_iff_if_galois_propI)
   auto
 
 lemma rel_if_galois_equivalence_if_iff_if_galois_equivalenceI:
   assumes "B \<Longrightarrow> B' \<Longrightarrow> ((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R\<^esub>)) l r"
   and "B \<longleftrightarrow> B'"
   shows "((rel_if B (\<le>\<^bsub>L\<^esub>)) \<equiv>\<^sub>G (rel_if B' (\<le>\<^bsub>R\<^esub>))) l r"
   using assms by (intro rel_if.galois_equivalenceI
     rel_if_galois_connection_if_iff_if_galois_connectionI
     galois_prop.rel_if_galois_prop_if_iff_if_galois_propI)
   (auto elim: galois.galois_connectionE)
 
 end
 
 context transport
 begin
 
 interpretation rel_if : transport "rel_if B (\<le>\<^bsub>L\<^esub>)" "rel_if B' (\<le>\<^bsub>R\<^esub>)" l r .
 
 lemma rel_if_preorder_equivalence_if_iff_if_preorder_equivalenceI:
   assumes "B \<Longrightarrow> B' \<Longrightarrow> ((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   and "B \<longleftrightarrow> B'"
   shows "((rel_if B (\<le>\<^bsub>L\<^esub>)) \<equiv>\<^bsub>pre\<^esub> (rel_if B' (\<le>\<^bsub>R\<^esub>))) l r"
   using assms by (intro rel_if.preorder_equivalence_if_galois_equivalenceI
     rel_if_galois_equivalence_if_iff_if_galois_equivalenceI
     preorder_on_rel_if_if_preorder_onI)
   blast+
 
 lemma rel_if_partial_equivalence_rel_equivalence_if_iff_if_partial_equivalence_rel_equivalenceI:
   assumes "B \<Longrightarrow> B' \<Longrightarrow> ((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   and "B \<longleftrightarrow> B'"
   shows "((rel_if B (\<le>\<^bsub>L\<^esub>)) \<equiv>\<^bsub>PER\<^esub> (rel_if B' (\<le>\<^bsub>R\<^esub>))) l r"
   using assms by (intro
     rel_if.partial_equivalence_rel_equivalence_if_galois_equivalenceI
     rel_if_galois_equivalence_if_iff_if_galois_equivalenceI)
   blast+
 
 end
 
 locale transport_Dep_Fun_Rel_no_dep_fun =
   transport_Dep_Fun_Rel_syntax L1 R1 l1 r1 L2 R2 "\<lambda>_ _. l2" "\<lambda>_ _. r2" +
   tdfr : transport_Dep_Fun_Rel L1 R1 l1 r1 L2 R2 "\<lambda>_ _. l2" "\<lambda>_ _. r2"
   for L1 :: "'a1 \<Rightarrow> 'a1 \<Rightarrow> bool"
   and R1 :: "'a2 \<Rightarrow> 'a2 \<Rightarrow> bool"
   and l1 :: "'a1 \<Rightarrow> 'a2"
   and r1 :: "'a2 \<Rightarrow> 'a1"
   and L2 :: "'a1 \<Rightarrow> 'a1 \<Rightarrow> 'b1 \<Rightarrow> 'b1 \<Rightarrow> bool"
   and R2 :: "'a2 \<Rightarrow> 'a2 \<Rightarrow> 'b2 \<Rightarrow> 'b2 \<Rightarrow> bool"
   and l2 :: "'b1 \<Rightarrow> 'b2"
   and r2 :: "'b2 \<Rightarrow> 'b1"
 begin
 
 notation t2.unit ("\<eta>\<^sub>2")
 notation t2.counit ("\<epsilon>\<^sub>2")
 
 abbreviation "L \<equiv> tdfr.L"
 abbreviation "R \<equiv> tdfr.R"
 
 abbreviation "l \<equiv> tdfr.l"
 abbreviation "r \<equiv> tdfr.r"
 
 notation tdfr.L (infix "\<le>\<^bsub>L\<^esub>" 50)
 notation tdfr.R (infix "\<le>\<^bsub>R\<^esub>" 50)
 
 notation tdfr.ge_left (infix "\<ge>\<^bsub>L\<^esub>" 50)
 notation tdfr.ge_right (infix "\<ge>\<^bsub>R\<^esub>" 50)
 
 notation tdfr.unit ("\<eta>")
 notation tdfr.counit ("\<epsilon>")
 
 theorem partial_equivalence_rel_equivalenceI:
   assumes per_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and per_equiv2: "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) l2 r2"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1' x2' \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
 proof -
   have per2I: "((\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2 r2"
     if hyps: "x1 \<le>\<^bsub>L1\<^esub> x2" "x2 \<^bsub>L1\<^esub>\<lessapprox> x1'" "x1' \<le>\<^bsub>R1\<^esub> x2'" for x1 x2 x1' x2'
   proof -
     from hyps have "x1 \<^bsub>L1\<^esub>\<lessapprox> x2'"
       using per_equiv1 t1.left_Galois_if_left_Galois_if_left_relI
         t1.left_Galois_if_right_rel_if_left_GaloisI
       by fast
     with per_equiv2 show ?thesis by blast
   qed
   have "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) (\<lambda>_ _. l2)"
     by (intro dep_mono_wrt_relI Dep_Fun_Rel_relI Dep_Fun_Rel_predI rel_if_if_impI)
-    (auto 8 0 dest!: per2I)
+    (auto 10 0 dest!: per2I)
   moreover have
     "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) (\<lambda>_ _. r2)"
     by (intro dep_mono_wrt_relI Dep_Fun_Rel_relI Dep_Fun_Rel_predI rel_if_if_impI)
-    (auto 8 0 dest!: per2I)
+    (auto 10 0 dest!: per2I)
   ultimately show ?thesis
     using assms by (intro tdfr.partial_equivalence_rel_equivalenceI) auto
 qed
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Examples/Prototype/transport.ML b/thys/Transport/Transport/Examples/Prototype/transport.ML
--- a/thys/Transport/Transport/Examples/Prototype/transport.ML
+++ b/thys/Transport/Transport/Examples/Prototype/transport.ML
@@ -1,409 +1,409 @@
 (*  Title:      Transport/transport.ML
     Author:     Kevin Kappelmann, Paul Bachmann
 
 Prototype for Transport. See README.md for future work.
 *)
 
-(*TODO: signature*)
+(*TODO: signature for final implementation*)
 
 structure Transport =
 struct
 
 structure Util = Transport_Util
 
 (*definitions used by Transport that need to be folded before a PER proof and unfolded after
 success.*)
 structure Transport_Defs = Named_Thms(
   val name = @{binding "trp_def"}
   val description = "Definitions used by Transport"
 )
 val _ = Theory.setup Transport_Defs.setup
 
 (* simplifying definitions *)
 
 val simp_rhs = Simplifier.rewrite #> Conversion_Util.rhs_conv #> Conversion_Util.thm_conv
 
 (*simplifies the generated definition of a transported term*)
 fun simp_transported_def ctxt simps y_def =
   let
     val ctxt = ctxt addsimps simps
     val y_def_eta_expanded = Util.equality_eta_expand ctxt "x" y_def
   in apply2 (simp_rhs ctxt) (y_def, y_def_eta_expanded) end
 
 (* resolution setup *)
 
 val any_unify_trp_hints_resolve_tac = Unify_Resolve_Base.unify_resolve_any_tac
   Transport_Mixed_Unification.norms_first_higherp_first_comb_higher_unify
   Transport_Mixed_Unification.first_higherp_first_comb_higher_unify
 
 fun get_theorems_tac f get_theorems ctxt = f (get_theorems ctxt) ctxt
 val get_theorems_resolve_tac = get_theorems_tac any_unify_trp_hints_resolve_tac
 
 val _ = Theory.setup (
     Method.setup @{binding trp_hints_resolve}
     (Attrib.thms >> (SIMPLE_METHOD' oo any_unify_trp_hints_resolve_tac))
     "Resolution with unification hints for Transport"
   )
 
 (* PER equivalence prover *)
 
 (*introduction rules*)
 structure PER_Intros = Named_Thms(
   val name = @{binding "per_intro"}
   val description = "Introduction rules for per_prover"
 )
 val _ = Theory.setup PER_Intros.setup
 
 fun per_prover_tac ctxt = REPEAT_ALL_NEW (get_theorems_resolve_tac PER_Intros.get ctxt)
 
 val _ = Theory.setup (
     Method.setup @{binding per_prover}
     (Scan.succeed (SIMPLE_METHOD' o per_prover_tac))
     "PER prover for Transport"
   )
 
 (* domain prover *)
 
 structure Transport_in_dom = Named_Thms(
   val name = @{binding "trp_in_dom"}
   val description = "In domain theorems for Transport"
 )
 val _ = Theory.setup Transport_in_dom.setup
 
 (*discharges the @{term "L x x'"} goals by registered lemmas*)
 fun transport_in_dom_prover_tac ctxt = get_theorems_resolve_tac Transport_in_dom.get ctxt
 
 val _ = Theory.setup (
     Method.setup @{binding trp_in_dom_prover}
     (Scan.succeed (SIMPLE_METHOD' o transport_in_dom_prover_tac))
     "in_dom prover for Transport"
   )
 
 
 (* blackbox prover *)
 
 (*first derives the PER equivalence, then looks for registered domain lemmas.*)
 fun unfold_tac thms ctxt = simp_tac (clear_simpset ctxt addsimps thms)
 val unfold_transport_defs_tac = get_theorems_tac unfold_tac Transport_Defs.get
 
 fun transport_prover ctxt i =
   per_prover_tac ctxt i
   THEN TRY (SOMEGOAL
     (TRY o unfold_transport_defs_tac ctxt
     THEN' transport_in_dom_prover_tac ctxt)
   )
 
 val _ = Theory.setup (
     Method.setup @{binding trp_prover}
     (Scan.succeed (SIMPLE_METHOD' o transport_prover))
     "Blackbox prover for Transport"
   )
 
 (* whitebox prover intro rules *)
 
 structure Transport_Related_Intros = Named_Thms(
   val name = @{binding "trp_related_intro"}
   val description = "Introduction rules for Transport whitebox proofs"
 )
 val _ = Theory.setup Transport_Related_Intros.setup
 
 
 (* relator rewriter *)
 
 (*rewrite rules to simplify the derived Galois relator*)
 structure Transport_Relator_Rewrites = Named_Thms(
   val name = @{binding "trp_relator_rewrite"}
   val description = "Rewrite rules for relators used by Transport"
 )
 val _ = Theory.setup Transport_Relator_Rewrites.setup
 
 (*simple rewrite tactic for Galois relators*)
 fun per_simp_prover ctxt thm =
   let
     val prems = Thm.cprems_of thm
     val per_prover_tac = per_prover_tac ctxt
     fun prove_prem prem = Goal.prove_internal ctxt [] prem (fn _ => HEADGOAL per_prover_tac)
   in try (map prove_prem) prems |> Option.map (curry (op OF) thm) end
 fun transport_relator_rewrite ctxt thm =
   let
     val transport_defs = Transport_Defs.get ctxt
     val transport_relator_rewrites = Transport_Relator_Rewrites.get ctxt
     val ctxt = (clear_simpset ctxt) addsimps transport_relator_rewrites
   in
     Local_Defs.fold ctxt transport_defs thm
     |> Raw_Simplifier.rewrite_thm (false, false, false) per_simp_prover ctxt
   end
 fun transport_relator_rewrite_tac ctxt =
   EqSubst.eqsubst_tac ctxt [0] (Transport_Relator_Rewrites.get ctxt)
   THEN_ALL_NEW TRY o SOLVED' (per_prover_tac ctxt)
 
 val _ = Theory.setup (
     Method.setup @{binding trp_relator_rewrite}
     (Scan.succeed (SIMPLE_METHOD' o transport_relator_rewrite_tac))
     "Rewrite Transport relator"
   )
 
 
 (* term transport command *)
 
 (*parsing*)
 @{parse_entries (struct) PA [L, R, x, y]}
 val parse_cmd_entries =
   let
     val parse_value = PA.parse_entry Parse.term Parse.term Parse.term Parse.term
     val parse_entry = Parse_Key_Value.parse_entry PA.parse_key Parse_Util.eq parse_value
   in PA.parse_entries_required Parse.and_list1 [PA.key PA.x] parse_entry (PA.empty_entries ()) end
 
 (*some utilities to destruct terms*)
 val transport_per_start_thm = @{thm "transport.transport_per_start"}
 val related_if_transport_per_thm = @{thm "transport.left_Galois_if_transport_per"}
 fun dest_transport_per \<^Const_>\<open>transport.transport_per S T for L R l r x y\<close> =
   ((S, T), (L, R, l, r, x, y))
 val dest_transport_per_y = dest_transport_per #> (fn (_, (_, _, _, _, _, y)) => y)
 
 fun mk_hom_Galois Ta Tb L R r x y =
   \<^Const>\<open>galois_rel.Galois Ta Ta Tb Tb for L R r x y\<close>
 fun dest_hom_Galois \<^Const_>\<open>galois_rel.Galois Ta _ Tb _ for L R r x y\<close> =
   ((Ta, Tb), (L, R, r, x, y))
 val dest_hom_Galois_y = dest_hom_Galois #> (fn (_, (_, _, _, _, y)) => y)
 
 (*bindings for generated theorems and definitions*)
 val binding_transport_per = \<^binding>\<open>transport_per\<close>
 val binding_per = \<^binding>\<open>per\<close>
 val binding_in_dom = \<^binding>\<open>in_dom\<close>
 val binding_related = \<^binding>\<open>related\<close>
 val binding_related_rewritten = \<^binding>\<open>related'\<close>
 val binding_def_simplified = \<^binding>\<open>eq\<close>
 val binding_def_eta_expanded_simplified = \<^binding>\<open>app_eq\<close>
 
 fun note_facts (binding, mixfix) ctxt related_thm y binding_thms_attribs =
   let
     val ((_, (_, y_def)), ctxt) = Util.create_local_theory_def (binding, mixfix) [] y ctxt
     (*create simplified definition theorems*)
     val transport_defs = Transport_Defs.get ctxt
     val (y_def_simplified, y_def_eta_expanded_simplified) =
       simp_transported_def ctxt transport_defs y_def
     (*create relatedness theorems*)
     val related_thm_rewritten = transport_relator_rewrite ctxt related_thm
     fun prepare_fact (suffix, thm, attribs) =
       let
         val binding = (Util.add_suffix binding suffix, [])
         val ctxt = (clear_simpset ctxt) addsimps transport_defs
         val folded_thm =
           (*fold definition of transported term*)
           Local_Defs.fold ctxt [y_def] thm
           (*simplify other transport definitions in theorem*)
           |> (Simplifier.rewrite ctxt |> Conversion_Util.thm_conv)
         val thm_attribs = ([folded_thm], attribs)
       in (binding, [thm_attribs]) end
     val facts = map prepare_fact ([
         (binding_related, related_thm, []),
         (binding_related_rewritten, related_thm_rewritten,
           [Util.attrib_to_src (Binding.pos_of binding) Transport_Related_Intros.add]),
         (binding_def_simplified, y_def_simplified, []),
         (binding_def_eta_expanded_simplified, y_def_eta_expanded_simplified, [])
       ] @ binding_thms_attribs)
   in Local_Theory.notes facts ctxt |> snd end
 
 (*black-box transport as described in the Transport paper*)
 fun after_qed_blackbox (binding, mixfix) [thms as [per_thm, in_dom_thm]] ctxt =
   let
     val transport_per_thm = List.foldl (op INCR_COMP) transport_per_start_thm thms
     (*fix possibly occurring meta type variables*)
     val ((_, [transport_per_thm]), ctxt) = Variable.importT [transport_per_thm] ctxt
     val y = Util.real_thm_concl transport_per_thm |> dest_transport_per_y
 
     val related_thm = transport_per_thm INCR_COMP related_if_transport_per_thm
     val binding_thms = [
         (binding_transport_per, transport_per_thm, []),
         (binding_per, per_thm, []),
         (binding_in_dom, in_dom_thm,
           [Util.attrib_to_src (Binding.pos_of binding) Transport_in_dom.add])
       ]
   in note_facts (binding, mixfix) ctxt related_thm y binding_thms end
 
 (*experimental white-box transport support*)
 fun after_qed_whitebox (binding, mixfix) [[related_thm]] ctxt =
   let
     (*fix possibly occurring meta type variables*)
     val ((_, [related_thm]), ctxt) = Variable.importT [related_thm] ctxt
     val y = Util.real_thm_concl related_thm |> dest_hom_Galois_y
   in note_facts (binding, mixfix) ctxt related_thm y [] end
 
 fun setup_goals_blackbox ctxt (L, R, cx) maxidx =
   let
     (*check*)
     val [cL, cR] = Syntax.check_terms ctxt [L, R] |> map (Thm.cterm_of ctxt)
     (*instantiate theorem*)
     val transport_per_start_thm = Thm.incr_indexes (maxidx + 1) transport_per_start_thm
     val args = [SOME cL, SOME cR, NONE, NONE, SOME cx]
     val transport_per_start_thm = Drule.infer_instantiate' ctxt args transport_per_start_thm
     val transport_defs = Transport_Defs.get ctxt
     val goals = Local_Defs.fold ctxt transport_defs transport_per_start_thm
       |> Thm.prems_of
       |> map (rpair [])
   in goals end
 
 fun setup_goals_whitebox ctxt (yT, L, R, cx, y) maxidx =
   let
     val (r, _) = Term_Util.fresh_var "r" dummyT maxidx
     (*check*)
     val Galois = mk_hom_Galois (Thm.typ_of_cterm cx) yT L R r (Thm.term_of cx) y
       |> Syntax.check_term ctxt
     val goal = Util.mk_judgement Galois |> rpair []
   in [goal] end
 
 fun setup_proof ((((binding, opt_yT, mixfix), params), unfolds), whitebox) lthy =
   let
     val ctxt = Util.set_proof_mode_schematic lthy
     (*type of transported term*)
     val yT = Option.map (Syntax.read_typ ctxt) opt_yT |> the_default dummyT
     (*theorems to unfold*)
     val unfolds = map (Proof_Context.get_fact ctxt o fst) unfolds |> flat
     (*term to transport*)
     val cx =
       (**read term**)
       Syntax.read_term ctxt (PA.get_x params) |> Thm.cterm_of ctxt
       (**unfold passed theorems**)
       |> Drule.cterm_rule (Local_Defs.unfold ctxt unfolds)
     (*transport relations and transport term goal*)
     val ([L, R, y], maxidx) =
       let
         (**configuration**)
         val opts = [PA.get_L_safe params, PA.get_R_safe params, PA.get_y_safe params]
         val opts_default_names = ["L", "R", "y"]
         val opts_constraints =
           [Util.mk_hom_rel_type (Thm.typ_of_cterm cx), Util.mk_hom_rel_type yT, yT]
           |> map Type.constraint
         (**parse**)
         val opts = map (Syntax.parse_term ctxt |> Option.map) opts
         val params_maxidx = Util.list_max (the_default ~1 o Option.map Term.maxidx_of_term)
           (Thm.maxidx_of_cterm cx) opts
         fun create_var (NONE, n) maxidx =
               Term_Util.fresh_var n dummyT params_maxidx ||> Integer.max maxidx
           | create_var (SOME t, _) created = (t, created)
         val (ts, maxidx) =
           fold_map create_var (opts ~~ opts_default_names) params_maxidx
           |>> map2 I opts_constraints
       in (ts, maxidx) end
     (*initialise goals and callback*)
     val (goals, after_qed) = if whitebox
       then (setup_goals_whitebox ctxt (yT, L, R, cx, y) maxidx, after_qed_whitebox)
       (*TODO: consider y in blackbox proofs*)
       else (setup_goals_blackbox ctxt (L, R, cx) maxidx, after_qed_blackbox)
   in
     Proof.theorem NONE (after_qed (binding, mixfix)) [goals] ctxt
     |> Proof.refine_singleton Util.split_conjunctions
   end
 
 val parse_strings =
   (*binding for transported term*)
   Parse_Spec.constdecl
   (*other params*)
   -- parse_cmd_entries
   (*optionally pass unfold theorems in case of white-box transports*)
   -- Scan.optional (Parse.reserved "unfold" |-- Parse.thms1) []
   (*use a bang "!" to start white-box transport mode (experimental)*)
   -- Parse.opt_bang
 
 val _ =
   Outer_Syntax.local_theory_to_proof \<^command_keyword>\<open>trp_term\<close>
     "Transport term" (parse_strings >> setup_proof)
 
 
 (* experimental white-box prover *)
 
 val any_match_resolve_related_tac =
   let fun unif binders = Higher_Ordern_Pattern_First_Decomp_Unification.e_match
     Unification_Util.match_types unif Unification_Combinator.fail_unify binders
   in
     Unify_Resolve_Base.unify_resolve_any_tac
       Higher_Ordern_Pattern_First_Decomp_Unification.norms_match unif
   end
 
 val related_comb_tac = any_match_resolve_related_tac @{thms related_Fun_Rel_combI}
 val related_lambda_tac = any_match_resolve_related_tac @{thms related_Fun_Rel_lambdaI}
 val related_tac = any_unify_trp_hints_resolve_tac
 val related_assume_tac = assume_tac
 
 fun mk_transport_related_tac cc_comb cc_lambda ctxt =
   let
     val transport_related_intros = Transport_Related_Intros.get ctxt
     val related_tac = related_tac transport_related_intros ctxt
     val comb_tac = related_comb_tac ctxt
     val lambda_tac = related_lambda_tac ctxt
     val assume_tac = related_assume_tac ctxt
   in
     Tactic_Util.CONCAT' [
       related_tac,
       cc_comb comb_tac,
       cc_lambda lambda_tac,
       assume_tac
     ]
   end
 val transport_related_step_tac =
   let fun cc_comb tac i = tac i
     THEN prefer_tac i
     THEN prefer_tac (i + 1)
   in mk_transport_related_tac cc_comb I end
 fun transport_related_tac ctxt =
   let
     fun transport_related_tac cc =
       let
         fun cc_comb tac = tac THEN_ALL_NEW TRY o cc
         fun cc_lambda tac = tac THEN' TRY o cc
       in mk_transport_related_tac cc_comb cc_lambda ctxt end
     fun fix tac i thm = tac (fix tac) i thm
   in fix transport_related_tac end
 
 val _ = Theory.setup (
     Method.setup @{binding trp_related_prover}
     (Scan.succeed (SIMPLE_METHOD' o transport_related_tac))
     "Relatedness prover for Transport"
   )
 
 fun instantiate_tac name ct ctxt =
   PRIMITIVE (Drule.infer_instantiate_types ctxt [((name, Thm.typ_of_cterm ct), ct)])
   |> CHANGED
 
 val map_dummyT = Term.map_types (K dummyT)
 
 fun mk_term_skeleton maxidx t =
   let
     val consts = Term.add_consts t []
     val (vars, _) = fold_map (uncurry Term_Util.fresh_var o apfst Long_Name.base_name) consts maxidx
     val t' = Term.subst_atomic (map2 (pair o Const) consts vars) t
   in t' end
 
 fun instantiate_skeleton_tac ctxt =
   let fun tac ct =
     let
       val (x, y) = Transport_Util.cdest_judgement ct |> Thm.dest_binop
       val default_sort = Proof_Context.default_sort ctxt
       val skeleton =
         mk_term_skeleton (Thm.maxidx_of_cterm ct) (Thm.term_of x)
         |> map_dummyT
         |> Type.constraint (Thm.typ_of_cterm y)
         |> Syntax.check_term (Util.set_proof_mode_pattern ctxt)
         (*add sort constraints for type variables*)
         |> Term.map_types (Term.map_atyps (map_type_tvar (fn (n, _) => TVar (n, default_sort n))))
         |> Thm.cterm_of ctxt
     in instantiate_tac (Thm.term_of y |> dest_Var |> fst) skeleton ctxt end
   in Tactic_Util.CSUBGOAL_DATA I (K o tac) end
 
 fun transport_whitebox_tac ctxt =
   instantiate_skeleton_tac ctxt
   THEN' transport_related_tac ctxt
   THEN_ALL_NEW (
     TRY o REPEAT1 o transport_relator_rewrite_tac ctxt
     THEN' TRY o any_unify_trp_hints_resolve_tac @{thms refl} ctxt
   )
 
 val _ = Theory.setup (
     Method.setup @{binding trp_whitebox_prover}
     (Scan.succeed (SIMPLE_METHOD' o transport_whitebox_tac))
     "Whitebox prover for Transport"
   )
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Examples/Transport_Partial_Quotient_Types.thy b/thys/Transport/Transport/Examples/Transport_Partial_Quotient_Types.thy
--- a/thys/Transport/Transport/Examples/Transport_Partial_Quotient_Types.thy
+++ b/thys/Transport/Transport/Examples/Transport_Partial_Quotient_Types.thy
@@ -1,98 +1,98 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 section \<open>Transport for Partial Quotient Types\<close>
 theory Transport_Partial_Quotient_Types
   imports
     HOL.Lifting
     Transport
 begin
 
 paragraph \<open>Summary\<close>
 text \<open>Every partial quotient type @{term Quotient}, as used by the Lifting
 package, is transportable.\<close>
 
 context transport
 begin
 
 interpretation t : transport L "(=)" l r .
 
 lemma Quotient_T_eq_Galois:
   assumes "Quotient (\<le>\<^bsub>L\<^esub>) l r T"
   shows "T = t.Galois"
 proof (intro ext iffI)
   fix x y assume "T x y"
   with assms have "x \<le>\<^bsub>L\<^esub> x" "l x = y" using Quotient_cr_rel by auto
   with assms have "r (l x) \<le>\<^bsub>L\<^esub> x" "r (l x) \<le>\<^bsub>L\<^esub> r y"
     using Quotient_rep_abs Quotient_rep_reflp by auto
   with assms have "x \<le>\<^bsub>L\<^esub> r y" using Quotient_part_equivp
     by (blast elim: part_equivpE dest: transpD sympD)
   then show "t.Galois x y" by blast
 next
   fix x y assume "t.Galois x y"
   with assms show "T x y" using Quotient_cr_rel Quotient_refl1 Quotient_symp
     by (fastforce intro: Quotient_rel_abs2[symmetric] dest: sympD)
 qed
 
 lemma Quotient_if_preorder_equivalence:
   assumes "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>pre\<^esub> (=)) l r"
   shows "Quotient (\<le>\<^bsub>L\<^esub>) l r t.Galois"
 proof (rule QuotientI)
   from assms show g2: "l (r y) = y" for y by fastforce
   from assms show "r y \<le>\<^bsub>L\<^esub> r y" for y by blast
   show g1: "x \<le>\<^bsub>L\<^esub> x' \<longleftrightarrow> x \<le>\<^bsub>L\<^esub> x \<and> x' \<le>\<^bsub>L\<^esub> x' \<and> l x = l x'"
     (is "?lhs \<longleftrightarrow> ?rhs") for x x'
   proof (rule iffI)
     assume ?rhs
-    with assms have "\<eta> x \<le>\<^bsub>L\<^esub> \<eta> x'" by fastforce
+    with assms have "\<eta> x \<le>\<^bsub>L\<^esub> \<eta> x'" by force
     moreover from \<open>?rhs\<close> assms have "x \<le>\<^bsub>L\<^esub> \<eta> x" "\<eta> x' \<le>\<^bsub>L\<^esub> x'"
       by (blast elim: t.preorder_equivalence_order_equivalenceE)+
     moreover from assms have "transitive (\<le>\<^bsub>L\<^esub>)" by blast
     ultimately show "x \<le>\<^bsub>L\<^esub> x'" by blast
   next
     assume ?lhs
     with assms show ?rhs by blast
   qed
   from assms show "t.Galois = (\<lambda>x y. x \<le>\<^bsub>L\<^esub> x \<and> l x = y)"
     by (intro ext iffI)
     (metis g1 g2 t.left_GaloisE,
       auto intro!: t.left_Galois_left_if_left_rel_if_inflationary_on_in_fieldI
       elim!: t.preorder_equivalence_order_equivalenceE)
 qed
 
 lemma partial_equivalence_rel_equivalence_if_Quotient:
   assumes "Quotient (\<le>\<^bsub>L\<^esub>) l r T"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (=)) l r"
 proof (rule t.partial_equivalence_rel_equivalence_if_order_equivalenceI)
   from Quotient_part_equivp[OF assms] show "partial_equivalence_rel (\<le>\<^bsub>L\<^esub>)"
     by (blast elim: part_equivpE dest: transpD sympD)
   have "x \<equiv>\<^bsub>L\<^esub> r (l x)" if "in_field (\<le>\<^bsub>L\<^esub>) x" for x
   proof -
     from assms \<open>in_field (\<le>\<^bsub>L\<^esub>) x\<close> have "x \<le>\<^bsub>L\<^esub> x"
       using Quotient_refl1 Quotient_refl2 by fastforce
     with assms Quotient_rep_abs Quotient_symp show ?thesis
       by (fastforce dest: sympD)
   qed
   with assms show "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (=)) l r"
     using Quotient_abs_rep Quotient_rel_abs Quotient_rep_reflp
       Quotient_abs_rep[symmetric]
     by (intro t.order_equivalenceI dep_mono_wrt_relI rel_equivalence_onI
       inflationary_onI deflationary_onI)
     auto
 qed auto
 
 corollary Quotient_iff_partial_equivalence_rel_equivalence:
   "Quotient (\<le>\<^bsub>L\<^esub>) l r t.Galois \<longleftrightarrow> ((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (=)) l r"
   using Quotient_if_preorder_equivalence partial_equivalence_rel_equivalence_if_Quotient
   by blast
 
 corollary Quotient_T_eq_ge_Galois_right:
   assumes "Quotient (\<le>\<^bsub>L\<^esub>) l r T"
   shows "T = t.ge_Galois_right"
   using assms
   by (subst t.ge_Galois_right_eq_left_Galois_if_symmetric_if_in_codom_eq_in_dom_if_galois_prop)
   (blast dest: partial_equivalence_rel_equivalence_if_Quotient
   intro: in_codom_eq_in_dom_if_reflexive_on_in_field Quotient_T_eq_Galois)+
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Examples/Typedef/Transport_Typedef.thy b/thys/Transport/Transport/Examples/Typedef/Transport_Typedef.thy
--- a/thys/Transport/Transport/Examples/Typedef/Transport_Typedef.thy
+++ b/thys/Transport/Transport/Examples/Typedef/Transport_Typedef.thy
@@ -1,210 +1,210 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 theory Transport_Typedef
   imports
     "HOL-Library.FSet"
     Transport_Typedef_Base
     Transport_Prototype
     Transport_Syntax
 begin
 
 context
   includes galois_rel_syntax transport_syntax
 begin
 
 typedef pint = "{i :: int. 0 \<le> i}" by auto
 
 interpretation typedef_pint : type_definition Rep_pint Abs_pint "{i :: int. 0 \<le> i}"
   by (fact type_definition_pint)
 
 lemma [trp_relator_rewrite, trp_uhint]:
   "(\<^bsub>(=\<^bsub>Collect ((\<le>) (0 :: int))\<^esub>)\<^esub>\<lessapprox>\<^bsub>(=) Rep_pint\<^esub>) \<equiv> typedef_pint.AR"
   using typedef_pint.left_Galois_eq_AR by (intro eq_reflection) simp
 
 typedef 'a fset = "{s :: 'a set. finite s}" by auto
 
 interpretation typedef_fset :
   type_definition Rep_fset Abs_fset "{s :: 'a set. finite s}"
   by (fact type_definition_fset)
 
 lemma [trp_relator_rewrite, trp_uhint]:
   "(\<^bsub>(=\<^bsub>{s :: 'a set. finite s}\<^esub>) :: 'a set \<Rightarrow> _\<^esub>\<lessapprox>\<^bsub>(=) Rep_fset\<^esub>) \<equiv> typedef_fset.AR"
   using typedef_fset.left_Galois_eq_AR by (intro eq_reflection) simp
 
 lemma eq_restrict_set_eq_eq_uhint [trp_uhint]:
-  "P \<equiv> \<lambda>x. x \<in> A \<Longrightarrow> ((=\<^bsub>A :: 'a set\<^esub>) :: 'a \<Rightarrow> _) \<equiv> (=\<^bsub>P\<^esub>)"
-  by simp
+  "(\<And>x. P x \<equiv> x \<in> A) \<Longrightarrow> ((=\<^bsub>A :: 'a set\<^esub>) :: 'a \<Rightarrow> _) \<equiv> (=\<^bsub>P\<^esub>)"
+  by (intro eq_reflection) (auto simp: fun_eq_iff)
 
-(*could also automatically tagged for every instance in type_definition*)
+(*could also automatically be tagged for every instance of type_definition*)
 declare
   typedef_pint.partial_equivalence_rel_equivalence[per_intro]
   typedef_fset.partial_equivalence_rel_equivalence[per_intro]
 
 
 lemma one_parametric [trp_in_dom]: "typedef_pint.L 1 1" by auto
 
 trp_term pint_one :: "pint" where x = "1 :: int"
   by trp_prover
 
 lemma add_parametric [trp_in_dom]:
   "(typedef_pint.L \<Rrightarrow> typedef_pint.L \<Rrightarrow> typedef_pint.L) (+) (+)"
-  by (intro Dep_Fun_Rel_relI) (auto intro!: eq_restrictI elim!: eq_restrictE)
+  by (intro Dep_Fun_Rel_relI) fastforce
 
 trp_term pint_add :: "pint \<Rightarrow> pint \<Rightarrow> pint"
   where x = "(+) :: int \<Rightarrow> _"
   by trp_prover
 
 lemma empty_parametric [trp_in_dom]: "typedef_fset.L {} {}"
   by auto
 
 trp_term fempty :: "'a fset" where x = "{} :: 'a set"
   by trp_prover
 
 
 lemma insert_parametric [trp_in_dom]:
   "((=) \<Rrightarrow> typedef_fset.L \<Rrightarrow> typedef_fset.L) insert insert"
   by auto
 
 trp_term finsert :: "'a \<Rightarrow> 'a fset \<Rightarrow> 'a fset" where x = insert
   and L = "((=) \<Rrightarrow> typedef_fset.L \<Rrightarrow> typedef_fset.L)"
   and R = "((=) \<Rrightarrow> typedef_fset.R \<Rrightarrow> typedef_fset.R)"
   by trp_prover
 
 
 (*experiments with white-box transports*)
 
 context
   notes refl[trp_related_intro]
 begin
 
 trp_term insert_add_int_fset_whitebox :: "int fset"
   where x = "insert (1 + (1 :: int)) {}" !
   by trp_whitebox_prover
 
 lemma empty_parametric' [trp_related_intro]: "(rel_set R) {} {}"
   by (intro Dep_Fun_Rel_relI rel_setI) (auto dest: rel_setD1 rel_setD2)
 
 lemma insert_parametric' [trp_related_intro]:
   "(R \<Rrightarrow> rel_set R \<Rrightarrow> rel_set R) insert insert"
   by (intro Dep_Fun_Rel_relI rel_setI) (auto dest: rel_setD1 rel_setD2)
 
 context
   assumes [trp_uhint]:
   (*proven for all natural functors*)
   "L \<equiv> rel_set (L1 :: int \<Rightarrow> int \<Rightarrow> bool) \<Longrightarrow> R \<equiv> rel_set (R1 :: pint \<Rightarrow> pint \<Rightarrow> bool)
   \<Longrightarrow> r \<equiv> image r1 \<Longrightarrow> S \<equiv> (\<^bsub>L1\<^esub>\<lessapprox>\<^bsub>R1 r1\<^esub>) \<Longrightarrow> (\<^bsub>L\<^esub>\<lessapprox>\<^bsub>R r\<^esub>) \<equiv> rel_set S"
 begin
 
 trp_term insert_add_pint_set_whitebox :: "pint set"
   where x = "insert (1 + (1 :: int)) {}" !
   by trp_whitebox_prover
 
 print_statement insert_add_int_fset_whitebox_def insert_add_pint_set_whitebox_def
 
 end
 end
 
 lemma image_parametric [trp_in_dom]:
   "(((=) \<Rrightarrow> (=)) \<Rrightarrow> typedef_fset.L \<Rrightarrow> typedef_fset.L) image image"
   by (intro Dep_Fun_Rel_relI) auto
 
 trp_term fimage :: "('a \<Rightarrow> 'b) \<Rightarrow> 'a fset \<Rightarrow> 'b fset" where x = image
   by trp_prover
 
 (*experiments with compositions*)
 
 lemma rel_fun_eq_Fun_Rel_rel: "rel_fun = Fun_Rel_rel"
   by (intro ext iffI Dep_Fun_Rel_relI) (auto elim: rel_funE)
 
 lemma image_parametric' [trp_related_intro]:
   "((R \<Rrightarrow> S) \<Rrightarrow> rel_set R \<Rrightarrow> rel_set S) image image"
   using transfer_raw[simplified rel_fun_eq_Fun_Rel_rel Transfer.Rel_def]
   by simp
 
 lemma Galois_id_hint [trp_uhint]:
   "(L :: 'a \<Rightarrow> 'a \<Rightarrow> bool) \<equiv> R \<Longrightarrow> r \<equiv> id \<Longrightarrow> E \<equiv> L \<Longrightarrow> (\<^bsub>L\<^esub>\<lessapprox>\<^bsub>R r\<^esub>) \<equiv> E"
   by (simp only: eq_reflection[OF transport_id.left_Galois_eq_left])
 
 lemma Freq [trp_uhint]: "L \<equiv> (=) \<Rrightarrow> (=) \<Longrightarrow> L \<equiv> (=)"
   by auto
 
 context
   fixes L1 R1 l1 r1 L R l r
   assumes per1: "(L1 \<equiv>\<^bsub>PER\<^esub> R1) l1 r1"
   defines "L \<equiv> rel_set L1" and "R \<equiv> rel_set R1"
   and "l \<equiv> image l1" and "r \<equiv> image r1"
 begin
 
 interpretation transport L R l r .
 
 context
   (*proven for all natural functors*)
   assumes transport_per_set: "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   and compat: "transport_comp.middle_compatible_codom R typedef_fset.L"
 begin
 
 trp_term fempty_param :: "'b fset"
   where x = "{} :: 'a set"
   and L = "transport_comp.L ?L1 ?R1 (?l1 :: 'a set \<Rightarrow> 'b set) ?r1 typedef_fset.L"
   and R = "transport_comp.L typedef_fset.R typedef_fset.L ?r2 ?l2 ?R1"
   apply (rule transport_comp.partial_equivalence_rel_equivalenceI)
     apply (rule transport_per_set)
     apply per_prover
     apply (fact compat)
   apply (rule transport_comp.left_relI[where ?y="{}" and ?y'="{}"])
   apply (unfold L_def R_def l_def r_def)
   apply (auto intro!: galois_rel.left_GaloisI in_codomI empty_transfer)
   done
 
 definition "set_succ \<equiv> image ((+) (1 :: int))"
 
 lemma set_succ_parametric [trp_in_dom]:
   "(typedef_fset.L \<Rrightarrow> typedef_fset.L) set_succ set_succ"
   unfolding set_succ_def by auto
 
 trp_term fset_succ :: "int fset \<Rightarrow> int fset"
   where x = set_succ
   and L = "typedef_fset.L \<Rrightarrow> typedef_fset.L"
   and R = "typedef_fset.R \<Rrightarrow> typedef_fset.R"
   by trp_prover
 
 trp_term fset_succ' :: "int fset \<Rightarrow> int fset"
   where x = set_succ
   and L = "typedef_fset.L \<Rrightarrow> typedef_fset.L"
   and R = "typedef_fset.R \<Rrightarrow> typedef_fset.R"
   unfold set_succ_def !
   (*current prototype gets lost in this example*)
   using refl[trp_related_intro]
   apply (tactic \<open>Transport.instantiate_skeleton_tac @{context} 1\<close>)
   apply (tactic \<open>Transport.transport_related_step_tac @{context} 1\<close>)
   apply (tactic \<open>Transport.transport_related_step_tac @{context} 1\<close>)
   apply (tactic \<open>Transport.transport_related_step_tac @{context} 1\<close>)
   apply (tactic \<open>Transport.transport_related_step_tac @{context} 1\<close>)
   apply (tactic \<open>Transport.transport_related_step_tac @{context} 1\<close>)
   apply (tactic \<open>Transport.transport_related_step_tac @{context} 1\<close>)
   apply assumption
   apply assumption
   prefer 3
   apply (tactic \<open>Transport.transport_related_step_tac @{context} 1\<close>)
   apply (tactic \<open>Transport.transport_related_step_tac @{context} 1\<close>)
   apply (fold trp_def)
   apply (trp_relator_rewrite)+
   apply (unfold trp_def)
   apply (trp_hints_resolve refl)
   done
 
 lemma pint_middle_compat:
   "transport_comp.middle_compatible_codom (rel_set ((=) :: pint \<Rightarrow> _))
   (=\<^bsub>Collect (finite :: pint set \<Rightarrow> _)\<^esub>)"
   by (intro transport_comp.middle_compatible_codom_if_right1_le_eqI)
   (auto simp: rel_set_eq intro!: transitiveI)
 
 trp_term pint_fset_succ :: "pint fset \<Rightarrow> pint fset"
   where x = "set_succ :: int set \<Rightarrow> int set"
   (*automation for composition not supported as of now*)
   oops
 
 end
 end
 end
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Examples/Typedef/Transport_Typedef_Base.thy b/thys/Transport/Transport/Examples/Typedef/Transport_Typedef_Base.thy
--- a/thys/Transport/Transport/Examples/Typedef/Transport_Typedef_Base.thy
+++ b/thys/Transport/Transport/Examples/Typedef/Transport_Typedef_Base.thy
@@ -1,42 +1,40 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 section \<open>Transport for HOL Type Definitions\<close>
 theory Transport_Typedef_Base
   imports
     HOL_Alignment_Binary_Relations
     Transport_Bijections
     HOL.Typedef
 begin
 
 context type_definition
 begin
 
 abbreviation (input) "L :: 'a \<Rightarrow> 'a \<Rightarrow> bool \<equiv> (=\<^bsub>A\<^esub>)"
 abbreviation (input) "R :: 'b \<Rightarrow> 'b \<Rightarrow> bool \<equiv> (=)"
 
 sublocale transport? :
   transport_eq_restrict_bijection "mem_of A" "\<top> :: 'b \<Rightarrow> bool" Abs Rep
   rewrites "(=\<^bsub>mem_of A\<^esub>) \<equiv> L"
   and "(=\<^bsub>\<top> :: 'b \<Rightarrow> bool\<^esub>) \<equiv> R"
   and "(galois_rel.Galois (=) (=) Rep)\<restriction>\<^bsub>mem_of A\<^esub>\<upharpoonleft>\<^bsub>\<top> :: 'b \<Rightarrow> bool\<^esub> \<equiv>
     (galois_rel.Galois (=) (=) Rep)"
   using Abs_inverse Rep_inverse
   by (intro transport_eq_restrict_bijection.intro bijection_onI)
-  (auto simp: restrict_right_eq
-    intro!: eq_reflection galois_rel.left_GaloisI Rep
-    elim: galois_rel.left_GaloisE)
+  (auto intro!: eq_reflection galois_rel.left_GaloisI Rep elim: galois_rel.left_GaloisE)
 
 interpretation galois L R Abs Rep .
 
 lemma Rep_left_Galois_self: "Rep y \<^bsub>L\<^esub>\<lessapprox> y"
   using Rep by (intro left_GaloisI) auto
 
 definition "AR x y \<equiv> x = Rep y"
 
 lemma left_Galois_eq_AR: "left_Galois = AR"
   unfolding AR_def
   by (auto intro!: galois_rel.left_GaloisI Rep elim: galois_rel.left_GaloisE)
 
 end
 
 
 end
diff --git a/thys/Transport/Transport/Functions/Monotone_Function_Relator.thy b/thys/Transport/Transport/Functions/Monotone_Function_Relator.thy
--- a/thys/Transport/Transport/Functions/Monotone_Function_Relator.thy
+++ b/thys/Transport/Transport/Functions/Monotone_Function_Relator.thy
@@ -1,105 +1,105 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 section \<open>Monotone Function Relator\<close>
 theory Monotone_Function_Relator
   imports
     Reflexive_Relator
 begin
 
 abbreviation "Mono_Dep_Fun_Rel R S \<equiv> ([x y \<Colon> R] \<Rrightarrow> S x y)\<^sup>\<oplus>"
 abbreviation "Mono_Fun_Rel R S \<equiv> Mono_Dep_Fun_Rel R (\<lambda>_ _. S)"
 
 bundle Mono_Dep_Fun_Rel_syntax begin
 syntax
   "_Mono_Fun_Rel_rel" :: "('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'c) \<Rightarrow>
     ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("(_) \<Rrightarrow>\<oplus> (_)" [41, 40] 40)
   "_Mono_Dep_Fun_Rel_rel" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'c) \<Rightarrow> ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _] \<Rrightarrow>\<oplus> (_)" [41, 41, 41, 40] 40)
   "_Mono_Dep_Fun_Rel_rel_if" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'c) \<Rightarrow> ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _/ |/ _] \<Rrightarrow>\<oplus> (_)" [41, 41, 41, 41, 40] 40)
 end
 bundle no_Mono_Dep_Fun_Rel_syntax begin
 no_syntax
   "_Mono_Fun_Rel_rel" :: "('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 'c) \<Rightarrow>
     ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("(_) \<Rrightarrow>\<oplus> (_)" [41, 40] 40)
   "_Mono_Dep_Fun_Rel_rel" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'c) \<Rightarrow> ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _] \<Rrightarrow>\<oplus> (_)" [41, 41, 41, 40] 40)
   "_Mono_Dep_Fun_Rel_rel_if" :: "idt \<Rightarrow> idt \<Rightarrow> ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> bool \<Rightarrow> ('c \<Rightarrow> 'd \<Rightarrow> bool) \<Rightarrow>
     ('a \<Rightarrow> 'c) \<Rightarrow> ('b \<Rightarrow> 'd) \<Rightarrow> bool" ("[_/ _/ \<Colon>/ _/ |/ _] \<Rrightarrow>\<oplus> (_)" [41, 41, 41, 41, 40] 40)
 end
 unbundle Mono_Dep_Fun_Rel_syntax
 
 translations
   "R \<Rrightarrow>\<oplus> S" \<rightleftharpoons> "CONST Mono_Fun_Rel R S"
   "[x y \<Colon> R] \<Rrightarrow>\<oplus> S" \<rightleftharpoons> "CONST Mono_Dep_Fun_Rel R (\<lambda>x y. S)"
   "[x y \<Colon> R | B] \<Rrightarrow>\<oplus> S" \<rightleftharpoons> "CONST Mono_Dep_Fun_Rel R (\<lambda>x y. CONST rel_if B S)"
 
 locale Dep_Fun_Rel_orders =
   fixes L :: "'a \<Rightarrow> 'b \<Rightarrow> bool"
   and R :: "'a \<Rightarrow> 'b \<Rightarrow> 'c \<Rightarrow> 'd \<Rightarrow> bool"
 begin
 
 sublocale o : orders L "R a b" for a b .
 
 notation L (infix "\<le>\<^bsub>L\<^esub>" 50)
 notation o.ge_left (infix "\<ge>\<^bsub>L\<^esub>" 50)
 
 notation R ("(\<le>\<^bsub>R (_) (_)\<^esub>)" 50)
 abbreviation "right_infix c a b d \<equiv> (\<le>\<^bsub>R a b\<^esub>) c d"
 notation right_infix ("(_) \<le>\<^bsub>R (_) (_)\<^esub> (_)" [51,51,51,51] 50)
 
 notation o.ge_right ("(\<ge>\<^bsub>R (_) (_)\<^esub>)" 50)
 
 abbreviation (input) "ge_right_infix d a b c \<equiv> (\<ge>\<^bsub>R a b\<^esub>) d c"
 notation ge_right_infix ("(_) \<ge>\<^bsub>R (_) (_)\<^esub> (_)" [51,51,51,51] 50)
 
 abbreviation (input) "DFR \<equiv> ([a b \<Colon> L] \<Rrightarrow> R a b)"
 
 end
 
 locale hom_Dep_Fun_Rel_orders = Dep_Fun_Rel_orders L R
   for L :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
   and R :: "'a \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> 'b \<Rightarrow> bool"
 begin
 
 sublocale ho : hom_orders L "R a b" for a b .
 
 lemma Mono_Dep_Fun_Refl_Rel_right_eq_Mono_Dep_Fun_if_le_if_reflexive_onI:
   assumes refl_L: "reflexive_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>R x2 x2\<^esub>) \<le> (\<le>\<^bsub>R x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>R x1 x1\<^esub>) \<le> (\<le>\<^bsub>R x1 x2\<^esub>)"
   shows "([x y \<Colon> (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<oplus> (\<le>\<^bsub>R x y\<^esub>)\<^sup>\<oplus>) = ([x y \<Colon> (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<oplus> (\<le>\<^bsub>R x y\<^esub>))"
 proof -
   {
     fix f g x1 x2
     assume "([x y \<Colon> (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R x y\<^esub>)) f g" "x1 \<le>\<^bsub>L\<^esub> x1" "x1 \<le>\<^bsub>L\<^esub> x2"
     with assms have "f x1 \<le>\<^bsub>R x1 x2\<^esub> g x1" "f x2 \<le>\<^bsub>R x1 x2\<^esub> g x2" by blast+
   }
   with refl_L show ?thesis
     by (intro ext iffI Refl_RelI Dep_Fun_Rel_relI) (auto elim!: Refl_RelE)
 qed
 
 lemma Mono_Dep_Fun_Refl_Rel_right_eq_Mono_Dep_Fun_if_mono_if_reflexive_onI:
   assumes "reflexive_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L\<^esub>) | x1 \<le>\<^bsub>L\<^esub> x3] \<Rrightarrow> (\<le>)) R"
   shows "([x y \<Colon> (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<oplus> (\<le>\<^bsub>R x y\<^esub>)\<^sup>\<oplus>) = ([x y \<Colon> (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<oplus> (\<le>\<^bsub>R x y\<^esub>))"
   using assms
   by (intro Mono_Dep_Fun_Refl_Rel_right_eq_Mono_Dep_Fun_if_le_if_reflexive_onI)
-  auto
+  (auto 6 0)
 
 end
 
 context hom_orders
 begin
 
 sublocale fro : hom_Dep_Fun_Rel_orders L "\<lambda>_ _. R" .
 
 corollary Mono_Fun_Rel_Refl_Rel_right_eq_Mono_Fun_RelI:
   assumes "reflexive_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<oplus> (\<le>\<^bsub>R\<^esub>)\<^sup>\<oplus>) = ((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<oplus> (\<le>\<^bsub>R\<^esub>))"
   using assms by (intro fro.Mono_Dep_Fun_Refl_Rel_right_eq_Mono_Dep_Fun_if_le_if_reflexive_onI)
   simp_all
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Functions/Reflexive_Relator.thy b/thys/Transport/Transport/Functions/Reflexive_Relator.thy
--- a/thys/Transport/Transport/Functions/Reflexive_Relator.thy
+++ b/thys/Transport/Transport/Functions/Reflexive_Relator.thy
@@ -1,275 +1,275 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 section \<open>Reflexive Relator\<close>
 theory Reflexive_Relator
   imports
     Galois_Equivalences
     Galois_Relator
 begin
 
 definition "Refl_Rel R x y \<equiv> R x x \<and> R y y \<and> R x y"
 
 bundle Refl_Rel_syntax begin notation Refl_Rel ("(_\<^sup>\<oplus>)" [1000]) end
 bundle no_Refl_Rel_syntax begin no_notation Refl_Rel ("(_\<^sup>\<oplus>)" [1000]) end
 unbundle Refl_Rel_syntax
 
 lemma Refl_RelI [intro]:
   assumes "R x x"
   and "R y y"
   and "R x y"
   shows "R\<^sup>\<oplus> x y"
   using assms unfolding Refl_Rel_def by blast
 
 lemma Refl_Rel_selfI [intro]:
   assumes "R x x"
   shows "R\<^sup>\<oplus> x x"
   using assms by blast
 
 lemma Refl_RelE [elim]:
   assumes "R\<^sup>\<oplus> x y"
   obtains "R x x" "R y y" "R x y"
   using assms unfolding Refl_Rel_def by blast
 
 lemma Refl_Rel_reflexive_on_in_field [iff]:
   "reflexive_on (in_field R\<^sup>\<oplus>) R\<^sup>\<oplus>"
   by (rule reflexive_onI) auto
 
 lemma Refl_Rel_le_self [iff]: "R\<^sup>\<oplus> \<le> R" by blast
 
 lemma Refl_Rel_eq_self_if_reflexive_on [simp]:
   assumes "reflexive_on (in_field R) R"
   shows "R\<^sup>\<oplus> = R"
   using assms by blast
 
 lemma reflexive_on_in_field_if_Refl_Rel_eq_self:
   assumes "R\<^sup>\<oplus> = R"
   shows "reflexive_on (in_field R) R"
   by (fact Refl_Rel_reflexive_on_in_field[of R, simplified assms])
 
 corollary Refl_Rel_eq_self_iff_reflexive_on:
   "R\<^sup>\<oplus> = R \<longleftrightarrow> reflexive_on (in_field R) R"
   using Refl_Rel_eq_self_if_reflexive_on reflexive_on_in_field_if_Refl_Rel_eq_self
   by blast
 
 lemma Refl_Rel_Refl_Rel_eq [simp]: "(R\<^sup>\<oplus>)\<^sup>\<oplus> = R\<^sup>\<oplus>"
   by (intro ext) auto
 
 lemma rel_inv_Refl_Rel_eq [simp]: "(R\<^sup>\<oplus>)\<inverse> = (R\<inverse>)\<^sup>\<oplus>"
   by (intro ext iffI Refl_RelI rel_invI) auto
 
 lemma Refl_Rel_transitive_onI [intro]:
   assumes "transitive_on (P :: 'a \<Rightarrow> bool) (R :: 'a \<Rightarrow> _)"
   shows "transitive_on P R\<^sup>\<oplus>"
   using assms by (intro transitive_onI) (blast dest: transitive_onD)
 
 corollary Refl_Rel_transitiveI [intro]:
   assumes "transitive R"
   shows "transitive R\<^sup>\<oplus>"
   using assms by blast
 
 corollary Refl_Rel_preorder_onI:
   assumes "transitive_on P R"
   and "P \<le> in_field R\<^sup>\<oplus>"
   shows "preorder_on P R\<^sup>\<oplus>"
   using assms by (intro preorder_onI
     reflexive_on_if_le_pred_if_reflexive_on[where ?P="in_field R\<^sup>\<oplus>" and ?P'=P])
   auto
 
 corollary Refl_Rel_preorder_on_in_fieldI [intro]:
   assumes "transitive R"
   shows "preorder_on (in_field R\<^sup>\<oplus>) R\<^sup>\<oplus>"
   using assms by (intro Refl_Rel_preorder_onI) auto
 
 lemma Refl_Rel_symmetric_onI [intro]:
   assumes "symmetric_on (P :: 'a \<Rightarrow> bool) (R :: 'a \<Rightarrow> _)"
   shows "symmetric_on P R\<^sup>\<oplus>"
   using assms by (intro symmetric_onI) (auto dest: symmetric_onD)
 
 lemma Refl_Rel_symmetricI [intro]:
   assumes "symmetric R"
   shows "symmetric R\<^sup>\<oplus>"
   using assms by (fold symmetric_on_in_field_iff_symmetric)
   (blast intro: symmetric_on_if_le_pred_if_symmetric_on)
 
 lemma Refl_Rel_partial_equivalence_rel_onI [intro]:
   assumes "partial_equivalence_rel_on (P :: 'a \<Rightarrow> bool) (R :: 'a \<Rightarrow> _)"
   shows "partial_equivalence_rel_on P R\<^sup>\<oplus>"
   using assms by (intro partial_equivalence_rel_onI Refl_Rel_transitive_onI
     Refl_Rel_symmetric_onI) auto
 
 lemma Refl_Rel_partial_equivalence_relI [intro]:
   assumes "partial_equivalence_rel R"
   shows "partial_equivalence_rel R\<^sup>\<oplus>"
   using assms
   by (intro partial_equivalence_relI Refl_Rel_transitiveI Refl_Rel_symmetricI) auto
 
 lemma Refl_Rel_app_leftI:
   assumes "R (f x) y"
   and "in_field S\<^sup>\<oplus> x"
   and "in_field R\<^sup>\<oplus> y"
   and "(S \<Rrightarrow>\<^sub>m R) f"
   shows "R\<^sup>\<oplus> (f x) y"
 proof (rule Refl_RelI)
   from \<open>in_field R\<^sup>\<oplus> y\<close> show "R y y" by blast
   from \<open>in_field S\<^sup>\<oplus> x\<close> have "S x x" by blast
   with \<open>(S \<Rrightarrow>\<^sub>m R) f\<close> show "R (f x) (f x)" by blast
 qed fact
 
 corollary Refl_Rel_app_rightI:
   assumes "R x (f y)"
   and "in_field S\<^sup>\<oplus> y"
   and "in_field R\<^sup>\<oplus> x"
   and "(S \<Rrightarrow>\<^sub>m R) f"
   shows "R\<^sup>\<oplus> x (f y)"
 proof -
   from assms have "(R\<inverse>)\<^sup>\<oplus> (f y) x" by (intro Refl_Rel_app_leftI[where ?S="S\<inverse>"])
-    (auto simp flip: rel_inv_Refl_Rel_eq)
+    (auto 5 0 simp flip: rel_inv_Refl_Rel_eq)
   then show ?thesis by blast
 qed
 
 lemma mono_wrt_rel_Refl_Rel_Refl_Rel_if_mono_wrt_rel [intro]:
   assumes "(R \<Rrightarrow>\<^sub>m S) f"
   shows "(R\<^sup>\<oplus> \<Rrightarrow>\<^sub>m S\<^sup>\<oplus>) f"
-  using assms by (intro dep_mono_wrt_relI) auto
+  using assms by (intro dep_mono_wrt_relI) blast
 
 context galois
 begin
 
 interpretation gR : galois "(\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus>" "(\<le>\<^bsub>R\<^esub>)\<^sup>\<oplus>" l r .
 
 lemma Galois_Refl_RelI:
   assumes "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "in_field (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> x"
   and "in_field (\<le>\<^bsub>R\<^esub>)\<^sup>\<oplus> y"
   and "in_codom (\<le>\<^bsub>R\<^esub>) y \<Longrightarrow> x \<^bsub>L\<^esub>\<lessapprox> y"
   shows "(galois_rel.Galois ((\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus>) ((\<le>\<^bsub>R\<^esub>)\<^sup>\<oplus>) r) x y"
   using assms by (intro gR.left_GaloisI in_codomI Refl_Rel_app_rightI[where ?f=r])
   auto
 
 lemma half_galois_prop_left_Refl_Rel_left_rightI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   shows "((\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)\<^sup>\<oplus>) l r"
   using assms by (intro gR.half_galois_prop_leftI Refl_RelI)
   (auto elim!: in_codomE gR.left_GaloisE Refl_RelE)
 
 interpretation flip_inv : galois "(\<ge>\<^bsub>R\<^esub>)" "(\<ge>\<^bsub>L\<^esub>)" r l
   rewrites "((\<ge>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<ge>\<^bsub>L\<^esub>)) \<equiv> ((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>))"
   and "\<And>R. (R\<inverse>)\<^sup>\<oplus> \<equiv> (R\<^sup>\<oplus>)\<inverse>"
   and "\<And>R S f g. (R\<inverse> \<^sub>h\<unlhd> S\<inverse>) f g \<equiv> (S \<unlhd>\<^sub>h R) g f"
   by (simp_all add: galois_prop.half_galois_prop_left_rel_inv_iff_half_galois_prop_right)
 
 lemma half_galois_prop_right_Refl_Rel_right_leftI:
   assumes "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   shows "((\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)\<^sup>\<oplus>) l r"
   using assms by (fact flip_inv.half_galois_prop_left_Refl_Rel_left_rightI)
 
 corollary galois_prop_Refl_Rel_left_rightI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<stileturn> (\<le>\<^bsub>R\<^esub>)) l r"
   shows "((\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<unlhd> (\<le>\<^bsub>R\<^esub>)\<^sup>\<oplus>) l r"
   using assms
   by (intro gR.galois_propI half_galois_prop_left_Refl_Rel_left_rightI
     half_galois_prop_right_Refl_Rel_right_leftI) auto
 
 lemma galois_connection_Refl_Rel_left_rightI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<stileturn> (\<le>\<^bsub>R\<^esub>)) l r"
   shows "((\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<stileturn> (\<le>\<^bsub>R\<^esub>)\<^sup>\<oplus>) l r"
   using assms
   by (intro gR.galois_connectionI galois_prop_Refl_Rel_left_rightI) auto
 
 lemma galois_equivalence_Refl_RelI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R\<^esub>)) l r"
   shows "((\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<equiv>\<^sub>G (\<le>\<^bsub>R\<^esub>)\<^sup>\<oplus>) l r"
 proof -
   interpret flip : galois R L r l .
   show ?thesis using assms by (intro gR.galois_equivalenceI
     galois_connection_Refl_Rel_left_rightI flip.galois_prop_Refl_Rel_left_rightI)
   auto
 qed
 
 end
 
 context order_functors
 begin
 
 lemma inflationary_on_in_field_Refl_Rel_left:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "inflationary_on (in_dom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   shows "inflationary_on (in_field (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus>) (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<eta>"
   using assms
-  by (intro inflationary_onI Refl_RelI) (auto elim!: in_fieldE Refl_RelE)
+  by (intro inflationary_onI Refl_RelI) (auto 0 3 elim!: in_fieldE Refl_RelE)
 
 lemma inflationary_on_in_field_Refl_Rel_left':
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "inflationary_on (in_codom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   shows "inflationary_on (in_field (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus>) (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<eta>"
   using assms
-  by (intro inflationary_onI Refl_RelI) (auto elim!: in_fieldE Refl_RelE)
+  by (intro inflationary_onI Refl_RelI) (auto 0 3 elim!: in_fieldE Refl_RelE)
 
 interpretation inv : galois "(\<ge>\<^bsub>L\<^esub>)" "(\<ge>\<^bsub>R\<^esub>)" l r
   rewrites "((\<ge>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<ge>\<^bsub>R\<^esub>)) \<equiv> ((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>))"
   and "((\<ge>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<ge>\<^bsub>L\<^esub>)) \<equiv> ((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>))"
   and "\<And>R. (R\<inverse>)\<^sup>\<oplus> \<equiv> (R\<^sup>\<oplus>)\<inverse>"
   and "\<And>R. in_dom R\<inverse> \<equiv> in_codom R"
   and "\<And>R. in_codom R\<inverse> \<equiv> in_dom R"
   and "\<And>R. in_field R\<inverse> \<equiv> in_field R"
   and "\<And>P R. inflationary_on P R\<inverse> \<equiv> deflationary_on P R"
   by simp_all
 
 lemma deflationary_on_in_field_Refl_Rel_leftI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "deflationary_on (in_dom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   shows "deflationary_on (in_field (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus>) (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<eta>"
   using assms by (fact inv.inflationary_on_in_field_Refl_Rel_left')
 
 lemma deflationary_on_in_field_Refl_RelI_left':
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "deflationary_on (in_codom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   shows "deflationary_on (in_field (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus>) (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<eta>"
   using assms by (fact inv.inflationary_on_in_field_Refl_Rel_left)
 
 lemma rel_equivalence_on_in_field_Refl_Rel_leftI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "rel_equivalence_on (in_dom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   shows "rel_equivalence_on (in_field (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus>) (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<eta>"
   using assms by (intro rel_equivalence_onI
     inflationary_on_in_field_Refl_Rel_left
     deflationary_on_in_field_Refl_Rel_leftI)
   auto
 
 lemma rel_equivalence_on_in_field_Refl_Rel_leftI':
   assumes "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   and "((\<le>\<^bsub>R\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L\<^esub>)) r"
   and "rel_equivalence_on (in_codom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   shows "rel_equivalence_on (in_field (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus>) (\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<eta>"
   using assms by (intro rel_equivalence_onI
     inflationary_on_in_field_Refl_Rel_left'
     deflationary_on_in_field_Refl_RelI_left')
   auto
 
 interpretation oR : order_functors "(\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus>" "(\<le>\<^bsub>R\<^esub>)\<^sup>\<oplus>" l r .
 
 lemma order_equivalence_Refl_RelI:
   assumes "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)) l r"
   shows "((\<le>\<^bsub>L\<^esub>)\<^sup>\<oplus> \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)\<^sup>\<oplus>) l r"
 proof -
   interpret flip : galois R L r l
     rewrites "flip.unit \<equiv> \<epsilon>"
     by (simp only: flip_unit_eq_counit)
   show ?thesis using assms by (intro oR.order_equivalenceI
     mono_wrt_rel_Refl_Rel_Refl_Rel_if_mono_wrt_rel
     rel_equivalence_on_in_field_Refl_Rel_leftI
     flip.rel_equivalence_on_in_field_Refl_Rel_leftI)
     (auto intro: rel_equivalence_on_if_le_pred_if_rel_equivalence_on
       in_field_if_in_dom)
 qed
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Functions/Transport_Functions.thy b/thys/Transport/Transport/Functions/Transport_Functions.thy
--- a/thys/Transport/Transport/Functions/Transport_Functions.thy
+++ b/thys/Transport/Transport/Functions/Transport_Functions.thy
@@ -1,248 +1,248 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 theory Transport_Functions
   imports
     Transport_Functions_Galois_Equivalence
     Transport_Functions_Galois_Relator
     Transport_Functions_Order_Base
     Transport_Functions_Order_Equivalence
     Transport_Functions_Relation_Simplifications
 begin
 
 paragraph \<open>Summary\<close>
 text \<open>Composition under (dependent) (monotone) function relators.
 Refer to \<^cite>\<open>"transport"\<close> for more details.\<close>
 
 subsection \<open>Summary of Main Results\<close>
 
 text \<open>More precise results can be found in the corresponding subtheories.\<close>
 
 paragraph \<open>Monotone Dependent Function Relator\<close>
 
 context transport_Mono_Dep_Fun_Rel
 begin
 
 interpretation flip : transport_Mono_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2
   rewrites "flip.t1.counit \<equiv> \<eta>\<^sub>1" and "flip.t1.unit \<equiv> \<epsilon>\<^sub>1"
   by (simp_all only: t1.flip_counit_eq_unit t1.flip_unit_eq_counit)
 
 subparagraph \<open>Closure of Order and Galois Concepts\<close>
 
 theorem preorder_galois_connection_if_galois_connectionI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<stileturn> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([_ x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x2 \<le>\<^bsub>L1\<^esub> x3 \<and> x4 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x3)] \<Rrightarrow> (\<ge>)) L2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | \<epsilon>\<^sub>1 x2' \<le>\<^bsub>R1\<^esub> x1'] \<Rrightarrow>\<^sub>m [x3' _ \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<stileturn>\<^bsub>pre\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro preorder_galois_connectionI
     galois_connection_left_right_if_mono_if_galois_connectionI'
     preorder_on_in_field_leftI flip.preorder_on_in_field_leftI
     tdfr.transitive_leftI' flip.tdfr.transitive_leftI
     tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_leftI
     tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_rightI)
   (auto intro: reflexive_on_if_le_pred_if_reflexive_on
       in_field_if_in_dom in_field_if_in_codom)
 
 theorem preorder_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 _ \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 _ \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1' _ \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' _ \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro preorder_equivalence_if_galois_equivalenceI
     galois_equivalence_if_mono_if_preorder_equivalenceI'
     preorder_on_in_field_leftI flip.preorder_on_in_field_leftI
     tdfr.transitive_leftI' flip.tdfr.transitive_leftI
     tdfr.transitive_left2_if_preorder_equivalenceI
     tdfr.transitive_right2_if_preorder_equivalenceI
     tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_leftI
     tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_rightI
     tdfr.galois_equivalence_if_mono_if_galois_equivalence_mono_assms_leftI
     flip.tdfr.galois_equivalence_if_mono_if_galois_equivalence_mono_assms_leftI)
   (auto intro: reflexive_on_if_le_pred_if_reflexive_on
     in_field_if_in_dom in_field_if_in_codom)
 
 theorem partial_equivalence_rel_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 _ \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 _ \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1' _ \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' _ \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
-  using assms by (intro partial_equivalence_rel_equivalence_if_galois_equivalenceI
+  using assms
+  by (intro partial_equivalence_rel_equivalence_if_galois_equivalenceI
     galois_equivalence_if_mono_if_preorder_equivalenceI'
     tdfr.transitive_left2_if_preorder_equivalenceI
     tdfr.transitive_right2_if_preorder_equivalenceI
     partial_equivalence_rel_leftI flip.partial_equivalence_rel_leftI
     tdfr.partial_equivalence_rel_left2_if_partial_equivalence_rel_equivalenceI
     tdfr.partial_equivalence_rel_right2_if_partial_equivalence_rel_equivalenceI)
   auto
 
-
 subparagraph \<open>Simplification of Left and Right Relations\<close>
 
 text \<open>See @{thm "left_rel_eq_tdfr_leftI_if_equivalencesI"}.\<close>
 
 
 subparagraph \<open>Simplification of Galois relator\<close>
 
 text \<open>See
 @{thm "left_Galois_eq_Dep_Fun_Rel_left_Galois_restrict_if_mono_if_galois_connectionI"
 "left_Galois_eq_Dep_Fun_Rel_left_Galois_restrict_if_preorder_equivalenceI"
 "left_Galois_eq_Dep_Fun_Rel_left_Galois_restrict_if_preorder_equivalenceI'"
 "Dep_Fun_Rel_left_Galois_restrict_left_right_eq_Dep_Fun_Rel_left_GaloisI"
 "Dep_Fun_Rel_left_Galois_restrict_left_right_restrict_left_right_eq"}\<close>
 
 end
 
 
 paragraph \<open>Monotone Function Relator\<close>
 
 context transport_Mono_Fun_Rel
 begin
 
 interpretation flip : transport_Mono_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2 .
 
 subparagraph \<open>Closure of Order and Galois Concepts\<close>
 
 lemma preorder_galois_connection_if_galois_connectionI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)" "reflexive_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<stileturn> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   and "transitive (\<le>\<^bsub>L2\<^esub>)" "transitive (\<le>\<^bsub>R2\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<stileturn>\<^bsub>pre\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro tpdfr.preorder_galois_connectionI
     galois_connection_left_rightI
     tpdfr.preorder_on_in_field_leftI flip.tpdfr.preorder_on_in_field_leftI
     tfr.transitive_leftI' flip.tfr.transitive_leftI)
   auto
 
 theorem preorder_galois_connectionI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>L2\<^esub>) \<stileturn>\<^bsub>pre\<^esub> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   shows "((\<le>\<^bsub>L\<^esub>) \<stileturn>\<^bsub>pre\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro preorder_galois_connection_if_galois_connectionI)
   (auto intro: reflexive_on_if_le_pred_if_reflexive_on
     in_field_if_in_dom in_field_if_in_codom)
 
 theorem preorder_equivalence_if_galois_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)" "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   and "transitive (\<le>\<^bsub>L2\<^esub>)" "transitive (\<le>\<^bsub>R2\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro tpdfr.preorder_equivalence_if_galois_equivalenceI
     galois_equivalenceI
     tpdfr.preorder_on_in_field_leftI flip.tpdfr.preorder_on_in_field_leftI
     tfr.transitive_leftI flip.tfr.transitive_leftI)
   (auto intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_dom)
 
 theorem preorder_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>L2\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro preorder_equivalence_if_galois_equivalenceI) auto
 
 theorem partial_equivalence_rel_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>L2\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro tpdfr.partial_equivalence_rel_equivalence_if_galois_equivalenceI
     galois_equivalenceI
     partial_equivalence_rel_leftI flip.partial_equivalence_rel_leftI)
   auto
 
 
 subparagraph \<open>Simplification of Left and Right Relations\<close>
 
 text \<open>See @{thm "left_rel_eq_tfr_leftI"}.\<close>
 
 
 subparagraph \<open>Simplification of Galois relator\<close>
 
 text \<open>See @{thm "left_Galois_eq_Fun_Rel_left_Galois_restrictI"
 "Fun_Rel_left_Galois_restrict_left_right_eq_Fun_Rel_left_GaloisI"
 "Fun_Rel_left_Galois_restrict_left_right_restrict_left_right_eq"}.\<close>
 
 end
 
 
 paragraph \<open>Dependent Function Relator\<close>
 
 text \<open>While a general transport of functions is only possible for the monotone
 function relator (see above), the locales @{locale "transport_Dep_Fun_Rel"} and
 @{locale "transport_Fun_Rel"} contain special cases to transport functions
 that are proven to be monotone using the standard function space.
 
 Moreover, in the special case of equivalences on partial equivalence relations,
 the standard function space is monotone - see
 @{thm "transport_Mono_Dep_Fun_Rel.left_rel_eq_tdfr_leftI_if_equivalencesI"}
 As such, we can derive general transport theorems from the monotone cases
 above.\<close>
 
 context transport_Dep_Fun_Rel
 begin
 
 interpretation tpdfr : transport_Mono_Dep_Fun_Rel L1 R1 l1 r1 L2 R2 l2 r2 .
 interpretation flip : transport_Mono_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2 .
 
 theorem partial_equivalence_rel_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1' x2' \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
 proof -
   from assms have "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) = (tpdfr.L \<equiv>\<^bsub>PER\<^esub> tpdfr.R)"
     by (subst tpdfr.left_rel_eq_tdfr_leftI_if_equivalencesI
         flip.left_rel_eq_tdfr_leftI_if_equivalencesI,
       auto intro!: partial_equivalence_rel_left2_if_partial_equivalence_rel_equivalenceI
         partial_equivalence_rel_right2_if_partial_equivalence_rel_equivalenceI
       iff: t1.galois_equivalence_right_left_iff_galois_equivalence_left_right)+
   with assms show ?thesis
     by (auto intro!: tpdfr.partial_equivalence_rel_equivalenceI)
 qed
 
 end
 
 
 paragraph \<open>Function Relator\<close>
 
 context transport_Fun_Rel
 begin
 
 interpretation tpfr : transport_Mono_Fun_Rel L1 R1 l1 r1 L2 R2 l2 r2 .
 interpretation flip_tpfr : transport_Mono_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2 .
 
 theorem partial_equivalence_rel_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>L2\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
 proof -
   from assms have "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) = (tpfr.tpdfr.L \<equiv>\<^bsub>PER\<^esub> tpfr.tpdfr.R)"
     by (subst tpfr.left_rel_eq_tfr_leftI flip_tpfr.left_rel_eq_tfr_leftI; auto)+
   with assms show ?thesis by (auto intro!: tpfr.partial_equivalence_rel_equivalenceI)
 qed
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Functions/Transport_Functions_Galois_Connection.thy b/thys/Transport/Transport/Functions/Transport_Functions_Galois_Connection.thy
--- a/thys/Transport/Transport/Functions/Transport_Functions_Galois_Connection.thy
+++ b/thys/Transport/Transport/Functions/Transport_Functions_Galois_Connection.thy
@@ -1,307 +1,307 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Galois Connection\<close>
 theory Transport_Functions_Galois_Connection
   imports
     Transport_Functions_Galois_Property
     Transport_Functions_Monotone
 begin
 
 paragraph \<open>Dependent Function Relator\<close>
 
 context transport_Dep_Fun_Rel
 begin
 
 subparagraph \<open>Lemmas for Monotone Function Relator\<close>
 
 lemma galois_connection_left_right_if_galois_connection_mono_2_assms_leftI:
   assumes galois_conn1: "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_R1: "reflexive_on (in_codom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and R2_le1: "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and mono_l2_2: "([x' \<Colon> in_codom (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x'] \<Rrightarrow>\<^sub>m
     [in_field (\<le>\<^bsub>L2 x1 (r1 x')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x'\<^esub>)) l2"
   shows "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x2')\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub>)"
 proof -
   show "([in_codom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x2')\<^esub>)"
     if "x1' \<le>\<^bsub>R1\<^esub> x2'" for x1' x2'
   proof -
     from galois_conn1 \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close> have "r1 x1' \<le>\<^bsub>L1\<^esub> r1 x2'" "r1 x2' \<^bsub>L1\<^esub>\<lessapprox> x2'"
       using refl_R1 by (auto intro: t1.right_left_Galois_if_reflexive_onI)
     with mono_l2_2 show ?thesis using R2_le1 \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close> by fastforce
   qed
   show "([in_dom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub>)"
     if "x \<le>\<^bsub>L1\<^esub> x" for x
   proof -
     from galois_conn1 \<open>x \<le>\<^bsub>L1\<^esub> x\<close> have "x \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x" "\<eta>\<^sub>1 x \<^bsub>L1\<^esub>\<lessapprox> l1 x"
       by (auto intro!: t1.right_left_Galois_if_right_relI
         t1.rel_unit_if_left_rel_if_half_galois_prop_right_if_mono_wrt_rel
           [unfolded t1.unit_eq])
     with mono_l2_2 show ?thesis by fastforce
   qed
 qed
 
 lemma galois_connection_left_right_if_galois_connection_mono_assms_leftI:
   assumes galois_conn1: "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_R1: "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and R2_le1: "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and mono_l2: "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   shows "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x1' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
   and "([x' \<Colon> in_codom (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x'] \<Rrightarrow>\<^sub>m
     [in_field (\<le>\<^bsub>L2 x1 (r1 x')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x'\<^esub>)) l2"
 proof -
   show "([in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x1' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
     if "x1' \<le>\<^bsub>R1\<^esub> x2'" for x1' x2'
   proof -
     from galois_conn1 \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close> have "r1 x1' \<le>\<^bsub>L1\<^esub> r1 x1'" "r1 x1' \<^bsub>L1\<^esub>\<lessapprox> x1'"
-      using refl_R1 by blast+
-    with mono_l2 show ?thesis using \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close> R2_le1 by (auto 9 0)
+      using refl_R1 by force+
+    with mono_l2 show ?thesis using \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close> R2_le1 by (auto 11 0)
   qed
   from mono_l2 show "([x' \<Colon> in_codom (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x'] \<Rrightarrow>\<^sub>m
     [in_field (\<le>\<^bsub>L2 x1 (r1 x')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x'\<^esub>)) l2" using refl_R1 by blast
 qed
 
 text \<open>In theory, the following lemmas can be obtained by taking the flipped,
 inverse interpretation of the locale; however, rewriting the assumptions is more
 involved than simply copying and adapting above proofs.\<close>
 
 lemma galois_connection_left_right_if_galois_connection_mono_2_assms_rightI:
   assumes galois_conn1: "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_L1: "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and L2_le2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and mono_r2_2: "([x \<Colon> in_dom (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>\<^sub>m
     [in_field (\<le>\<^bsub>R2 (l1 x) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x (r1 x2')\<^esub>)) r2"
   shows "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x1)\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub>)"
 proof -
   show "([in_dom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x1)\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
     if "x1 \<le>\<^bsub>L1\<^esub> x2" for x1 x2
   proof -
     from galois_conn1 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> have "x1 \<^bsub>L1\<^esub>\<lessapprox> l1 x1" "l1 x1 \<le>\<^bsub>R1\<^esub> l1 x2"
       using refl_L1 by (auto intro!: t1.left_Galois_left_if_reflexive_on_if_half_galois_prop_rightI)
-    with mono_r2_2 show ?thesis using L2_le2 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> by (auto 9 0)
+    with mono_r2_2 show ?thesis using L2_le2 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> by (auto 12 0)
   qed
   show "([in_codom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub>)"
     if "x' \<le>\<^bsub>R1\<^esub> x'" for x'
   proof -
     from galois_conn1 \<open>x' \<le>\<^bsub>R1\<^esub> x'\<close> have "r1 x' \<^bsub>L1\<^esub>\<lessapprox> \<epsilon>\<^sub>1 x'" "\<epsilon>\<^sub>1 x' \<le>\<^bsub>R1\<^esub> x'"
       by (auto intro!: t1.left_Galois_left_if_left_relI
         t1.counit_rel_if_right_rel_if_half_galois_prop_left_if_mono_wrt_rel
           [unfolded t1.counit_eq])
     with mono_r2_2 show ?thesis by fastforce
   qed
 qed
 
 lemma galois_connection_left_right_if_galois_connection_mono_assms_rightI:
   assumes galois_conn1: "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_L1: "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and L2_le2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and mono_r2: "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   shows "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub>)"
   and "([x \<Colon> in_dom (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>\<^sub>m
     [in_field (\<le>\<^bsub>R2 (l1 x) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x (r1 x2')\<^esub>)) r2"
 proof -
   show "([in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub>)"
     if "x1 \<le>\<^bsub>L1\<^esub> x2" for x1 x2
   proof -
     from galois_conn1 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> have "x2 \<^bsub>L1\<^esub>\<lessapprox> l1 x2" "l1 x2 \<le>\<^bsub>R1\<^esub> l1 x2"
       using refl_L1 by (blast intro: t1.left_Galois_left_if_reflexive_on_if_half_galois_prop_rightI)+
     with mono_r2 show ?thesis using \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> L2_le2 by fastforce
   qed
   from mono_r2 show "([x \<Colon> in_dom (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>\<^sub>m
     [in_field (\<le>\<^bsub>R2 (l1 x) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x (r1 x2')\<^esub>)) r2" using refl_L1 by blast
 qed
 
 end
 
 
 paragraph \<open>Monotone Dependent Function Relator\<close>
 
 context transport_Mono_Dep_Fun_Rel
 begin
 
 interpretation flip : transport_Mono_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2 .
 
 lemma galois_connection_left_rightI:
   assumes "(tdfr.L \<Rrightarrow>\<^sub>m tdfr.R) l" and "(tdfr.R \<Rrightarrow>\<^sub>m tdfr.L) r"
   and "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<unlhd> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) \<le> (\<le>\<^bsub>L2 x x\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>) \<le> (\<le>\<^bsub>R2 x' x'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<stileturn> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms
   by (intro galois_connectionI galois_prop_left_rightI' mono_wrt_rel_leftI
     flip.mono_wrt_rel_leftI)
   auto
 
 lemma galois_connection_left_rightI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ((\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<unlhd> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x1' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x2')\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x1)\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<stileturn> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms
   by (intro galois_connection_left_rightI tdfr.mono_wrt_rel_left_if_transitiveI
     tdfr.mono_wrt_rel_right_if_transitiveI)
   auto
 
 lemma galois_connection_left_right_if_galois_connectionI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<stileturn> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x1' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x2')\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x1)\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<stileturn> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms
   by (intro galois_connection_left_rightI'
     tdfr.mono_wrt_rel_left2_if_mono_wrt_rel_left2_if_left_GaloisI
     tdfr.mono_wrt_rel_right2_if_mono_wrt_rel_right2_if_left_GaloisI)
   (auto 7 0)
 
 corollary galois_connection_left_right_if_galois_connectionI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow>
     ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<stileturn> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x1' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
   and "([x' \<Colon> in_codom (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x'] \<Rrightarrow>\<^sub>m
     [in_field (\<le>\<^bsub>L2 x1 (r1 x')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x'\<^esub>)) l2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub>)"
   and "([x \<Colon> in_dom (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>\<^sub>m
     [in_field (\<le>\<^bsub>R2 (l1 x) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<stileturn> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro galois_connection_left_right_if_galois_connectionI
     tdfr.galois_connection_left_right_if_galois_connection_mono_2_assms_leftI
     tdfr.galois_connection_left_right_if_galois_connection_mono_2_assms_rightI)
   (auto intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_dom in_field_if_in_codom)
 
 corollary galois_connection_left_right_if_mono_if_galois_connectionI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<stileturn> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<stileturn> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro galois_connection_left_right_if_galois_connectionI'
     tdfr.galois_connection_left_right_if_galois_connection_mono_assms_leftI
     tdfr.galois_connection_left_right_if_galois_connection_mono_assms_rightI)
   auto
 
 corollary galois_connection_left_right_if_mono_if_galois_connectionI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<stileturn> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([_ x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x2 \<le>\<^bsub>L1\<^esub> x3 \<and> x4 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x3)] \<Rrightarrow> (\<ge>)) L2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | \<epsilon>\<^sub>1 x2' \<le>\<^bsub>R1\<^esub> x1'] \<Rrightarrow>\<^sub>m [x3' _ \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<stileturn> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro galois_connection_left_right_if_mono_if_galois_connectionI
     tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_leftI
     tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_rightI)
   auto
 
 end
 
 
 paragraph \<open>Monotone Function Relator\<close>
 
 context transport_Mono_Fun_Rel
 begin
 
 interpretation flip : transport_Mono_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2 .
 
 lemma galois_connection_left_rightI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<stileturn> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "transitive (\<le>\<^bsub>R2\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<stileturn> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro tpdfr.galois_connectionI galois_prop_left_rightI
     mono_wrt_rel_leftI flip.mono_wrt_rel_leftI)
   auto
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Functions/Transport_Functions_Galois_Equivalence.thy b/thys/Transport/Transport/Functions/Transport_Functions_Galois_Equivalence.thy
--- a/thys/Transport/Transport/Functions/Transport_Functions_Galois_Equivalence.thy
+++ b/thys/Transport/Transport/Functions/Transport_Functions_Galois_Equivalence.thy
@@ -1,351 +1,352 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Galois Equivalence\<close>
 theory Transport_Functions_Galois_Equivalence
   imports
     Transport_Functions_Galois_Connection
     Transport_Functions_Order_Base
 begin
 
 paragraph \<open>Dependent Function Relator\<close>
 
 context transport_Dep_Fun_Rel
 begin
 
 subparagraph \<open>Lemmas for Monotone Function Relator\<close>
 
 lemma flip_half_galois_prop_left2_if_half_galois_prop_left2_if_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and half_galois_prop_left2: "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow>
     ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>) (l2\<^bsub>x' x\<^esub>) "
   and "(\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>) = (\<le>\<^bsub>L2 x x\<^esub>)"
   and "(\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) = (\<le>\<^bsub>L2 x x\<^esub>)"
   and "x \<le>\<^bsub>L1\<^esub> x"
   shows "((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub>)"
 proof -
   from assms have "x \<^bsub>L1\<^esub>\<lessapprox> l1 x" by (intro t1.left_Galois_left_if_left_relI) auto
   with half_galois_prop_left2
     have "((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub>)" by auto
   with assms show ?thesis by simp
 qed
 
 lemma flip_half_galois_prop_right2_if_half_galois_prop_right2_if_GaloisI:
   assumes "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and half_galois_prop_right2: "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow>
     ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>) (l2\<^bsub>x' x\<^esub>)"
   and "(\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>) = (\<le>\<^bsub>R2 x' x'\<^esub>)"
   and "(\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>) = (\<le>\<^bsub>R2 x' x'\<^esub>)"
   and "x' \<le>\<^bsub>R1\<^esub> x'"
   shows "((\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') x'\<^esub>) (l2\<^bsub>x' (r1 x')\<^esub>)"
 proof -
   from assms have "r1 x' \<^bsub>L1\<^esub>\<lessapprox> x'" by (intro t1.right_left_Galois_if_right_relI) auto
   with half_galois_prop_right2
     have "((\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') x'\<^esub>) (l2\<^bsub>x' (r1 x')\<^esub>)" by auto
   with assms show ?thesis by simp
 qed
 
 interpretation flip : transport_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2
   rewrites "flip.t1.counit \<equiv> \<eta>\<^sub>1" and "flip.t1.unit \<equiv> \<epsilon>\<^sub>1"
   by (simp_all only: t1.flip_counit_eq_unit t1.flip_unit_eq_counit)
 
 lemma galois_equivalence_if_mono_if_galois_equivalence_mono_assms_leftI:
   assumes galois_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and preorder_L1: "preorder_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and mono_L2: "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   shows "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | \<eta>\<^sub>1 x2 \<le>\<^bsub>L1\<^esub> x1] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2" (is ?goal1)
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x2 \<le>\<^bsub>L1\<^esub> x3 \<and> x4 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x3)] \<Rrightarrow> (\<ge>)) L2" (is ?goal2)
 proof -
   show ?goal1
   proof (intro dep_mono_wrt_relI rel_if_if_impI Dep_Fun_Rel_relI)
     fix x1 x2 x3 x4 assume "x1 \<le>\<^bsub>L1\<^esub> x2"
     moreover with galois_equiv1 preorder_L1 have "x2 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2"
       by (blast intro: t1.rel_unit_if_reflexive_on_if_galois_connection)
     moreover assume "\<eta>\<^sub>1 x2 \<le>\<^bsub>L1\<^esub> x1"
     ultimately have "x2 \<equiv>\<^bsub>L1\<^esub> x1" using preorder_L1 by blast
     moreover assume "x3 \<le>\<^bsub>L1\<^esub> x4" "x2 \<le>\<^bsub>L1\<^esub> x3"
-    ultimately show "(\<le>\<^bsub>L2 x1 x3\<^esub>) \<le> (\<le>\<^bsub>L2 x2 x4\<^esub>)" using preorder_L1 mono_L2 by blast
+    ultimately show "(\<le>\<^bsub>L2 x1 x3\<^esub>) \<le> (\<le>\<^bsub>L2 x2 x4\<^esub>)" using preorder_L1 mono_L2
+      by (intro le_relI) (blast dest!: rel_ifD elim!: dep_mono_wrt_relE)
   qed
   show ?goal2
   proof (intro dep_mono_wrt_relI rel_if_if_impI Dep_Fun_Rel_relI)
     fix x1 x2 x3 x4 presume "x3 \<le>\<^bsub>L1\<^esub> x4" "x4 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x3"
     moreover with galois_equiv1 preorder_L1 have "\<eta>\<^sub>1 x3 \<le>\<^bsub>L1\<^esub> x3"
       by (blast intro: flip.t1.counit_rel_if_reflexive_on_if_galois_connection)
     ultimately have "x3 \<equiv>\<^bsub>L1\<^esub> x4" using preorder_L1 by blast
     moreover presume "x1 \<le>\<^bsub>L1\<^esub> x2" "x2 \<le>\<^bsub>L1\<^esub> x3"
     ultimately show "(\<le>\<^bsub>L2 x2 x4\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x3\<^esub>)" using preorder_L1 mono_L2 by fast
   qed auto
 qed
 
 lemma galois_equivalence_if_mono_if_galois_equivalence_Dep_Fun_Rel_pred_assm_leftI:
   assumes galois_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_L1: "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and refl_R1: "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and mono_L2: "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and mono_R2: "([x1' x2' \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and mono_l2: "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "x \<le>\<^bsub>L1\<^esub> x"
   shows "([in_codom (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub>)"
 proof (intro Dep_Fun_Rel_predI)
   fix y assume "in_codom (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>) y"
   moreover from \<open>x \<le>\<^bsub>L1\<^esub> x\<close> galois_equiv1 refl_L1 have "x \<equiv>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x"
     by (blast intro: bi_related_if_rel_equivalence_on
       t1.rel_equivalence_on_unit_if_reflexive_on_if_galois_equivalence)
   moreover with refl_L1 have "\<eta>\<^sub>1 x \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x" by blast
   ultimately have "in_codom (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) (\<eta>\<^sub>1 x)\<^esub>) y" using mono_L2 by blast
   moreover from \<open>x \<le>\<^bsub>L1\<^esub> x\<close> galois_equiv1
     have "l1 x \<le>\<^bsub>R1\<^esub> l1 x" "\<eta>\<^sub>1 x \<le>\<^bsub>L1\<^esub> x" "x \<^bsub>L1\<^esub>\<lessapprox> l1 x"
     by (blast intro: t1.left_Galois_left_if_left_relI
       flip.t1.counit_rel_if_right_rel_if_galois_connection)+
   moreover note
     Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_l2 \<open>l1 x \<le>\<^bsub>R1\<^esub> l1 x\<close>] \<open>\<eta>\<^sub>1 x \<le>\<^bsub>L1\<^esub> x\<close>]
   ultimately have "l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y \<le>\<^bsub>R2 (\<epsilon>\<^sub>1 (l1 x)) (l1 x)\<^esub> l2\<^bsub>(l1 x) x\<^esub> y" by auto
   moreover note \<open>l1 x \<le>\<^bsub>R1\<^esub> l1 x\<close>
   moreover with galois_equiv1 refl_R1 have "l1 x \<equiv>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 (l1 x)"
     by (blast intro: bi_related_if_rel_equivalence_on
       flip.t1.rel_equivalence_on_unit_if_reflexive_on_if_galois_equivalence)
   ultimately show "l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y \<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub> l2\<^bsub>(l1 x) x\<^esub> y"
     using mono_R2 by blast
 qed
 
 lemma galois_equivalence_if_mono_if_galois_equivalence_Dep_Fun_Rel_pred_assm_right:
   assumes galois_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_R1: "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and mono_L2: "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and mono_R2: "([x1' x2' \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and mono_r2: "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "x' \<le>\<^bsub>R1\<^esub> x'"
   shows "([in_dom (\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') x'\<^esub>) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub>)"
 proof (intro Dep_Fun_Rel_predI)
   fix y assume "in_dom (\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>) y"
   moreover from \<open>x' \<le>\<^bsub>R1\<^esub> x'\<close> galois_equiv1 refl_R1 have "x' \<equiv>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x'"
     by (blast intro: bi_related_if_rel_equivalence_on
       flip.t1.rel_equivalence_on_unit_if_reflexive_on_if_galois_equivalence)
   moreover with refl_R1 have "\<epsilon>\<^sub>1 x' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x'" by blast
   ultimately have "in_dom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') (\<epsilon>\<^sub>1 x')\<^esub>) y" using mono_R2 by blast
   moreover from \<open>x' \<le>\<^bsub>R1\<^esub> x'\<close> galois_equiv1
     have "r1 x' \<le>\<^bsub>L1\<^esub> r1 x'" "x' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x'" "r1 x' \<^bsub>L1\<^esub>\<lessapprox> x'"
     by (blast intro: t1.right_left_Galois_if_right_relI
       flip.t1.rel_unit_if_left_rel_if_galois_connection)+
   moreover note
     Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_r2 \<open>r1 x' \<le>\<^bsub>L1\<^esub> r1 x'\<close>] \<open>x' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x'\<close>]
   ultimately have "r2\<^bsub>(r1 x') x'\<^esub> y \<le>\<^bsub>L2 (r1 x') (\<eta>\<^sub>1 (r1 x'))\<^esub> r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y" by auto
   moreover note \<open>r1 x' \<le>\<^bsub>L1\<^esub> r1 x'\<close>
   moreover with galois_equiv1 refl_R1 have "r1 x' \<equiv>\<^bsub>L1\<^esub> \<eta>\<^sub>1 (r1 x')"
     by (blast intro: bi_related_if_rel_equivalence_on
       t1.rel_equivalence_on_unit_if_reflexive_on_if_galois_equivalence)
   ultimately show "r2\<^bsub>(r1 x') x'\<^esub> y \<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub> r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y"
     using mono_L2 by blast
 qed
 
 end
 
 
 paragraph \<open>Monotone Dependent Function Relator\<close>
 
 context transport_Mono_Dep_Fun_Rel
 begin
 
 context
 begin
 
 interpretation flip : transport_Mono_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2
   rewrites "flip.t1.counit \<equiv> \<eta>\<^sub>1" and "flip.t1.unit \<equiv> \<epsilon>\<^sub>1"
   by (simp_all only: t1.flip_counit_eq_unit t1.flip_unit_eq_counit)
 
 lemma galois_equivalence_if_galois_equivalenceI:
   assumes galois_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_L1: "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and galois_equiv2: "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow>
     ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>) \<le> (\<le>\<^bsub>L2 x x\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x2' x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> (\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>) \<le> (\<le>\<^bsub>R2 x' x'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x1' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x2')\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x1)\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') x'\<^esub>) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R\<^esub>)) l r"
 proof -
   from galois_equiv2 have
     "((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<stileturn> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
     "((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>) (l2\<^bsub>x' x\<^esub>)"
     "((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>) (l2\<^bsub>x' x\<^esub>)"
     if "x \<^bsub>L1\<^esub>\<lessapprox> x'" for x x' using \<open>x \<^bsub>L1\<^esub>\<lessapprox> x'\<close>
     by (blast elim: galois.galois_connectionE galois_prop.galois_propE)+
   moreover from galois_equiv1 galois_equiv2 have
     "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
       ((\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
     by (intro tdfr.mono_wrt_rel_left2_if_mono_wrt_rel_left2_if_left_GaloisI) auto
   moreover from galois_equiv1 galois_equiv2 have
     "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
     by (intro tdfr.mono_wrt_rel_right2_if_mono_wrt_rel_right2_if_left_GaloisI)
     (auto elim!: t1.galois_equivalenceE)
   moreover from galois_equiv1 refl_L1 have
     "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> x \<equiv>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x"
     "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> x' \<equiv>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x'"
     by (blast intro!: bi_related_if_rel_equivalence_on
       t1.rel_equivalence_on_unit_if_reflexive_on_if_galois_equivalence
       flip.t1.rel_equivalence_on_unit_if_reflexive_on_if_galois_equivalence)+
   ultimately show ?thesis using assms
     by (intro galois_equivalenceI
       galois_connection_left_right_if_galois_connectionI flip.galois_prop_left_rightI
       tdfr.flip_half_galois_prop_left2_if_half_galois_prop_left2_if_left_GaloisI
       tdfr.flip_half_galois_prop_right2_if_half_galois_prop_right2_if_GaloisI
       tdfr.mono_wrt_rel_left_if_transitiveI tdfr.mono_wrt_rel_right_if_transitiveI
       flip.tdfr.left_rel_right_if_left_right_rel_le_right2_assmI
       flip.tdfr.left_right_rel_if_left_rel_right_ge_left2_assmI
       tdfr.left_rel2_unit_eqs_left_rel2I
       flip.tdfr.left_rel2_unit_eqs_left_rel2I)
     (auto elim!: t1.galois_equivalenceE
       intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_dom
       in_field_if_in_codom)
 qed
 
 corollary galois_equivalence_if_galois_equivalenceI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>) \<le> (\<le>\<^bsub>L2 x x\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x2' x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> (\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>) \<le> (\<le>\<^bsub>R2 x' x'\<^esub>)"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub>)"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') x'\<^esub>) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro galois_equivalence_if_galois_equivalenceI
     tdfr.galois_connection_left_right_if_galois_connection_mono_assms_leftI
     tdfr.galois_connection_left_right_if_galois_connection_mono_assms_rightI
     tdfr.galois_connection_left_right_if_galois_connection_mono_2_assms_leftI
     tdfr.galois_connection_left_right_if_galois_connection_mono_2_assms_rightI)
   (auto intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_dom
     in_field_if_in_codom)
 
 corollary galois_equivalence_if_mono_if_galois_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | \<eta>\<^sub>1 x2 \<le>\<^bsub>L1\<^esub> x1] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x2 \<le>\<^bsub>L1\<^esub> x3 \<and> x4 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x3)] \<Rrightarrow> (\<ge>)) L2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | \<epsilon>\<^sub>1 x2' \<le>\<^bsub>R1\<^esub> x1'] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | (x2' \<le>\<^bsub>R1\<^esub> x3' \<and> x4' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x3')] \<Rrightarrow> (\<ge>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub>)"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') x'\<^esub>) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro galois_equivalence_if_galois_equivalenceI'
     tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_leftI
     flip.tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_leftI
     tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_rightI
     flip.tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_rightI)
   auto
 
 end
 
 interpretation flip : transport_Mono_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2
   rewrites "flip.t1.counit \<equiv> \<eta>\<^sub>1" and "flip.t1.unit \<equiv> \<epsilon>\<^sub>1"
   by (simp_all only: t1.flip_counit_eq_unit t1.flip_unit_eq_counit)
 
 lemma galois_equivalence_if_mono_if_preorder_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1' x2' \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro galois_equivalence_if_mono_if_galois_equivalenceI
     tdfr.galois_equivalence_if_mono_if_galois_equivalence_mono_assms_leftI
     flip.tdfr.galois_equivalence_if_mono_if_galois_equivalence_mono_assms_leftI
     tdfr.galois_equivalence_if_mono_if_galois_equivalence_Dep_Fun_Rel_pred_assm_leftI
     tdfr.galois_equivalence_if_mono_if_galois_equivalence_Dep_Fun_Rel_pred_assm_right)
   auto
 
 theorem galois_equivalence_if_mono_if_preorder_equivalenceI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1' x2' \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro galois_equivalence_if_mono_if_preorder_equivalenceI
     tdfr.transitive_left2_if_preorder_equivalenceI
     tdfr.transitive_right2_if_preorder_equivalenceI)
   auto
 
 end
 
 
 paragraph \<open>Monotone Function Relator\<close>
 
 context transport_Mono_Fun_Rel
 begin
 
 interpretation flip : transport_Mono_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2 .
 
 lemma galois_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "transitive (\<le>\<^bsub>R2\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro tpdfr.galois_equivalenceI
     galois_connection_left_rightI flip.galois_prop_left_rightI)
   (auto intro: reflexive_on_if_le_pred_if_reflexive_on
     in_field_if_in_dom in_field_if_in_codom)
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Functions/Transport_Functions_Galois_Relator.thy b/thys/Transport/Transport/Functions/Transport_Functions_Galois_Relator.thy
--- a/thys/Transport/Transport/Functions/Transport_Functions_Galois_Relator.thy
+++ b/thys/Transport/Transport/Functions/Transport_Functions_Galois_Relator.thy
@@ -1,865 +1,865 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Galois Relator\<close>
 theory Transport_Functions_Galois_Relator
   imports
     Transport_Functions_Relation_Simplifications
 begin
 
 paragraph \<open>Dependent Function Relator\<close>
 
 context transport_Dep_Fun_Rel
 begin
 
 interpretation flip : transport_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2
   rewrites "flip.t1.counit \<equiv> \<eta>\<^sub>1" by (simp only: t1.flip_counit_eq_unit)
 
 lemma Dep_Fun_Rel_left_Galois_if_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_L1: "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and mono_r2: "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and L2_le2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and ge_L2_r2_le2: "\<And>x x' y'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> in_dom (\<le>\<^bsub>R2 (l1 x) x'\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 x (r1 x')\<^esub>) (r2\<^bsub>x (l1 x)\<^esub> y') \<le> (\<ge>\<^bsub>L2 x (r1 x')\<^esub>) (r2\<^bsub>x x'\<^esub> y')"
   and trans_L2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   and "f \<^bsub>L\<^esub>\<lessapprox> g"
   shows "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
 proof (intro Dep_Fun_Rel_relI)
   fix x x' assume "x \<^bsub>L1\<^esub>\<lessapprox> x'"
   show "f x \<^bsub>L2 x x'\<^esub>\<lessapprox> g x'"
   proof (intro t2.left_GaloisI)
     from \<open>x \<^bsub>L1\<^esub>\<lessapprox> x'\<close> \<open>((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1\<close> have "x \<le>\<^bsub>L1\<^esub> r1 x'" "l1 x \<le>\<^bsub>R1\<^esub> x'" by auto
     with \<open>g \<le>\<^bsub>R\<^esub> g\<close> have "g (l1 x) \<le>\<^bsub>R2 (l1 x) x'\<^esub> g x'" by blast
     then show "in_codom (\<le>\<^bsub>R2 (l1 x) x'\<^esub>) (g x')" by blast
 
     from \<open>f \<^bsub>L\<^esub>\<lessapprox> g\<close> have "f \<le>\<^bsub>L\<^esub> r g" by blast
     moreover from refl_L1 \<open>x \<^bsub>L1\<^esub>\<lessapprox> x'\<close> have "x \<le>\<^bsub>L1\<^esub> x" by blast
     ultimately have "f x \<le>\<^bsub>L2 x x\<^esub> (r g) x" by blast
     with L2_le2 \<open>x \<le>\<^bsub>L1\<^esub> r1 x'\<close> have "f x \<le>\<^bsub>L2 x (r1 x')\<^esub> (r g) x" by blast
     then have "f x \<le>\<^bsub>L2 x (r1 x')\<^esub> r2\<^bsub>x (l1 x)\<^esub> (g (l1 x))" by simp
     with ge_L2_r2_le2 have "f x \<le>\<^bsub>L2 x (r1 x')\<^esub> r2\<^bsub>x x'\<^esub> (g (l1 x))"
       using \<open>x \<^bsub>L1\<^esub>\<lessapprox> x'\<close> \<open>g (l1 x) \<le>\<^bsub>R2 (l1 x) x'\<^esub> _\<close> by blast
     moreover have "... \<le>\<^bsub>L2 x (r1 x')\<^esub> r2\<^bsub>x x'\<^esub> (g x')"
       using mono_r2 \<open>x \<^bsub>L1\<^esub>\<lessapprox> x'\<close> \<open>g (l1 x) \<le>\<^bsub>R2 (l1 x) x'\<^esub> g x'\<close> by blast
     ultimately show "f x \<le>\<^bsub>L2 x (r1 x')\<^esub> r2\<^bsub>x x'\<^esub> (g x')"
       using trans_L2 \<open>x \<^bsub>L1\<^esub>\<lessapprox> x'\<close> by blast
   qed
 qed
 
 lemma left_rel_right_if_Dep_Fun_Rel_left_GaloisI:
   assumes mono_l1: "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and half_galois_prop_right1: "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and L2_unit_le2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and ge_L2_r2_le1: "\<And>x1 x2 y'. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub> y') \<le> (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub> y')"
   and rel_f_g: "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   shows "f \<le>\<^bsub>L\<^esub> r g"
 proof (intro left_relI)
   fix x1 x2 assume "x1 \<le>\<^bsub>L1\<^esub> x2"
   with mono_l1 half_galois_prop_right1 have "x1 \<^bsub>L1\<^esub>\<lessapprox> l1 x2"
     by (intro t1.left_Galois_left_if_left_relI) auto
   with rel_f_g have "f x1 \<^bsub>L2 x1 (l1 x2)\<^esub>\<lessapprox> g (l1 x2)" by blast
   then have "in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) (g (l1 x2))"
     "f x1 \<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub> r2\<^bsub>x1 (l1 x2)\<^esub> (g (l1 x2))" by auto
   with L2_unit_le2 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> have "f x1 \<le>\<^bsub>L2 x1 x2\<^esub> r2\<^bsub>x1 (l1 x2)\<^esub> (g (l1 x2))" by blast
   with ge_L2_r2_le1 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> \<open>in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) (g (l1 x2))\<close>
     have "f x1 \<le>\<^bsub>L2 x1 x2\<^esub> r2\<^bsub>x2 (l1 x2)\<^esub> (g (l1 x2))" by blast
   then show "f x1 \<le>\<^bsub>L2 x1 x2\<^esub> r g x2" by simp
 qed
 
 lemma left_Galois_if_Dep_Fun_Rel_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2 y'. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub> y') \<le> (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub> y')"
   and "in_codom (\<le>\<^bsub>R\<^esub>) g"
   and "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g"
   using assms by (intro left_GaloisI left_rel_right_if_Dep_Fun_Rel_left_GaloisI) auto
 
 lemma left_right_rel_if_Dep_Fun_Rel_left_GaloisI:
   assumes mono_r1: "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and half_galois_prop_left2: "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ((\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (r2\<^bsub>(r1 x1') x2'\<^esub>)"
   and R2_le1: "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and R2_l2_le1: "\<And>x1' x2' y. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) y \<Longrightarrow>
     (\<le>\<^bsub>R2 x1' x2'\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub> y) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>) (l2\<^bsub>x1' (r1 x1')\<^esub> y)"
   and rel_f_g: "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   shows "l f \<le>\<^bsub>R\<^esub> g"
 proof (rule flip.left_relI)
   fix x1' x2' assume "x1' \<le>\<^bsub>R1\<^esub> x2'"
   with mono_r1 have "r1 x1' \<^bsub>L1\<^esub>\<lessapprox> x2'" by blast
   with rel_f_g have "f (r1 x1') \<^bsub>L2 (r1 x1') x2'\<^esub>\<lessapprox> g x2'" by blast
   with half_galois_prop_left2[OF \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close>]
     have "l2\<^bsub>x2' (r1 x1')\<^esub> (f (r1 x1')) \<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub> g x2'" by auto
   with R2_le1 \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close> have "l2\<^bsub>x2' (r1 x1')\<^esub> (f (r1 x1')) \<le>\<^bsub>R2 x1' x2'\<^esub> g x2'"
     by blast
   with R2_l2_le1 \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close> \<open>f (r1 x1') \<^bsub>L2 (r1 x1') x2'\<^esub>\<lessapprox> _\<close>
     have "l2\<^bsub>x1' (r1 x1')\<^esub> (f (r1 x1')) \<le>\<^bsub>R2 x1' x2'\<^esub> g x2'" by blast
   then show "l f x1' \<le>\<^bsub>R2 x1' x2'\<^esub> g x2'" by simp
 qed
 
 lemma left_Galois_if_Dep_Fun_Rel_left_GaloisI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1" and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ((\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (r2\<^bsub>(r1 x1') x2'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1 x2 y'. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub> y') \<le> (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub> y')"
   and "\<And>x1' x2' y. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) y \<Longrightarrow>
     (\<le>\<^bsub>R2 x1' x2'\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub> y) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>) (l2\<^bsub>x1' (r1 x1')\<^esub> y)"
   and "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g"
   using assms by (intro left_Galois_if_Dep_Fun_Rel_left_GaloisI in_codomI[where ?x="l f"])
   (auto intro!: left_right_rel_if_Dep_Fun_Rel_left_GaloisI)
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2 y'. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub> y') \<le> (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub> y')"
   and "\<And>x x' y'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> in_dom (\<le>\<^bsub>R2 (l1 x) x'\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 x (r1 x')\<^esub>) (r2\<^bsub>x (l1 x)\<^esub> y') \<le> (\<ge>\<^bsub>L2 x (r1 x')\<^esub>) (r2\<^bsub>x x'\<^esub> y')"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro iffI)
   (auto intro!: Dep_Fun_Rel_left_Galois_if_left_GaloisI left_Galois_if_Dep_Fun_Rel_left_GaloisI)
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_ge_left_rel2_assmI:
   assumes "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   shows "\<And>x1 x2 y'. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub> y') \<le> (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub> y')"
   using assms by blast
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_ge_left_rel2_assmI':
   assumes "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   shows "\<And>x x' y'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> in_dom (\<le>\<^bsub>R2 (l1 x) x'\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 x (r1 x')\<^esub>) (r2\<^bsub>x (l1 x)\<^esub> y') \<le> (\<ge>\<^bsub>L2 x (r1 x')\<^esub>) (r2\<^bsub>x x'\<^esub> y')"
   using assms by blast
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_mono_assm_in_codom_rightI:
   assumes mono_l1: "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and half_galois_prop_right1: "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_L1: "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and L2_le_unit2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and mono_r2: "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "x1 \<le>\<^bsub>L1\<^esub> x2"
   shows "([in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub>)"
 proof (intro Dep_Fun_Rel_predI)
   from mono_l1 half_galois_prop_right1 refl_L1 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close>
   have "l1 x2 \<le>\<^bsub>R1\<^esub> l1 x2" "x2 \<^bsub>L1\<^esub>\<lessapprox> l1 x2"
     by (blast intro: t1.left_Galois_left_if_left_relI)+
   fix y' assume "in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) y'"
   with Dep_Fun_Rel_relD[OF
     dep_mono_wrt_relD[OF mono_r2 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close>] \<open>l1 x2 \<le>\<^bsub>R1\<^esub> l1 x2\<close>]
     have "r2\<^bsub>x1 (l1 x2)\<^esub> y' \<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub> r2\<^bsub>x2 (l1 x2)\<^esub> y'"
     using \<open>x2 \<^bsub>L1\<^esub>\<lessapprox> l1 x2\<close> by (auto dest: in_field_if_in_codom)
   with L2_le_unit2 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> show "r2\<^bsub>x1 (l1 x2)\<^esub> y' \<le>\<^bsub>L2 x1 x2\<^esub> r2\<^bsub>x2 (l1 x2)\<^esub> y'"
     by blast
 qed
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_mono_assm_in_dom_rightI:
   assumes mono_l1: "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and half_galois_prop_right1: "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_L1: "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and mono_r2: "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "x \<^bsub>L1\<^esub>\<lessapprox> x'"
   shows "([in_dom (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>) (r2\<^bsub>x x'\<^esub>)"
 proof -
   from mono_l1 half_galois_prop_right1 refl_L1 \<open>x \<^bsub>L1\<^esub>\<lessapprox> x'\<close>
     have "x \<le>\<^bsub>L1\<^esub> x" "l1 x \<le>\<^bsub>R1\<^esub> x'" "x \<^bsub>L1\<^esub>\<lessapprox> l1 x"
     by (auto intro!: t1.half_galois_prop_leftD t1.left_Galois_left_if_left_relI)
   with Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_r2 \<open>x \<le>\<^bsub>L1\<^esub> x\<close>] \<open>l1 x \<le>\<^bsub>R1\<^esub> x'\<close>]
     show ?thesis by blast
 qed
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_if_monoI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro left_Galois_iff_Dep_Fun_Rel_left_GaloisI
     left_Galois_iff_Dep_Fun_Rel_left_Galois_ge_left_rel2_assmI
     left_Galois_iff_Dep_Fun_Rel_left_Galois_ge_left_rel2_assmI'
     left_Galois_iff_Dep_Fun_Rel_left_Galois_mono_assm_in_dom_rightI
     left_Galois_iff_Dep_Fun_Rel_left_Galois_mono_assm_in_codom_rightI)
   (auto intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_dom
     in_field_if_in_codom)
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_left_rel2_le_assmI:
   assumes refl_L1: "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and mono_L2: "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 _ \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x2] \<Rrightarrow>\<^sub>m (\<le>)) L2"
   and "x1 \<le>\<^bsub>L1\<^esub> x2"
   shows "(\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
 proof -
   from refl_L1 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> have "x1 \<le>\<^bsub>L1\<^esub> x1" by blast
   with dep_mono_wrt_relD[OF dep_mono_wrt_predD[OF mono_L2] \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close>]
     show "(\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)" by auto
 qed
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_left_rel2_unit1_le_assmI:
   assumes mono_l1: "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and half_galois_prop_right1: "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_L1: "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and antimono_L2:
     "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 x3 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x1 \<le>\<^bsub>L1\<^esub> x2 \<and> x3 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2)] \<Rrightarrow>\<^sub>m (\<ge>)) L2"
   and "x1 \<le>\<^bsub>L1\<^esub> x2"
   shows "(\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
 proof -
   from mono_l1 half_galois_prop_right1 refl_L1 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> have "x2 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2"
     by (blast intro: t1.rel_unit_if_reflexive_on_if_half_galois_prop_right_if_mono_wrt_rel)
   with refl_L1 have "\<eta>\<^sub>1 x2 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2" by blast
   with dep_mono_wrt_relD[OF dep_mono_wrt_predD[OF antimono_L2] \<open>x2 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2\<close>]
     show "(\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)" using \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> by auto
 qed
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_if_monoI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 _ \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x2] \<Rrightarrow>\<^sub>m (\<le>)) L2"
   and "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 x3 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x1 \<le>\<^bsub>L1\<^esub> x2 \<and> x3 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2)] \<Rrightarrow>\<^sub>m (\<ge>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro left_Galois_iff_Dep_Fun_Rel_left_Galois_if_monoI
     left_Galois_iff_Dep_Fun_Rel_left_Galois_left_rel2_unit1_le_assmI
     left_Galois_iff_Dep_Fun_Rel_left_Galois_left_rel2_le_assmI)
   (auto intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_codom
     in_field_if_in_dom)
 
 corollary left_Galois_iff_Dep_Fun_Rel_left_Galois_if_mono_if_galois_connectionI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 _ \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x2] \<Rrightarrow>\<^sub>m (\<le>)) L2"
   and "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 x3 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x1 \<le>\<^bsub>L1\<^esub> x2 \<and> x3 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2)] \<Rrightarrow>\<^sub>m (\<ge>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro left_Galois_iff_Dep_Fun_Rel_left_Galois_if_monoI') auto
 
 interpretation flip_inv : galois "(\<ge>\<^bsub>R1\<^esub>)" "(\<ge>\<^bsub>L1\<^esub>)" r1 l1 .
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_left_rel2_unit1_le_assm_if_galois_equivI:
   assumes galois_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_L1: "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and mono_L2: "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 _ \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x2] \<Rrightarrow>\<^sub>m (\<le>)) L2"
   and "x1 \<le>\<^bsub>L1\<^esub> x2"
   shows "(\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
 proof -
   from refl_L1 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> have "x1 \<le>\<^bsub>L1\<^esub> x1" by blast
   from galois_equiv1 refl_L1 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> have "\<eta>\<^sub>1 x2 \<le>\<^bsub>L1\<^esub> x2" by (intro
     flip.t1.counit_rel_if_reflexive_on_if_half_galois_prop_left_if_mono_wrt_rel)
     blast+
   have "x1 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2" by (rule t1.rel_unit_if_left_rel_if_mono_wrt_relI)
     (insert galois_equiv1 refl_L1 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close>, auto)
   with dep_mono_wrt_relD[OF dep_mono_wrt_predD[OF mono_L2] \<open>\<eta>\<^sub>1 x2 \<le>\<^bsub>L1\<^esub> x2\<close>]
     show "(\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)" by auto
 qed
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_if_galois_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 _ \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x2] \<Rrightarrow>\<^sub>m (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro
     left_Galois_iff_Dep_Fun_Rel_left_Galois_if_monoI
     left_Galois_iff_Dep_Fun_Rel_left_Galois_left_rel2_le_assmI
     left_Galois_iff_Dep_Fun_Rel_left_Galois_left_rel2_unit1_le_assm_if_galois_equivI)
   auto
 
 corollary left_Galois_iff_Dep_Fun_Rel_left_Galois_if_galois_equivalenceI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro left_Galois_iff_Dep_Fun_Rel_left_Galois_if_galois_equivalenceI
     reflexive_on_in_field_mono_assm_left2I)
   auto
 
 corollary left_Galois_iff_Dep_Fun_Rel_left_Galois_if_preorder_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro left_Galois_iff_Dep_Fun_Rel_left_Galois_if_galois_equivalenceI')
   auto
 
 
 corollary left_Galois_iff_Dep_Fun_Rel_left_Galois_if_preorder_equivalenceI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "g \<le>\<^bsub>R\<^esub> g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro left_Galois_iff_Dep_Fun_Rel_left_Galois_if_preorder_equivalenceI
     transitive_left2_if_preorder_equivalenceI)
   (auto 5 0)
 
 
 subparagraph \<open>Simplification of Restricted Function Relator\<close>
 
 lemma Dep_Fun_Rel_left_Galois_restrict_left_right_eq_Dep_Fun_Rel_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1" and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ((\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (r2\<^bsub>(r1 x1') x2'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2' y. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) y \<Longrightarrow>
     (\<le>\<^bsub>R2 x1' x2'\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub> y) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>) (l2\<^bsub>x1' (r1 x1')\<^esub> y)"
   and "\<And>x1 x2 y'. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub> y') \<le> (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub> y')"
   shows "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>
     = ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))"
-  using assms by (intro ext iffI restrict_leftI restrict_rightI
+  using assms by (intro ext iffI bin_rel_restrict_leftI bin_rel_restrict_rightI
     in_domI[where ?y="r _"] left_rel_right_if_Dep_Fun_Rel_left_GaloisI
     in_codomI[where ?x="l _"] left_right_rel_if_Dep_Fun_Rel_left_GaloisI)
   auto
 
 lemma Dep_Fun_Rel_left_Galois_restrict_left_right_eq_Dep_Fun_Rel_left_GaloisI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ((\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (r2\<^bsub>(r1 x1') x2'\<^esub>)"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x2 \<le>\<^bsub>L1\<^esub> x3 \<and> x4 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x3)] \<Rrightarrow> (\<ge>)) L2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | \<epsilon>\<^sub>1 x2' \<le>\<^bsub>R1\<^esub> x1'] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>
     = ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))"
   using assms by (intro
     Dep_Fun_Rel_left_Galois_restrict_left_right_eq_Dep_Fun_Rel_left_GaloisI
     left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_leftI
     reflexive_on_in_field_mono_assm_left2I
     left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_rightI
     mono_wrt_rel_left_in_dom_mono_left_assm
     galois_connection_left_right_if_galois_connection_mono_assms_leftI
     galois_connection_left_right_if_galois_connection_mono_assms_rightI
     left_Galois_iff_Dep_Fun_Rel_left_Galois_ge_left_rel2_assmI)
   auto
 
 text \<open>Simplification of Restricted Function Relator for Nested Transports\<close>
 
 lemma Dep_Fun_Rel_left_Galois_restrict_left_right_restrict_left_right_eq:
   fixes S :: "'a1 \<Rightarrow> 'a2 \<Rightarrow> 'b1 \<Rightarrow> 'b2 \<Rightarrow> bool"
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   shows "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (S x x')\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L2 x (r1 x')\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)\<^esub>)
       \<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub> =
     ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> S x x')\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>" (is "?lhs = ?rhs")
 proof -
   have "?lhs =
     ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (S x x')\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)\<^esub>)
       \<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>"
-    by (subst restrict_left_right_eq_restrict_right_left,
+    by (subst bin_rel_restrict_left_right_eq_restrict_right_left,
       subst restrict_left_Dep_Fun_Rel_rel_restrict_left_eq)
     auto
   also have "... = ?rhs"
-    using assms by (subst restrict_left_right_eq_restrict_right_left,
+    using assms by (subst bin_rel_restrict_left_right_eq_restrict_right_left,
       subst restrict_right_Dep_Fun_Rel_rel_restrict_right_eq)
     (auto elim!: in_codomE t1.left_GaloisE
-      simp only: restrict_left_right_eq_restrict_right_left)
+      simp only: bin_rel_restrict_left_right_eq_restrict_right_left)
   finally show ?thesis .
 qed
 
 end
 
 
 paragraph \<open>Function Relator\<close>
 
 context transport_Fun_Rel
 begin
 
 corollary Fun_Rel_left_Galois_if_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   and "f \<^bsub>L\<^esub>\<lessapprox> g"
   shows "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>)) f g"
   using assms by (intro tdfr.Dep_Fun_Rel_left_Galois_if_left_GaloisI) simp_all
 
 corollary left_Galois_if_Fun_Rel_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "in_codom (\<le>\<^bsub>R\<^esub>) g"
   and "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>)) f g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g"
   using assms by (intro tdfr.left_Galois_if_Dep_Fun_Rel_left_GaloisI) simp_all
 
 lemma left_Galois_if_Fun_Rel_left_GaloisI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1" and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>L2\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   and "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>)) f g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g"
   using assms by (intro tdfr.left_Galois_if_Dep_Fun_Rel_left_GaloisI') simp_all
 
 corollary left_Galois_iff_Fun_Rel_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>)) f g"
   using assms by (intro tdfr.left_Galois_iff_Dep_Fun_Rel_left_GaloisI) simp_all
 
 
 subparagraph \<open>Simplification of Restricted Function Relator\<close>
 
 lemma Fun_Rel_left_Galois_restrict_left_right_eq_Fun_Rel_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1" and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>L2\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   shows "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub> = ((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>))"
   using assms
   by (intro tdfr.Dep_Fun_Rel_left_Galois_restrict_left_right_eq_Dep_Fun_Rel_left_GaloisI)
   simp_all
 
 text \<open>Simplification of Restricted Function Relator for Nested Transports\<close>
 
 lemma Fun_Rel_left_Galois_restrict_left_right_restrict_left_right_eq:
   fixes S :: "'b1 \<Rightarrow> 'b2 \<Rightarrow> bool"
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   shows "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> S\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L2\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R2\<^esub>)\<^esub>)\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub> =
     ((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> S)\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>"
   using assms
   by (intro tdfr.Dep_Fun_Rel_left_Galois_restrict_left_right_restrict_left_right_eq)
   simp_all
 
 end
 
 
 paragraph \<open>Monotone Dependent Function Relator\<close>
 
 context transport_Mono_Dep_Fun_Rel
 begin
 
 lemma Dep_Fun_Rel_left_Galois_if_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x x' y'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> in_dom (\<le>\<^bsub>R2 (l1 x) x'\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 x (r1 x')\<^esub>) (r2\<^bsub>x (l1 x)\<^esub> y') \<le> (\<ge>\<^bsub>L2 x (r1 x')\<^esub>) (r2\<^bsub>x x'\<^esub> y')"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "f \<^bsub>L\<^esub>\<lessapprox> g"
   shows "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms unfolding left_rel_eq_tdfr_left_Refl_Rel right_rel_eq_tdfr_right_Refl_Rel
   by (intro tdfr.Dep_Fun_Rel_left_Galois_if_left_GaloisI tdfr.left_GaloisI)
   (auto elim!: galois_rel.left_GaloisE in_codomE)
 
 lemma left_Galois_if_Dep_Fun_Rel_left_GaloisI:
   assumes "(tdfr.R \<Rrightarrow>\<^sub>m tdfr.L) r"
   and "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2 y'. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub> y') \<le> (\<ge>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub> y')"
   and "in_dom (\<le>\<^bsub>L\<^esub>) f"
   and "in_codom (\<le>\<^bsub>R\<^esub>) g"
   and "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g"
   using assms unfolding left_rel_eq_tdfr_left_Refl_Rel right_rel_eq_tdfr_right_Refl_Rel
   by (intro tdfr.Galois_Refl_RelI tdfr.left_Galois_if_Dep_Fun_Rel_left_GaloisI)
   (auto simp: in_codom_eq_in_dom_if_reflexive_on_in_field)
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_GaloisI:
   assumes "(tdfr.R \<Rrightarrow>\<^sub>m tdfr.L) r"
   and "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "in_dom (\<le>\<^bsub>L\<^esub>) f"
   and "in_codom (\<le>\<^bsub>R\<^esub>) g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro iffI Dep_Fun_Rel_left_Galois_if_left_GaloisI
     tdfr.left_Galois_iff_Dep_Fun_Rel_left_Galois_ge_left_rel2_assmI'
     tdfr.left_Galois_iff_Dep_Fun_Rel_left_Galois_mono_assm_in_dom_rightI)
   (auto intro!: left_Galois_if_Dep_Fun_Rel_left_GaloisI
     tdfr.left_Galois_iff_Dep_Fun_Rel_left_Galois_ge_left_rel2_assmI
     tdfr.left_Galois_iff_Dep_Fun_Rel_left_Galois_mono_assm_in_codom_rightI
     intro: reflexive_on_if_le_pred_if_reflexive_on
       in_field_if_in_dom in_field_if_in_codom)
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_if_mono_if_galois_connectionI:
   assumes galois_conn1: "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_L1: "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and L2_le_unit2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and mono_r2: "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and trans_L2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "in_dom (\<le>\<^bsub>L\<^esub>) f"
   and "in_codom (\<le>\<^bsub>R\<^esub>) g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g" (is "?lhs \<longleftrightarrow> ?rhs")
 proof -
   have "(\<le>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub> y') \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>) (r2\<^bsub>x1 (l1 x1)\<^esub> y')"
     if hyps: "x1 \<le>\<^bsub>L1\<^esub> x2" "in_dom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) y'" for x1 x2 y'
   proof -
     have "([in_dom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x1)\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
     proof (intro Dep_Fun_Rel_predI)
       from galois_conn1 refl_L1 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close>
         have "x1 \<le>\<^bsub>L1\<^esub> x1" "l1 x1 \<le>\<^bsub>R1\<^esub> l1 x2" "x1 \<^bsub>L1\<^esub>\<lessapprox> l1 x1"
         by (blast intro: t1.left_Galois_left_if_left_relI)+
       fix y' assume "in_dom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) y'"
       with Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_r2 \<open>x1 \<le>\<^bsub>L1\<^esub> x1\<close>]
         \<open>l1 x1 \<le>\<^bsub>R1\<^esub> l1 x2\<close>]
         have "r2\<^bsub>x1 (l1 x1)\<^esub> y' \<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub> r2\<^bsub>x1 (l1 x2)\<^esub> y'"
         using \<open>x1 \<^bsub>L1\<^esub>\<lessapprox> l1 x1\<close> by (auto dest: in_field_if_in_dom)
       with L2_le_unit2 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> show "r2\<^bsub>x1 (l1 x1)\<^esub> y' \<le>\<^bsub>L2 x1 x2\<^esub> r2\<^bsub>x1 (l1 x2)\<^esub> y'"
         by blast
     qed
     with hyps show ?thesis using trans_L2 by blast
   qed
   then show ?thesis using assms
     using assms by (intro left_Galois_iff_Dep_Fun_Rel_left_GaloisI
       tdfr.mono_wrt_rel_rightI
       tdfr.mono_wrt_rel_right2_if_mono_wrt_rel_right2_if_left_GaloisI
       tdfr.left_Galois_iff_Dep_Fun_Rel_left_Galois_ge_left_rel2_assmI
       tdfr.left_Galois_iff_Dep_Fun_Rel_left_Galois_mono_assm_in_codom_rightI)
     (auto intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_codom)
 qed
 
 corollary left_Galois_iff_Dep_Fun_Rel_left_Galois_if_mono_if_galois_connectionI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 _ \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x2] \<Rrightarrow>\<^sub>m (\<le>)) L2"
   and "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 x3 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x1 \<le>\<^bsub>L1\<^esub> x2 \<and> x3 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2)] \<Rrightarrow>\<^sub>m (\<ge>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "in_dom (\<le>\<^bsub>L\<^esub>) f"
   and "in_codom (\<le>\<^bsub>R\<^esub>) g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g" (is "?lhs \<longleftrightarrow> ?rhs")
   using assms by (intro
     left_Galois_iff_Dep_Fun_Rel_left_Galois_if_mono_if_galois_connectionI
     tdfr.left_Galois_iff_Dep_Fun_Rel_left_Galois_left_rel2_unit1_le_assmI
     tdfr.left_Galois_iff_Dep_Fun_Rel_left_Galois_left_rel2_le_assmI)
   auto
 
 corollary left_Galois_eq_Dep_Fun_Rel_left_Galois_restrict_if_mono_if_galois_connectionI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 _ \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x2] \<Rrightarrow>\<^sub>m (\<le>)) L2"
   and "([x1 \<Colon> \<top>] \<Rrightarrow>\<^sub>m [x2 x3 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x1 \<le>\<^bsub>L1\<^esub> x2 \<and> x3 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2)] \<Rrightarrow>\<^sub>m (\<ge>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>"
-  using assms by (intro ext iffI restrict_leftI restrict_rightI
+  using assms by (intro ext iffI bin_rel_restrict_leftI bin_rel_restrict_rightI
     iffD1[OF left_Galois_iff_Dep_Fun_Rel_left_Galois_if_mono_if_galois_connectionI'])
   (auto intro!:
     iffD2[OF left_Galois_iff_Dep_Fun_Rel_left_Galois_if_mono_if_galois_connectionI'])
 
 lemma left_Galois_iff_Dep_Fun_Rel_left_Galois_if_galois_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "in_dom (\<le>\<^bsub>L\<^esub>) f"
   and "in_codom (\<le>\<^bsub>R\<^esub>) g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro left_Galois_iff_Dep_Fun_Rel_left_Galois_if_mono_if_galois_connectionI
     tdfr.left_Galois_iff_Dep_Fun_Rel_left_Galois_left_rel2_le_assmI
     tdfr.reflexive_on_in_field_mono_assm_left2I
     tdfr.left_Galois_iff_Dep_Fun_Rel_left_Galois_left_rel2_unit1_le_assm_if_galois_equivI)
   auto
 
 theorem left_Galois_eq_Dep_Fun_Rel_left_Galois_restrict_if_galois_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>"
-  using assms by (intro ext iffI restrict_leftI restrict_rightI
+  using assms by (intro ext iffI bin_rel_restrict_leftI bin_rel_restrict_rightI
     iffD1[OF left_Galois_iff_Dep_Fun_Rel_left_Galois_if_galois_equivalenceI])
   (auto intro!: iffD2[OF left_Galois_iff_Dep_Fun_Rel_left_Galois_if_galois_equivalenceI])
 
 corollary left_Galois_iff_Dep_Fun_Rel_left_Galois_if_preorder_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "in_dom (\<le>\<^bsub>L\<^esub>) f"
   and "in_codom (\<le>\<^bsub>R\<^esub>) g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro left_Galois_iff_Dep_Fun_Rel_left_Galois_if_galois_equivalenceI)
   auto
 
 corollary left_Galois_eq_Dep_Fun_Rel_left_Galois_restrict_if_preorder_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>"
-  using assms by (intro ext iffI restrict_leftI restrict_rightI
+  using assms by (intro ext iffI bin_rel_restrict_leftI bin_rel_restrict_rightI
     iffD1[OF left_Galois_iff_Dep_Fun_Rel_left_Galois_if_preorder_equivalenceI])
   (auto intro!: iffD2[OF left_Galois_iff_Dep_Fun_Rel_left_Galois_if_preorder_equivalenceI])
 
 corollary left_Galois_iff_Dep_Fun_Rel_left_Galois_if_preorder_equivalenceI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "in_dom (\<le>\<^bsub>L\<^esub>) f"
   and "in_codom (\<le>\<^bsub>R\<^esub>) g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>)) f g"
   using assms by (intro left_Galois_iff_Dep_Fun_Rel_left_Galois_if_preorder_equivalenceI
     tdfr.transitive_left2_if_preorder_equivalenceI)
   (auto 5 0)
 
 corollary left_Galois_eq_Dep_Fun_Rel_left_Galois_restrict_if_preorder_equivalenceI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>"
-  using assms by (intro ext iffI restrict_leftI restrict_rightI
+  using assms by (intro ext iffI bin_rel_restrict_leftI bin_rel_restrict_rightI
     iffD1[OF left_Galois_iff_Dep_Fun_Rel_left_Galois_if_preorder_equivalenceI'])
   (auto intro!: iffD2[OF left_Galois_iff_Dep_Fun_Rel_left_Galois_if_preorder_equivalenceI'])
 
 
 subparagraph \<open>Simplification of Restricted Function Relator\<close>
 
 lemma Dep_Fun_Rel_left_Galois_restrict_left_right_eq_Dep_Fun_Rel_left_Galois_if_reflexive_onI:
   assumes "reflexive_on (in_field tdfr.L) tdfr.L"
   and "reflexive_on (in_field tdfr.R) tdfr.R"
   and "((\<le>\<^bsub>L1\<^esub>) \<stileturn> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ((\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (r2\<^bsub>(r1 x1') x2'\<^esub>)"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x2 \<le>\<^bsub>L1\<^esub> x3 \<and> x4 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x3)] \<Rrightarrow> (\<ge>)) L2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | \<epsilon>\<^sub>1 x2' \<le>\<^bsub>R1\<^esub> x1'] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>
     = ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))"
   using assms by (auto simp only: left_rel_eq_tdfr_left_rel_if_reflexive_on
       right_rel_eq_tdfr_right_rel_if_reflexive_on
     intro!: tdfr.Dep_Fun_Rel_left_Galois_restrict_left_right_eq_Dep_Fun_Rel_left_GaloisI')
 
 interpretation flip : transport_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2
   rewrites "flip.t1.unit \<equiv> \<epsilon>\<^sub>1" by (simp only: t1.flip_unit_eq_counit)
 
 lemma Dep_Fun_Rel_left_Galois_restrict_left_right_eq_Dep_Fun_Rel_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ((\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (r2\<^bsub>(r1 x1') x2'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1' x2' \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and PERS: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> partial_equivalence_rel (\<le>\<^bsub>L2 x1 x2\<^esub>)"
     "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> partial_equivalence_rel (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>
     = ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (\<^bsub>L2 x x'\<^esub>\<lessapprox>))"
   using assms by (intro
     Dep_Fun_Rel_left_Galois_restrict_left_right_eq_Dep_Fun_Rel_left_Galois_if_reflexive_onI
     tdfr.reflexive_on_in_field_left_if_equivalencesI
     flip.reflexive_on_in_field_left_if_equivalencesI
     tdfr.galois_equivalence_if_mono_if_galois_equivalence_mono_assms_leftI
     flip.galois_equivalence_if_mono_if_galois_equivalence_mono_assms_leftI)
   (auto dest!: PERS)
 
 
 text \<open>Simplification of Restricted Function Relator for Nested Transports\<close>
 
 lemma Dep_Fun_Rel_left_Galois_restrict_left_right_restrict_left_right_eq:
   fixes S :: "'a1 \<Rightarrow> 'a2 \<Rightarrow> 'b1 \<Rightarrow> 'b2 \<Rightarrow> bool"
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   shows "([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> (S x x')\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L2 x (r1 x')\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)\<^esub>)
       \<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub> =
     ([x x' \<Colon> (\<^bsub>L1\<^esub>\<lessapprox>)] \<Rrightarrow> S x x')\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>"
     (is "?lhs\<restriction>\<^bsub>?DL\<^esub>\<upharpoonleft>\<^bsub>?CR\<^esub> = ?rhs\<restriction>\<^bsub>?DL\<^esub>\<upharpoonleft>\<^bsub>?CR\<^esub>")
 proof (intro ext)
   fix f g
   have "?lhs\<restriction>\<^bsub>?DL\<^esub>\<upharpoonleft>\<^bsub>?CR\<^esub> f g \<longleftrightarrow> ?lhs f g \<and> ?DL f \<and> ?CR g" by blast
   also have "... \<longleftrightarrow> ?lhs\<restriction>\<^bsub>in_dom tdfr.L\<^esub>\<upharpoonleft>\<^bsub>in_codom tdfr.R\<^esub> f g \<and> ?DL f \<and> ?CR g"
     unfolding left_rel_eq_tdfr_left_Refl_Rel right_rel_eq_tdfr_right_Refl_Rel
     by blast
   also with assms have "... \<longleftrightarrow> ?rhs\<restriction>\<^bsub>in_dom tdfr.L\<^esub>\<upharpoonleft>\<^bsub>in_codom tdfr.R\<^esub> f g \<and> ?DL f \<and> ?CR g"
     by (simp only:
       tdfr.Dep_Fun_Rel_left_Galois_restrict_left_right_restrict_left_right_eq)
   also have "... \<longleftrightarrow> ?rhs\<restriction>\<^bsub>?DL\<^esub>\<upharpoonleft>\<^bsub>?CR\<^esub> f g"
     unfolding left_rel_eq_tdfr_left_Refl_Rel right_rel_eq_tdfr_right_Refl_Rel
     by blast
   finally show "?lhs\<restriction>\<^bsub>?DL\<^esub>\<upharpoonleft>\<^bsub>?CR\<^esub> f g \<longleftrightarrow> ?rhs\<restriction>\<^bsub>?DL\<^esub>\<upharpoonleft>\<^bsub>?CR\<^esub> f g" .
 qed
 
 end
 
 
 paragraph \<open>Monotone Function Relator\<close>
 
 context transport_Mono_Fun_Rel
 begin
 
 corollary Fun_Rel_left_Galois_if_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) (r2)"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "f \<^bsub>L\<^esub>\<lessapprox> g"
   shows "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>)) f g"
   using assms by (intro tpdfr.Dep_Fun_Rel_left_Galois_if_left_GaloisI) simp_all
 
 interpretation flip : transport_Mono_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2 .
 
 lemma left_Galois_if_Fun_Rel_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "in_dom (\<le>\<^bsub>L\<^esub>) f"
   and "in_codom (\<le>\<^bsub>R\<^esub>) g"
   and "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>)) f g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g"
   using assms
   by (intro tpdfr.left_Galois_if_Dep_Fun_Rel_left_GaloisI flip.tfr.mono_wrt_rel_leftI)
   simp_all
 
 corollary left_Galois_iff_Fun_Rel_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) (r2)"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "in_dom (\<le>\<^bsub>L\<^esub>) f"
   and "in_codom (\<le>\<^bsub>R\<^esub>) g"
   shows "f \<^bsub>L\<^esub>\<lessapprox> g \<longleftrightarrow> ((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>)) f g"
   using assms by (intro iffI Fun_Rel_left_Galois_if_left_GaloisI)
   (auto intro!: left_Galois_if_Fun_Rel_left_GaloisI)
 
 theorem left_Galois_eq_Fun_Rel_left_Galois_restrictI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   shows "(\<^bsub>L\<^esub>\<lessapprox>) = ((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>"
-  using assms by (intro ext iffI restrict_leftI restrict_rightI
+  using assms by (intro ext iffI bin_rel_restrict_leftI bin_rel_restrict_rightI
     iffD1[OF left_Galois_iff_Fun_Rel_left_GaloisI])
   (auto elim!: tpdfr.left_GaloisE intro!: iffD2[OF left_Galois_iff_Fun_Rel_left_GaloisI])
 
 
 subparagraph \<open>Simplification of Restricted Function Relator\<close>
 
 lemma Fun_Rel_left_Galois_restrict_left_right_eq_Fun_Rel_left_Galois_if_reflexive_onI:
   assumes "reflexive_on (in_field tfr.tdfr.L) tfr.tdfr.L"
   and "reflexive_on (in_field tfr.tdfr.R) tfr.tdfr.R"
   and "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1" and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>L2\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   shows "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub> = ((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>))"
   using assms by (auto simp only: tpdfr.left_rel_eq_tdfr_left_rel_if_reflexive_on
       tpdfr.right_rel_eq_tdfr_right_rel_if_reflexive_on
     intro!: tfr.Fun_Rel_left_Galois_restrict_left_right_eq_Fun_Rel_left_GaloisI)
 
 lemma Fun_Rel_left_Galois_restrict_left_right_eq_Fun_Rel_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1" and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   and "partial_equivalence_rel (\<le>\<^bsub>L2\<^esub>)"
   and "partial_equivalence_rel (\<le>\<^bsub>R2\<^esub>)"
   shows "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>))\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub> = ((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> (\<^bsub>L2\<^esub>\<lessapprox>))"
   using assms by (intro
     Fun_Rel_left_Galois_restrict_left_right_eq_Fun_Rel_left_Galois_if_reflexive_onI
     tfr.reflexive_on_in_field_leftI
     flip.tfr.reflexive_on_in_field_leftI)
   auto
 
 
 text \<open>Simplification of Restricted Function Relator for Nested Transports\<close>
 
 lemma Fun_Rel_left_Galois_restrict_left_right_restrict_left_right_eq:
   fixes S :: "'b1 \<Rightarrow> 'b2 \<Rightarrow> bool"
   assumes "((\<le>\<^bsub>L1\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   shows "((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> S\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L2\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R2\<^esub>)\<^esub>)\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub> =
     ((\<^bsub>L1\<^esub>\<lessapprox>) \<Rrightarrow> S)\<restriction>\<^bsub>in_dom (\<le>\<^bsub>L\<^esub>)\<^esub>\<upharpoonleft>\<^bsub>in_codom (\<le>\<^bsub>R\<^esub>)\<^esub>"
   using assms
   by (intro tpdfr.Dep_Fun_Rel_left_Galois_restrict_left_right_restrict_left_right_eq)
   simp_all
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Functions/Transport_Functions_Order_Base.thy b/thys/Transport/Transport/Functions/Transport_Functions_Order_Base.thy
--- a/thys/Transport/Transport/Functions/Transport_Functions_Order_Base.thy
+++ b/thys/Transport/Transport/Functions/Transport_Functions_Order_Base.thy
@@ -1,428 +1,428 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Basic Order Properties\<close>
 theory Transport_Functions_Order_Base
   imports
     Transport_Functions_Base
 begin
 
 paragraph \<open>Dependent Function Relator\<close>
 
 context hom_Dep_Fun_Rel_orders
 begin
 
 lemma reflexive_on_in_domI:
   assumes refl_L: "reflexive_on (in_codom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   and R_le_R_if_L: "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>R x2 x2\<^esub>) \<le> (\<le>\<^bsub>R x1 x2\<^esub>)"
   and pequiv_R: "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> partial_equivalence_rel (\<le>\<^bsub>R x1 x2\<^esub>)"
   shows "reflexive_on (in_dom DFR) DFR"
 proof (intro reflexive_onI Dep_Fun_Rel_relI)
   fix f x1 x2
   assume "in_dom DFR f"
   then obtain g where "DFR f g" by auto
   moreover assume "x1 \<le>\<^bsub>L\<^esub> x2"
   moreover with refl_L have "x2 \<le>\<^bsub>L\<^esub> x2" by blast
   ultimately have "f x1 \<le>\<^bsub>R x1 x2\<^esub> g x2" "f x2 \<le>\<^bsub>R x1 x2\<^esub> g x2"
     using R_le_R_if_L by auto
   moreover with pequiv_R \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close>  have "g x2 \<le>\<^bsub>R x1 x2\<^esub> f x2"
     by (blast dest: symmetricD)
   ultimately show "f x1 \<le>\<^bsub>R x1 x2\<^esub> f x2" using pequiv_R \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> by blast
 qed
 
 lemma reflexive_on_in_codomI:
   assumes refl_L: "reflexive_on (in_dom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   and R_le_R_if_L: "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>R x1 x1\<^esub>) \<le> (\<le>\<^bsub>R x1 x2\<^esub>)"
   and pequiv_R: "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> partial_equivalence_rel (\<le>\<^bsub>R x1 x2\<^esub>)"
   shows "reflexive_on (in_codom DFR) DFR"
 proof (intro reflexive_onI Dep_Fun_Rel_relI)
   fix f x1 x2
   assume "in_codom DFR f"
   then obtain g where "DFR g f" by auto
   moreover assume "x1 \<le>\<^bsub>L\<^esub> x2"
   moreover with refl_L have "x1 \<le>\<^bsub>L\<^esub> x1" by blast
   ultimately have "g x1 \<le>\<^bsub>R x1 x2\<^esub> f x2" "g x1 \<le>\<^bsub>R x1 x2\<^esub> f x1"
     using R_le_R_if_L by auto
   moreover with pequiv_R \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close>  have "f x1 \<le>\<^bsub>R x1 x2\<^esub> g x1"
     by (blast dest: symmetricD)
   ultimately show "f x1 \<le>\<^bsub>R x1 x2\<^esub> f x2" using pequiv_R \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> by blast
 qed
 
 corollary reflexive_on_in_fieldI:
   assumes "reflexive_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>R x2 x2\<^esub>) \<le> (\<le>\<^bsub>R x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>R x1 x1\<^esub>) \<le> (\<le>\<^bsub>R x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> partial_equivalence_rel (\<le>\<^bsub>R x1 x2\<^esub>)"
   shows "reflexive_on (in_field DFR) DFR"
 proof -
   from assms have "reflexive_on (in_dom DFR) DFR"
     by (intro reflexive_on_in_domI)
     (auto intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_codom)
   moreover from assms have "reflexive_on (in_codom DFR) DFR"
     by (intro reflexive_on_in_codomI)
     (auto intro: reflexive_on_if_le_pred_if_reflexive_on in_field_if_in_dom)
   ultimately show ?thesis by (auto iff: in_field_iff_in_dom_or_in_codom)
 qed
 
 lemma transitiveI:
   assumes refl_L: "reflexive_on (in_dom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   and R_le_R_if_L: "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>R x1 x1\<^esub>) \<le> (\<le>\<^bsub>R x1 x2\<^esub>)"
   and trans: "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>R x1 x2\<^esub>)"
   shows "transitive DFR"
 proof (intro transitiveI Dep_Fun_Rel_relI)
   fix f1 f2 f3 x1 x2 assume "x1 \<le>\<^bsub>L\<^esub> x2"
   with refl_L have "x1 \<le>\<^bsub>L\<^esub> x1" by blast
   moreover assume "DFR f1 f2"
   ultimately have "f1 x1 \<le>\<^bsub>R x1 x1\<^esub> f2 x1" by blast
   with R_le_R_if_L have "f1 x1 \<le>\<^bsub>R x1 x2\<^esub> f2 x1" using \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> by blast
   assume "DFR f2 f3"
   with \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> have "f2 x1 \<le>\<^bsub>R x1 x2\<^esub> f3 x2" by blast
   with \<open>f1 x1 \<le>\<^bsub>R x1 x2\<^esub> f2 x1\<close> show "f1 x1 \<le>\<^bsub>R x1 x2\<^esub>  f3 x2"
     using trans \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> by blast
 qed
 
 lemma transitiveI':
   assumes refl_L: "reflexive_on (in_codom (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   and R_le_R_if_L: "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>R x2 x2\<^esub>) \<le> (\<le>\<^bsub>R x1 x2\<^esub>)"
   and trans: "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>R x1 x2\<^esub>)"
   shows "transitive DFR"
 proof (intro Binary_Relations_Transitive.transitiveI Dep_Fun_Rel_relI)
   fix f1 f2 f3 x1 x2 assume "DFR f1 f2" "x1 \<le>\<^bsub>L\<^esub> x2"
   then have "f1 x1 \<le>\<^bsub>R x1 x2\<^esub> f2 x2" by blast
   from \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> refl_L have "x2 \<le>\<^bsub>L\<^esub> x2" by blast
   moreover assume "DFR f2 f3"
   ultimately have "f2 x2 \<le>\<^bsub>R x2 x2\<^esub> f3 x2" by blast
   with R_le_R_if_L have "f2 x2 \<le>\<^bsub>R x1 x2\<^esub> f3 x2" using \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> by blast
   with \<open>f1 x1 \<le>\<^bsub>R x1 x2\<^esub> f2 x2\<close> show "f1 x1 \<le>\<^bsub>R x1 x2\<^esub> f3 x2"
     using trans \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> by blast
 qed
 
 lemma preorder_on_in_fieldI:
   assumes "reflexive_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>R x2 x2\<^esub>) \<le> (\<le>\<^bsub>R x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>R x1 x1\<^esub>) \<le> (\<le>\<^bsub>R x1 x2\<^esub>)"
   and pequiv_R: "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> partial_equivalence_rel (\<le>\<^bsub>R x1 x2\<^esub>)"
   shows "preorder_on (in_field DFR) DFR"
   using assms by (intro preorder_onI reflexive_on_in_fieldI)
   (auto intro!: transitiveI dest: pequiv_R elim!: partial_equivalence_relE)
 
 lemma symmetricI:
   assumes sym_L: "symmetric (\<le>\<^bsub>L\<^esub>)"
   and R_le_R_if_L: "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>R x1 x2\<^esub>) \<le> (\<le>\<^bsub>R x2 x1\<^esub>)"
   and sym_R: "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> symmetric (\<le>\<^bsub>R x1 x2\<^esub>)"
   shows "symmetric DFR"
 proof (intro symmetricI Dep_Fun_Rel_relI)
   fix f g x y assume "x \<le>\<^bsub>L\<^esub> y"
   with sym_L have "y \<le>\<^bsub>L\<^esub> x" by (rule symmetricD)
   moreover assume "DFR f g"
   ultimately have "f y \<le>\<^bsub>R y x\<^esub> g x" by blast
   with sym_R \<open>y \<le>\<^bsub>L\<^esub> x\<close> have "g x \<le>\<^bsub>R y x\<^esub> f y" by (blast dest: symmetricD)
   with R_le_R_if_L \<open>y \<le>\<^bsub>L\<^esub> x\<close> show "g x \<le>\<^bsub>R x y\<^esub> f y" by blast
 qed
 
 corollary partial_equivalence_relI:
   assumes "reflexive_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   and sym_L: "symmetric (\<le>\<^bsub>L\<^esub>)"
   and mono_R: "([x1 x2 \<Colon> (\<le>\<^bsub>L\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L\<^esub>) | x1 \<le>\<^bsub>L\<^esub> x3] \<Rrightarrow> (\<le>)) R"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L\<^esub> x2 \<Longrightarrow> partial_equivalence_rel (\<le>\<^bsub>R x1 x2\<^esub>)"
   shows "partial_equivalence_rel DFR"
 proof -
   have "(\<le>\<^bsub>R x1 x2\<^esub>) \<le> (\<le>\<^bsub>R x2 x1\<^esub>)" if "x1 \<le>\<^bsub>L\<^esub> x2" for x1 x2
   proof -
     from sym_L \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> have "x2 \<le>\<^bsub>L\<^esub> x1" by (rule symmetricD)
     with mono_R \<open>x1 \<le>\<^bsub>L\<^esub> x2\<close> show ?thesis by blast
   qed
   with assms show ?thesis
     by (intro partial_equivalence_relI transitiveI symmetricI)
-    (auto elim: partial_equivalence_relE[OF assms(4)])
+    (blast elim: partial_equivalence_relE[OF assms(4)])+
 qed
 
 end
 
 context transport_Dep_Fun_Rel
 begin
 
 lemmas reflexive_on_in_field_leftI = dfro1.reflexive_on_in_fieldI
   [folded left_rel_eq_Dep_Fun_Rel]
 lemmas transitive_leftI = dfro1.transitiveI[folded left_rel_eq_Dep_Fun_Rel]
 lemmas transitive_leftI' = dfro1.transitiveI'[folded left_rel_eq_Dep_Fun_Rel]
 lemmas preorder_on_in_field_leftI = dfro1.preorder_on_in_fieldI
   [folded left_rel_eq_Dep_Fun_Rel]
 lemmas symmetric_leftI = dfro1.symmetricI[folded left_rel_eq_Dep_Fun_Rel]
 lemmas partial_equivalence_rel_leftI = dfro1.partial_equivalence_relI
   [folded left_rel_eq_Dep_Fun_Rel]
 
 
 subparagraph \<open>Introduction Rules for Assumptions\<close>
 
 lemma transitive_left2_if_transitive_left2_if_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and L2_eq: "(\<le>\<^bsub>L2 x1 x2\<^esub>) = (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> transitive (\<le>\<^bsub>L2 x (r1 x')\<^esub>)"
   and "x1 \<le>\<^bsub>L1\<^esub> x2"
   shows "transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   by (subst L2_eq) (auto intro!: assms t1.left_Galois_left_if_left_relI)
 
 lemma symmetric_left2_if_symmetric_left2_if_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and L2_eq: "(\<le>\<^bsub>L2 x1 x2\<^esub>) = (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> symmetric (\<le>\<^bsub>L2 x (r1 x')\<^esub>)"
   and "x1 \<le>\<^bsub>L1\<^esub> x2"
   shows "symmetric (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   by (subst L2_eq) (auto intro!: assms t1.left_Galois_left_if_left_relI)
 
 lemma partial_equivalence_rel_left2_if_partial_equivalence_rel_left2_if_left_GaloisI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and L2_eq: "(\<le>\<^bsub>L2 x1 x2\<^esub>) = (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> partial_equivalence_rel (\<le>\<^bsub>L2 x (r1 x')\<^esub>)"
   and "x1 \<le>\<^bsub>L1\<^esub> x2"
   shows "partial_equivalence_rel (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   by (subst L2_eq) (auto intro!: assms t1.left_Galois_left_if_left_relI)
 
 context
   assumes galois_prop: "((\<le>\<^bsub>L1\<^esub>) \<unlhd> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
 begin
 
 interpretation flip_inv :
   transport_Dep_Fun_Rel "(\<ge>\<^bsub>R1\<^esub>)" "(\<ge>\<^bsub>L1\<^esub>)" r1 l1 "flip2 R2" "flip2 L2" r2 l2
   rewrites "flip_inv.t1.unit \<equiv> \<epsilon>\<^sub>1"
   and "\<And>R x y. (flip2 R x y) \<equiv> (R y x)\<inverse>"
   and "\<And>R S. R\<inverse> = S\<inverse> \<equiv> R = S"
   and "\<And>R S. (R\<inverse> \<Rrightarrow>\<^sub>m S\<inverse>) \<equiv> (R \<Rrightarrow>\<^sub>m S)"
   and "\<And>x x'. x' \<^bsub>R1\<^esub>\<greaterapprox> x \<equiv> x \<^bsub>L1\<^esub>\<lessapprox> x'"
   and "((\<ge>\<^bsub>R1\<^esub>) \<unlhd>\<^sub>h (\<ge>\<^bsub>L1\<^esub>)) r1 l1 \<equiv> True"
   and "\<And>R. transitive R\<inverse> \<equiv> transitive R"
   and "\<And>R. symmetric R\<inverse> \<equiv> symmetric R"
   and "\<And>R. partial_equivalence_rel R\<inverse> \<equiv> partial_equivalence_rel R"
   and "\<And>P. (True \<Longrightarrow> P) \<equiv> Trueprop P"
   and "\<And>P Q. (True \<Longrightarrow> PROP P \<Longrightarrow> PROP Q) \<equiv> (PROP P \<Longrightarrow> True \<Longrightarrow> PROP Q)"
   using galois_prop
   by (auto intro!: Eq_TrueI simp add: t1.flip_unit_eq_counit
     galois_prop.half_galois_prop_right_rel_inv_iff_half_galois_prop_left
     simp del: rel_inv_iff_rel)
 
 lemma transitive_right2_if_transitive_right2_if_left_GaloisI:
   assumes "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "(\<le>\<^bsub>R2 x1 x2\<^esub>) = (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1) x2\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> transitive (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)"
   and "x1 \<le>\<^bsub>R1\<^esub> x2"
   shows "transitive (\<le>\<^bsub>R2 x1 x2\<^esub>)"
   using galois_prop assms
   by (intro flip_inv.transitive_left2_if_transitive_left2_if_left_GaloisI
     [simplified rel_inv_iff_rel, of x1])
   auto
 
 lemma symmetric_right2_if_symmetric_right2_if_left_GaloisI:
   assumes "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "(\<le>\<^bsub>R2 x1 x2\<^esub>) = (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1) x2\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> symmetric (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)"
   and "x1 \<le>\<^bsub>R1\<^esub> x2"
   shows "symmetric (\<le>\<^bsub>R2 x1 x2\<^esub>)"
   using galois_prop assms
   by (intro flip_inv.symmetric_left2_if_symmetric_left2_if_left_GaloisI
     [simplified rel_inv_iff_rel, of x1])
   auto
 
 lemma partial_equivalence_rel_right2_if_partial_equivalence_rel_right2_if_left_GaloisI:
   assumes "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "(\<le>\<^bsub>R2 x1 x2\<^esub>) = (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1) x2\<^esub>)"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> partial_equivalence_rel (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)"
   and "x1 \<le>\<^bsub>R1\<^esub> x2"
   shows "partial_equivalence_rel (\<le>\<^bsub>R2 x1 x2\<^esub>)"
   using galois_prop assms
   by (intro flip_inv.partial_equivalence_rel_left2_if_partial_equivalence_rel_left2_if_left_GaloisI
     [simplified rel_inv_iff_rel, of x1])
   auto
 
 end
 
 lemma transitive_left2_if_preorder_equivalenceI:
   assumes pre_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "x1 \<le>\<^bsub>L1\<^esub> x2"
   shows "transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
 proof -
   from \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> pre_equiv1 have "x2 \<equiv>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2"
     by (blast elim: t1.preorder_equivalence_order_equivalenceE
       intro: bi_related_if_rel_equivalence_on)
   with assms have "(\<le>\<^bsub>L2 x1 x2\<^esub>) = (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>)"
     by (intro left2_eq_if_bi_related_if_monoI) blast+
   with assms show ?thesis
     by (intro transitive_left2_if_transitive_left2_if_left_GaloisI[of x1]) blast+
 qed
 
 lemma symmetric_left2_if_partial_equivalence_rel_equivalenceI:
   assumes PER_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "x1 \<le>\<^bsub>L1\<^esub> x2"
   shows "symmetric (\<le>\<^bsub>L2 x1 x2\<^esub>)"
 proof -
   from \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> PER_equiv1 have "x2 \<equiv>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2"
     by (blast elim: t1.preorder_equivalence_order_equivalenceE
       intro: bi_related_if_rel_equivalence_on)
   with assms have "(\<le>\<^bsub>L2 x1 x2\<^esub>) = (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>)"
     by (intro left2_eq_if_bi_related_if_monoI) blast+
   with assms show ?thesis
     by (intro symmetric_left2_if_symmetric_left2_if_left_GaloisI[of x1]) blast+
 qed
 
 lemma partial_equivalence_rel_left2_if_partial_equivalence_rel_equivalenceI:
   assumes PER_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "x1 \<le>\<^bsub>L1\<^esub> x2"
   shows "partial_equivalence_rel (\<le>\<^bsub>L2 x1 x2\<^esub>)"
 proof -
   from \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> PER_equiv1 have "x2 \<equiv>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2"
     by (blast elim: t1.preorder_equivalence_order_equivalenceE
       intro: bi_related_if_rel_equivalence_on)
   with assms have "(\<le>\<^bsub>L2 x1 x2\<^esub>) = (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>)"
     by (intro left2_eq_if_bi_related_if_monoI) blast+
   with assms show ?thesis
     by (intro partial_equivalence_rel_left2_if_partial_equivalence_rel_left2_if_left_GaloisI[of x1])
     blast+
 qed
 
 interpretation flip : transport_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2
   rewrites "flip.t1.counit \<equiv> \<eta>\<^sub>1" and "flip.t1.unit \<equiv> \<epsilon>\<^sub>1"
   by (simp_all only: t1.flip_counit_eq_unit t1.flip_unit_eq_counit)
 
 lemma transitive_right2_if_preorder_equivalenceI:
   assumes pre_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "([x1' x2' \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "x1' \<le>\<^bsub>R1\<^esub> x2'"
   shows "transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
 proof -
   from \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close> pre_equiv1 have "x1' \<equiv>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x1'"
     by (blast elim: t1.preorder_equivalence_order_equivalenceE
       intro: bi_related_if_rel_equivalence_on)
   with assms have "(\<le>\<^bsub>R2 x1' x2'\<^esub>) = (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>)"
     by (intro flip.left2_eq_if_bi_related_if_monoI) blast+
   with assms show ?thesis
     by (intro transitive_right2_if_transitive_right2_if_left_GaloisI[of x1']) blast+
 qed
 
 lemma symmetric_right2_if_partial_equivalence_rel_equivalenceI:
   assumes PER_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "([x1' x2' \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "x1' \<le>\<^bsub>R1\<^esub> x2'"
   shows "symmetric (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
 proof -
   from \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close> PER_equiv1 have "x1' \<equiv>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x1'"
     by (blast elim: t1.preorder_equivalence_order_equivalenceE
       intro: bi_related_if_rel_equivalence_on)
   with assms have "(\<le>\<^bsub>R2 x1' x2'\<^esub>) = (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>)"
     by (intro flip.left2_eq_if_bi_related_if_monoI) blast+
   with assms show ?thesis
     by (intro symmetric_right2_if_symmetric_right2_if_left_GaloisI[of x1']) blast+
 qed
 
 lemma partial_equivalence_rel_right2_if_partial_equivalence_rel_equivalenceI:
   assumes PER_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "([x1' x2' \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "x1' \<le>\<^bsub>R1\<^esub> x2'"
   shows "partial_equivalence_rel (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
 proof -
   from \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close> PER_equiv1 have "x1' \<equiv>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x1'"
     by (blast elim: t1.preorder_equivalence_order_equivalenceE
       intro: bi_related_if_rel_equivalence_on)
   with assms have "(\<le>\<^bsub>R2 x1' x2'\<^esub>) = (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>)"
     by (intro flip.left2_eq_if_bi_related_if_monoI) blast+
   with assms show ?thesis
     by (intro partial_equivalence_rel_right2_if_partial_equivalence_rel_right2_if_left_GaloisI[of x1'])
     blast+
 qed
 
 end
 
 paragraph \<open>Function Relator\<close>
 
 context transport_Fun_Rel
 begin
 
 lemma reflexive_on_in_field_leftI:
   assumes "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "partial_equivalence_rel (\<le>\<^bsub>L2\<^esub>)"
   shows "reflexive_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   using assms by (intro tdfr.reflexive_on_in_field_leftI) simp_all
 
 lemma transitive_leftI:
   assumes "reflexive_on (in_dom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   shows "transitive (\<le>\<^bsub>L\<^esub>)"
   using assms by (intro tdfr.transitive_leftI) simp_all
 
 lemma transitive_leftI':
   assumes "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   shows "transitive (\<le>\<^bsub>L\<^esub>)"
   using assms by (intro tdfr.transitive_leftI') simp_all
 
 lemma preorder_on_in_field_leftI:
   assumes "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "partial_equivalence_rel (\<le>\<^bsub>L2\<^esub>)"
   shows "preorder_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   using assms by (intro tdfr.preorder_on_in_field_leftI) simp_all
 
 lemma symmetric_leftI:
   assumes "symmetric (\<le>\<^bsub>L1\<^esub>)"
   and "symmetric (\<le>\<^bsub>L2\<^esub>)"
   shows "symmetric (\<le>\<^bsub>L\<^esub>)"
   using assms by (intro tdfr.symmetric_leftI) simp_all
 
 corollary partial_equivalence_rel_leftI:
   assumes "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "symmetric (\<le>\<^bsub>L1\<^esub>)"
   and "partial_equivalence_rel (\<le>\<^bsub>L2\<^esub>)"
   shows "partial_equivalence_rel (\<le>\<^bsub>L\<^esub>)"
   using assms by (intro tdfr.partial_equivalence_rel_leftI) auto
 
 end
 
 paragraph \<open>Monotone Dependent Function Relator\<close>
 
 context transport_Mono_Dep_Fun_Rel
 begin
 
 lemmas reflexive_on_in_field_leftI = Refl_Rel_reflexive_on_in_field[of tdfr.L,
   folded left_rel_eq_tdfr_left_Refl_Rel]
 lemmas transitive_leftI = Refl_Rel_transitiveI
   [of tdfr.L, folded left_rel_eq_tdfr_left_Refl_Rel]
 lemmas preorder_on_in_field_leftI = Refl_Rel_preorder_on_in_fieldI[of tdfr.L,
   folded left_rel_eq_tdfr_left_Refl_Rel]
 lemmas symmetric_leftI = Refl_Rel_symmetricI[of tdfr.L,
   OF tdfr.symmetric_leftI, folded left_rel_eq_tdfr_left_Refl_Rel]
 lemmas partial_equivalence_rel_leftI = Refl_Rel_partial_equivalence_relI[of tdfr.L,
   OF tdfr.partial_equivalence_rel_leftI, folded left_rel_eq_tdfr_left_Refl_Rel]
 
 end
 
 
 paragraph \<open>Monotone Function Relator\<close>
 
 context transport_Mono_Fun_Rel
 begin
 
 lemma symmetric_leftI:
   assumes "symmetric (\<le>\<^bsub>L1\<^esub>)"
   and "symmetric (\<le>\<^bsub>L2\<^esub>)"
   shows "symmetric (\<le>\<^bsub>L\<^esub>)"
   using assms by (intro tpdfr.symmetric_leftI) auto
 
 lemma partial_equivalence_rel_leftI:
   assumes "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "symmetric (\<le>\<^bsub>L1\<^esub>)"
   and "partial_equivalence_rel (\<le>\<^bsub>L2\<^esub>)"
   shows "partial_equivalence_rel (\<le>\<^bsub>L\<^esub>)"
   using assms by (intro tpdfr.partial_equivalence_rel_leftI) auto
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Functions/Transport_Functions_Order_Equivalence.thy b/thys/Transport/Transport/Functions/Transport_Functions_Order_Equivalence.thy
--- a/thys/Transport/Transport/Functions/Transport_Functions_Order_Equivalence.thy
+++ b/thys/Transport/Transport/Functions/Transport_Functions_Order_Equivalence.thy
@@ -1,725 +1,726 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Order Equivalence\<close>
 theory Transport_Functions_Order_Equivalence
   imports
     Transport_Functions_Monotone
     Transport_Functions_Galois_Equivalence
 begin
 
 paragraph \<open>Dependent Function Relator\<close>
 
 context transport_Dep_Fun_Rel
 begin
 
 subparagraph \<open>Inflationary\<close>
 
 lemma rel_unit_self_if_rel_selfI:
   assumes inflationary_unit1: "inflationary_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and refl_L1: "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and trans_L1: "transitive (\<le>\<^bsub>L1\<^esub>)"
   and mono_l2: "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> ((\<le>\<^bsub>L2 x x\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>)"
   and mono_r2: "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>)"
   and inflationary_unit2: "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow>
     inflationary_on (in_codom (\<le>\<^bsub>L2 x x\<^esub>)) (\<le>\<^bsub>L2 x x\<^esub>) (\<eta>\<^bsub>2 x (l1 x)\<^esub>)"
   and L2_le1: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and L2_unit_le2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and ge_R2_l2_le2: "\<And>x y. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> in_codom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) y \<Longrightarrow>
     (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub> y) \<le> (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y)"
   and trans_L2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "f \<le>\<^bsub>L\<^esub> f"
   shows "f \<le>\<^bsub>L\<^esub> \<eta> f"
 proof (intro left_relI)
   fix x1 x2 assume [iff]: "x1 \<le>\<^bsub>L1\<^esub> x2"
   moreover with inflationary_unit1 have "x2 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2" by blast
   ultimately have "x1 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2" using trans_L1 by blast
   with \<open>f \<le>\<^bsub>L\<^esub> f\<close> have "f x1 \<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub> f (\<eta>\<^sub>1 x2)" by blast
   with L2_unit_le2 have "f x1 \<le>\<^bsub>L2 x1 x2\<^esub> f (\<eta>\<^sub>1 x2)" by blast
   moreover have "... \<le>\<^bsub>L2 x1 x2\<^esub> \<eta> f x2"
   proof -
     from refl_L1 \<open>x2 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2\<close> have "\<eta>\<^sub>1 x2 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2" by blast
     with \<open>f \<le>\<^bsub>L\<^esub> f\<close> have "f (\<eta>\<^sub>1 x2) \<le>\<^bsub>L2 (\<eta>\<^sub>1 x2) (\<eta>\<^sub>1 x2)\<^esub> f (\<eta>\<^sub>1 x2)" by blast
     with L2_le1 have "f (\<eta>\<^sub>1 x2) \<le>\<^bsub>L2 x2 (\<eta>\<^sub>1 x2)\<^esub> f (\<eta>\<^sub>1 x2)"
       using \<open>x2 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x2\<close> by blast
     moreover from refl_L1 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close> have [iff]: "x2 \<le>\<^bsub>L1\<^esub> x2" by blast
     ultimately have "f (\<eta>\<^sub>1 x2) \<le>\<^bsub>L2 x2 x2\<^esub> f (\<eta>\<^sub>1 x2)" using L2_unit_le2 by blast
     with inflationary_unit2 have "f (\<eta>\<^sub>1 x2) \<le>\<^bsub>L2 x2 x2\<^esub> \<eta>\<^bsub>2 x2 (l1 x2)\<^esub> (f (\<eta>\<^sub>1 x2))" by blast
     moreover have "... \<le>\<^bsub>L2 x2 x2\<^esub> \<eta> f x2"
     proof -
       from \<open>f (\<eta>\<^sub>1 x2) \<le>\<^bsub>L2 x2 x2\<^esub> f (\<eta>\<^sub>1 x2)\<close> mono_l2
         have "l2\<^bsub>(l1 x2) x2\<^esub> (f (\<eta>\<^sub>1 x2)) \<le>\<^bsub>R2 (l1 x2) (l1 x2)\<^esub> l2\<^bsub>(l1 x2) x2\<^esub> (f (\<eta>\<^sub>1 x2))"
         by blast
       with ge_R2_l2_le2
         have "l2\<^bsub>(l1 x2) x2\<^esub> (f (\<eta>\<^sub>1 x2)) \<le>\<^bsub>R2 (l1 x2) (l1 x2)\<^esub> l2\<^bsub>(l1 x2) (\<eta>\<^sub>1 x2)\<^esub> (f (\<eta>\<^sub>1 x2))"
         using \<open>f (\<eta>\<^sub>1 x2) \<le>\<^bsub>L2 x2 (\<eta>\<^sub>1 x2)\<^esub> f (\<eta>\<^sub>1 x2)\<close> by blast
       with mono_r2 have "\<eta>\<^bsub>2 x2 (l1 x2)\<^esub> (f (\<eta>\<^sub>1 x2)) \<le>\<^bsub>L2 x2 (\<eta>\<^sub>1 x2)\<^esub> \<eta> f x2"
         by auto
       with L2_unit_le2 show ?thesis by blast
     qed
     ultimately have "f (\<eta>\<^sub>1 x2) \<le>\<^bsub>L2 x2 x2\<^esub> \<eta> f x2" using trans_L2 by blast
     with L2_le1 show ?thesis by blast
   qed
   ultimately show "f x1 \<le>\<^bsub>L2 x1 x2\<^esub> \<eta> f x2" using trans_L2 by blast
 qed
 
 subparagraph \<open>Deflationary\<close>
 
 interpretation flip_inv :
   transport_Dep_Fun_Rel "(\<ge>\<^bsub>R1\<^esub>)" "(\<ge>\<^bsub>L1\<^esub>)" r1 l1 "flip2 R2" "flip2 L2" r2 l2
   rewrites "flip_inv.L \<equiv> (\<ge>\<^bsub>R\<^esub>)" and "flip_inv.R \<equiv> (\<ge>\<^bsub>L\<^esub>)"
   and "flip_inv.unit \<equiv> \<epsilon>"
   and "flip_inv.t1.unit \<equiv> \<epsilon>\<^sub>1"
   and "\<And>x y. flip_inv.t2_unit x y \<equiv> \<epsilon>\<^bsub>2 y x\<^esub>"
   and "\<And>R x y. (flip2 R x y)\<inverse> \<equiv> R y x"
   and "\<And>R. in_codom R\<inverse> \<equiv> in_dom R"
   and "\<And>R x1 x2. in_codom (flip2 R x1 x2) \<equiv> in_dom (R x2 x1)"
   and "\<And>x1 x2 x1' x2'. (flip2 R2 x1' x2' \<Rrightarrow>\<^sub>m flip2 L2 x1 x2) \<equiv> ((\<le>\<^bsub>R2 x2' x1'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x2 x1\<^esub>))"
   and "\<And>x1 x2 x1' x2'. (flip2 L2 x1 x2 \<Rrightarrow>\<^sub>m flip2 R2 x1' x2') \<equiv> ((\<le>\<^bsub>L2 x2 x1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 x2' x1'\<^esub>))"
   and "\<And>P. inflationary_on P (\<ge>\<^bsub>R1\<^esub>) \<equiv> deflationary_on P (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>P x. inflationary_on P (flip2 R2 x x) \<equiv> deflationary_on P (\<le>\<^bsub>R2 x x\<^esub>)"
   and "\<And>x1 x2 x3 x4. flip2 R2 x1 x2 \<le> flip2 R2 x3 x4 \<equiv> (\<le>\<^bsub>R2 x2 x1\<^esub>) \<le> (\<le>\<^bsub>R2 x4 x3\<^esub>)"
   and "\<And>(R :: 'z \<Rightarrow> _) (P :: 'z \<Rightarrow> bool). reflexive_on P R\<inverse> \<equiv> reflexive_on P R"
   and "\<And>R. transitive R\<inverse> \<equiv> transitive R"
   and "\<And>x1' x2'. transitive (flip2 R2 x1' x2') \<equiv> transitive (\<le>\<^bsub>R2 x2' x1'\<^esub>)"
   by (simp_all add: flip_inv_left_eq_ge_right flip_inv_right_eq_ge_left
     flip_unit_eq_counit t1.flip_unit_eq_counit t2.flip_unit_eq_counit
     galois_prop.rel_inv_half_galois_prop_right_eq_half_galois_prop_left_rel_inv)
 
 lemma counit_rel_self_if_rel_selfI:
   assumes "deflationary_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>) \<epsilon>\<^sub>1"
   and "reflexive_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "transitive (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> ((\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>)) (l2\<^bsub> x' (r1 x')\<^esub>)"
   and "\<And>x' x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> ((\<le>\<^bsub>R2 x' x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') x'\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> deflationary_on (in_dom (\<le>\<^bsub>R2 x' x'\<^esub>)) (\<le>\<^bsub>R2 x' x'\<^esub>) (\<epsilon>\<^bsub>2 (r1 x') x'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x' y'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> in_dom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>) y' \<Longrightarrow>
     (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub> y') \<le> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y')"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   shows "\<epsilon> g \<le>\<^bsub>R\<^esub> g"
   using assms by (intro flip_inv.rel_unit_self_if_rel_selfI[simplified rel_inv_iff_rel])
 
 
 subparagraph \<open>Relational Equivalence\<close>
 
 lemma bi_related_unit_self_if_rel_self_aux:
   assumes rel_equiv_unit1: "rel_equivalence_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and mono_r2: "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x x\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>)"
   and rel_equiv_unit2: "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow>
     rel_equivalence_on (in_field (\<le>\<^bsub>L2 x x\<^esub>)) (\<le>\<^bsub>L2 x x\<^esub>) (\<eta>\<^bsub>2 x (l1 x)\<^esub>)"
   and L2_le1: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and L2_le2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and [iff]: "x \<le>\<^bsub>L1\<^esub> x"
   shows "((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>)"
   and "((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>)"
   and "deflationary_on (in_dom (\<le>\<^bsub>L2 x x\<^esub>)) (\<le>\<^bsub>L2 x x\<^esub>) \<eta>\<^bsub>2 x (l1 x)\<^esub>"
   and "inflationary_on (in_codom (\<le>\<^bsub>L2 x x\<^esub>)) (\<le>\<^bsub>L2 x x\<^esub>) \<eta>\<^bsub>2 x (l1 x)\<^esub>"
 proof -
   from rel_equiv_unit1 have "x \<equiv>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x" by blast
   with mono_r2 show "((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>)"
     and "((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>)"
     using L2_le1 L2_le2 by blast+
 qed (insert rel_equiv_unit2, blast+)
 
 interpretation flip : transport_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2
   rewrites "flip.counit \<equiv> \<eta>" and "flip.t1.counit \<equiv> \<eta>\<^sub>1"
   and "\<And>x y. flip.t2_counit x y \<equiv> \<eta>\<^bsub>2 y x\<^esub>"
   by (simp_all add: order_functors.flip_counit_eq_unit)
 
 lemma bi_related_unit_self_if_rel_selfI:
   assumes rel_equiv_unit1: "rel_equivalence_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and trans_L1: "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> ((\<le>\<^bsub>L2 x x\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x x\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow>
     rel_equivalence_on (in_field (\<le>\<^bsub>L2 x x\<^esub>)) (\<le>\<^bsub>L2 x x\<^esub>) (\<eta>\<^bsub>2 x (l1 x)\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x1) x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x y. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> in_dom (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>) y \<Longrightarrow>
     (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub> y) \<le> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y)"
   and "\<And>x y. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> in_codom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) y \<Longrightarrow>
     (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub> y) \<le> (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "f \<le>\<^bsub>L\<^esub> f"
   shows "f \<equiv>\<^bsub>L\<^esub> \<eta> f"
 proof -
   from rel_equiv_unit1 trans_L1 have "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
     by (intro reflexive_on_in_field_if_transitive_if_rel_equivalence_on)
   with assms show ?thesis
     by (intro bi_relatedI rel_unit_self_if_rel_selfI
       flip.counit_rel_self_if_rel_selfI
       bi_related_unit_self_if_rel_self_aux)
     (auto intro: inflationary_on_if_le_pred_if_inflationary_on
       deflationary_on_if_le_pred_if_deflationary_on
       reflexive_on_if_le_pred_if_reflexive_on
       in_field_if_in_dom in_field_if_in_codom)
 qed
 
 
 subparagraph \<open>Lemmas for Monotone Function Relator\<close>
 
 lemma order_equivalence_if_order_equivalence_mono_assms_leftI:
   assumes order_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_R1: "reflexive_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and R2_counit_le1: "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and mono_l2: "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and [iff]: "x1' \<le>\<^bsub>R1\<^esub> x2'"
   shows "([in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x1' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
   and "([in_codom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x2')\<^esub>)"
 proof -
   from refl_R1 have "x1' \<le>\<^bsub>R1\<^esub> x1'" "x2' \<le>\<^bsub>R1\<^esub> x2'" by auto
   moreover with order_equiv1
     have "r1 x1' \<le>\<^bsub>L1\<^esub> r1 x2'" "r1 x1' \<le>\<^bsub>L1\<^esub> r1 x1'" "r1 x2' \<le>\<^bsub>L1\<^esub> r1 x2'" by auto
   ultimately have "r1 x1' \<^bsub>L1\<^esub>\<lessapprox> x1'" "r1 x2' \<^bsub>L1\<^esub>\<lessapprox> x2'" by blast+
   note Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_l2 \<open>x1' \<le>\<^bsub>R1\<^esub> x2'\<close>]
     \<open>r1 x1' \<le>\<^bsub>L1\<^esub> r1 x1'\<close>]
   with \<open>r1 x1' \<^bsub>L1\<^esub>\<lessapprox> x1'\<close> R2_counit_le1
     show "([in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x1' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
     by (intro Dep_Fun_Rel_predI) (auto dest!: in_field_if_in_dom)
   note Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_l2 \<open>x2' \<le>\<^bsub>R1\<^esub> x2'\<close>]
     \<open>r1 x1' \<le>\<^bsub>L1\<^esub> r1 x2'\<close>]
   with \<open>r1 x2' \<^bsub>L1\<^esub>\<lessapprox> x2'\<close> R2_counit_le1
     show "([in_codom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x2')\<^esub>)"
     by (intro Dep_Fun_Rel_predI) (auto dest!: in_field_if_in_codom)
 qed
 
 lemma order_equivalence_if_order_equivalence_mono_assms_rightI:
   assumes order_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and refl_L1: "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and L2_unit_le2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and mono_r2: "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and [iff]: "x1 \<le>\<^bsub>L1\<^esub> x2"
   shows "([in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub>)"
   and "([in_dom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x1)\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
 proof -
   from refl_L1 have "x1 \<le>\<^bsub>L1\<^esub> x1" "x2 \<le>\<^bsub>L1\<^esub> x2" by auto
   moreover with order_equiv1
     have "l1 x1 \<le>\<^bsub>R1\<^esub> l1 x2" "l1 x1 \<le>\<^bsub>R1\<^esub> l1 x1" "l1 x2 \<le>\<^bsub>R1\<^esub> l1 x2" by auto
   ultimately have "x1 \<^bsub>L1\<^esub>\<lessapprox> l1 x1" "x2 \<^bsub>L1\<^esub>\<lessapprox> l1 x2" using order_equiv1
     by (auto intro!: t1.left_Galois_left_if_in_codom_if_inflationary_onI)
   note Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_r2 \<open>x1 \<le>\<^bsub>L1\<^esub> x2\<close>]
     \<open>l1 x2 \<le>\<^bsub>R1\<^esub> l1 x2\<close>]
   with \<open>x2 \<^bsub>L1\<^esub>\<lessapprox> l1 x2\<close> L2_unit_le2
     show "([in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub>)"
     by (intro Dep_Fun_Rel_predI) (auto dest!: in_field_if_in_codom)
   note Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_r2 \<open>x1 \<le>\<^bsub>L1\<^esub> x1\<close>]
     \<open>l1 x1 \<le>\<^bsub>R1\<^esub> l1 x2\<close>]
   with \<open>x1 \<^bsub>L1\<^esub>\<lessapprox> l1 x1\<close> L2_unit_le2
     show "([in_dom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x1)\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
     by (intro Dep_Fun_Rel_predI) (auto dest!: in_field_if_in_dom)
 qed
 
 lemma l2_unit_bi_rel_selfI:
   assumes pre_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and mono_L2:
     "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x2 \<le>\<^bsub>L1\<^esub> x3 \<and> x4 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x3)] \<Rrightarrow> (\<ge>)) L2"
   and mono_R2:
     "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | (x2' \<le>\<^bsub>R1\<^esub> x3' \<and> x4' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x3')] \<Rrightarrow> (\<ge>)) R2"
   and mono_l2: "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "x \<le>\<^bsub>L1\<^esub> x"
   and "in_field (\<le>\<^bsub>L2 x x\<^esub>) y"
   shows "l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y \<equiv>\<^bsub>R2 (l1 x) (l1 x)\<^esub> l2\<^bsub>(l1 x) x\<^esub> y"
 proof (rule bi_relatedI)
   note t1.preorder_equivalence_order_equivalenceE[elim!]
   from \<open>x \<le>\<^bsub>L1\<^esub> x\<close> pre_equiv1 have "l1 x \<le>\<^bsub>R1\<^esub> l1 x" "x \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x" "\<eta>\<^sub>1 x \<le>\<^bsub>L1\<^esub> x" by blast+
   with pre_equiv1 have "x \<^bsub>L1\<^esub>\<lessapprox> l1 x" "\<eta>\<^sub>1 x \<^bsub>L1\<^esub>\<lessapprox> l1 x" by (auto 4 3)
   from pre_equiv1 \<open>x \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x\<close> have "x \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 (\<eta>\<^sub>1 x)" by fastforce
   moreover note \<open>in_field (\<le>\<^bsub>L2 x x\<^esub>) y\<close>
     Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_L2 \<open>\<eta>\<^sub>1 x \<le>\<^bsub>L1\<^esub> x\<close>] \<open>\<eta>\<^sub>1 x \<le>\<^bsub>L1\<^esub> x\<close>]
     Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_L2 \<open>x \<le>\<^bsub>L1\<^esub> x\<close>] \<open>\<eta>\<^sub>1 x \<le>\<^bsub>L1\<^esub> x\<close>]
   ultimately have "in_field (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) (\<eta>\<^sub>1 x)\<^esub>) y" "in_field (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) y"
     using \<open>x \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x\<close> by blast+
   moreover note \<open>x \<^bsub>L1\<^esub>\<lessapprox> l1 x\<close>
     Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_l2 \<open>l1 x \<le>\<^bsub>R1\<^esub> l1 x\<close>] \<open>\<eta>\<^sub>1 x \<le>\<^bsub>L1\<^esub> x\<close>]
   ultimately have "l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y \<le>\<^bsub>R2 (\<epsilon>\<^sub>1 (l1 x)) (l1 x)\<^esub> l2\<^bsub>(l1 x) x\<^esub> y" by auto
   moreover from pre_equiv1 \<open>l1 x \<le>\<^bsub>R1\<^esub> l1 x\<close>
     have "\<epsilon>\<^sub>1 (l1 x) \<le>\<^bsub>R1\<^esub> l1 x" "l1 x \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 (l1 x)" by fastforce+
   moreover note Dep_Fun_Rel_relD[OF dep_mono_wrt_relD
     [OF mono_R2 \<open>l1 x \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 (l1 x)\<close>] \<open>l1 x \<le>\<^bsub>R1\<^esub> l1 x\<close>]
   ultimately show "l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y \<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub> l2\<^bsub>(l1 x) x\<^esub> y" by blast
   note \<open>\<eta>\<^sub>1 x \<^bsub>L1\<^esub>\<lessapprox> l1 x\<close> \<open>in_field (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) y\<close>
     Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_l2 \<open>l1 x \<le>\<^bsub>R1\<^esub> l1 x\<close>] \<open>x \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x\<close>]
   then show "l2\<^bsub>(l1 x) x\<^esub> y \<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub> l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y" by auto
 qed
 
 lemma r2_counit_bi_rel_selfI:
   assumes pre_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and mono_L2:
     "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x2 \<le>\<^bsub>L1\<^esub> x3 \<and> x4 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x3)] \<Rrightarrow> (\<ge>)) L2"
   and mono_R2:
     "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | (x2' \<le>\<^bsub>R1\<^esub> x3' \<and> x4' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x3')] \<Rrightarrow> (\<ge>)) R2"
   and mono_r2: "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "x' \<le>\<^bsub>R1\<^esub> x'"
   and "in_field (\<le>\<^bsub>R2 x' x'\<^esub>) y'"
   shows "r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y' \<equiv>\<^bsub>L2 (r1 x') (r1 x')\<^esub> r2\<^bsub>(r1 x') x'\<^esub> y'"
 proof (rule bi_relatedI)
   note t1.preorder_equivalence_order_equivalenceE[elim!]
   from \<open>x' \<le>\<^bsub>R1\<^esub> x'\<close> pre_equiv1 have "r1 x' \<le>\<^bsub>L1\<^esub> r1 x'" "x' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x'" "\<epsilon>\<^sub>1 x' \<le>\<^bsub>R1\<^esub> x'" by blast+
-  with pre_equiv1 have "r1 x' \<^bsub>L1\<^esub>\<lessapprox> x'" "r1 x' \<^bsub>L1\<^esub>\<lessapprox> \<epsilon>\<^sub>1 x'" by auto
+  with pre_equiv1 have "r1 x' \<^bsub>L1\<^esub>\<lessapprox> x'" "r1 x' \<^bsub>L1\<^esub>\<lessapprox> \<epsilon>\<^sub>1 x'" by force+
   from pre_equiv1 \<open>x' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x'\<close> have "x' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 (\<epsilon>\<^sub>1 x')" by fastforce
   moreover note \<open>in_field (\<le>\<^bsub>R2 x' x'\<^esub>) y'\<close>
     Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_R2 \<open>\<epsilon>\<^sub>1 x' \<le>\<^bsub>R1\<^esub> x'\<close>] \<open>\<epsilon>\<^sub>1 x' \<le>\<^bsub>R1\<^esub> x'\<close>]
     Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_R2 \<open>\<epsilon>\<^sub>1 x' \<le>\<^bsub>R1\<^esub> x'\<close>] \<open>x' \<le>\<^bsub>R1\<^esub> x'\<close>]
   ultimately have "in_field (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') (\<epsilon>\<^sub>1 x')\<^esub>) y'" "in_field (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>) y'"
     using \<open>x' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x'\<close> \<open>x' \<le>\<^bsub>R1\<^esub> x'\<close> by blast+
   moreover note \<open>r1 x' \<^bsub>L1\<^esub>\<lessapprox> \<epsilon>\<^sub>1 x'\<close>
     Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_r2 \<open>r1 x' \<le>\<^bsub>L1\<^esub> r1 x'\<close>] \<open>\<epsilon>\<^sub>1 x' \<le>\<^bsub>R1\<^esub> x'\<close>]
   ultimately show "r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y' \<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub> r2\<^bsub>(r1 x') x'\<^esub> y'" by auto
   note \<open>r1 x' \<^bsub>L1\<^esub>\<lessapprox> x'\<close> \<open>in_field (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') (\<epsilon>\<^sub>1 x')\<^esub>) y'\<close>
     Dep_Fun_Rel_relD[OF dep_mono_wrt_relD[OF mono_r2 \<open>r1 x' \<le>\<^bsub>L1\<^esub> r1 x'\<close>] \<open>x' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x'\<close>]
   then have "r2\<^bsub>(r1 x') x'\<^esub> y' \<le>\<^bsub>L2 (r1 x') (\<eta>\<^sub>1 (r1 x'))\<^esub> r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y'" by auto
   moreover from pre_equiv1 \<open>r1 x' \<le>\<^bsub>L1\<^esub> r1 x'\<close>
     have "\<eta>\<^sub>1 (r1 x') \<le>\<^bsub>L1\<^esub> r1 x'" "r1 x' \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 (r1 x')" by fastforce+
   moreover note Dep_Fun_Rel_relD[OF dep_mono_wrt_relD
     [OF mono_L2 \<open>r1 x' \<le>\<^bsub>L1\<^esub> r1 x'\<close>] \<open>r1 x' \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 (r1 x')\<close>]
   ultimately show "r2\<^bsub>(r1 x') x'\<^esub> y' \<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub> r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y'"
     using pre_equiv1 by blast
 qed
 
 end
 
 
 paragraph \<open>Function Relator\<close>
 
 context transport_Fun_Rel
 begin
 
 corollary rel_unit_self_if_rel_selfI:
   assumes "inflationary_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "inflationary_on (in_codom (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>) \<eta>\<^sub>2"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "f \<le>\<^bsub>L\<^esub> f"
   shows "f \<le>\<^bsub>L\<^esub> \<eta> f"
   using assms by (intro tdfr.rel_unit_self_if_rel_selfI) simp_all
 
 corollary counit_rel_self_if_rel_selfI:
   assumes "deflationary_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>) \<epsilon>\<^sub>1"
   and "reflexive_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "transitive (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "deflationary_on (in_dom (\<le>\<^bsub>R2\<^esub>)) (\<le>\<^bsub>R2\<^esub>) \<epsilon>\<^sub>2"
   and "transitive (\<le>\<^bsub>R2\<^esub>)"
   and "g \<le>\<^bsub>R\<^esub> g"
   shows "\<epsilon> g \<le>\<^bsub>R\<^esub> g"
   using assms by (intro tdfr.counit_rel_self_if_rel_selfI) simp_all
 
 lemma bi_related_unit_self_if_rel_selfI:
   assumes "rel_equivalence_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "rel_equivalence_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>) \<eta>\<^sub>2"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   and "f \<le>\<^bsub>L\<^esub> f"
   shows "f \<equiv>\<^bsub>L\<^esub> \<eta> f"
   using assms by (intro tdfr.bi_related_unit_self_if_rel_selfI) simp_all
 
 end
 
 
 paragraph \<open>Monotone Dependent Function Relator\<close>
 
 context transport_Mono_Dep_Fun_Rel
 begin
 
 subparagraph \<open>Inflationary\<close>
 
 lemma inflationary_on_unitI:
   assumes "(tdfr.L \<Rrightarrow>\<^sub>m tdfr.R) l" and "(tdfr.R \<Rrightarrow>\<^sub>m tdfr.L) r"
   and "inflationary_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> ((\<le>\<^bsub>L2 x x\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> inflationary_on (in_codom (\<le>\<^bsub>L2 x x\<^esub>)) (\<le>\<^bsub>L2 x x\<^esub>) (\<eta>\<^bsub>2 x (l1 x)\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x y. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> in_codom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) y \<Longrightarrow>
     (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub> y) \<le> (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   shows "inflationary_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   unfolding left_rel_eq_tdfr_left_Refl_Rel using assms
   by (intro inflationary_onI Refl_RelI)
-  (auto intro: tdfr.rel_unit_self_if_rel_selfI[simplified unit_eq] elim!: Refl_RelE)
+  (auto 6 2 intro: tdfr.rel_unit_self_if_rel_selfI[simplified unit_eq]
+    elim!: Refl_RelE in_fieldE)
 
 
 subparagraph \<open>Deflationary\<close>
 
 lemma deflationary_on_counitI:
   assumes "(tdfr.L \<Rrightarrow>\<^sub>m tdfr.R) l" and "(tdfr.R \<Rrightarrow>\<^sub>m tdfr.L) r"
   and "deflationary_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>) \<epsilon>\<^sub>1"
   and "reflexive_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "transitive (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> ((\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>)) (l2\<^bsub> x' (r1 x')\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow>
     ((\<le>\<^bsub>R2 x' x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') x'\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> deflationary_on (in_dom (\<le>\<^bsub>R2 x' x'\<^esub>)) (\<le>\<^bsub>R2 x' x'\<^esub>) (\<epsilon>\<^bsub>2 (r1 x') x'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x' y'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> in_dom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>) y' \<Longrightarrow>
     (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub> y') \<le> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y')"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   shows "deflationary_on (in_field (\<le>\<^bsub>R\<^esub>)) (\<le>\<^bsub>R\<^esub>) \<epsilon>"
   unfolding right_rel_eq_tdfr_right_Refl_Rel using assms
   by (intro deflationary_onI Refl_RelI)
-  (auto intro: tdfr.counit_rel_self_if_rel_selfI[simplified counit_eq]
-    elim!: Refl_RelE)
+  (auto 6 2 intro: tdfr.counit_rel_self_if_rel_selfI[simplified counit_eq]
+    elim!: Refl_RelE in_fieldE)
 
 
 subparagraph \<open>Relational Equivalence\<close>
 
 context
 begin
 
 interpretation flip : transport_Mono_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2
   rewrites "flip.counit \<equiv> \<eta>" and "flip.t1.counit \<equiv> \<eta>\<^sub>1"
   and "\<And>x y. flip.t2_counit x y \<equiv> \<eta>\<^bsub>2 y x\<^esub>"
   by (simp_all add: order_functors.flip_counit_eq_unit)
 
 lemma rel_equivalence_on_unitI:
   assumes "(tdfr.L \<Rrightarrow>\<^sub>m tdfr.R) l" and "(tdfr.R \<Rrightarrow>\<^sub>m tdfr.L) r"
   and rel_equiv_unit1: "rel_equivalence_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and trans_L1: "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> ((\<le>\<^bsub>L2 x x\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x x\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> rel_equivalence_on (in_field (\<le>\<^bsub>L2 x x\<^esub>)) (\<le>\<^bsub>L2 x x\<^esub>) (\<eta>\<^bsub>2 x (l1 x)\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x1) x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x y. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> in_dom (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>) y \<Longrightarrow>
     (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub> y) \<le> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y)"
   and "\<And>x y. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> in_codom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) y \<Longrightarrow>
     (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub> y) \<le> (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   shows "rel_equivalence_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
 proof -
   from rel_equiv_unit1 trans_L1 have "reflexive_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
     by (intro reflexive_on_in_field_if_transitive_if_rel_equivalence_on)
   with assms show ?thesis
     by (intro rel_equivalence_onI inflationary_on_unitI
       flip.deflationary_on_counitI)
     (auto intro!: tdfr.bi_related_unit_self_if_rel_self_aux
       intro: inflationary_on_if_le_pred_if_inflationary_on
         deflationary_on_if_le_pred_if_deflationary_on
         reflexive_on_if_le_pred_if_reflexive_on
         in_field_if_in_dom in_field_if_in_codom
       elim!: rel_equivalence_onE
       simp only:)
 qed
 
 end
 
 subparagraph \<open>Order Equivalence\<close>
 
 interpretation flip : transport_Mono_Dep_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2
   rewrites "flip.unit \<equiv> \<epsilon>" and "flip.t1.unit \<equiv> \<epsilon>\<^sub>1"
   and "flip.counit \<equiv> \<eta>" and "flip.t1.counit \<equiv> \<eta>\<^sub>1"
   and "\<And>x y. flip.t2_unit x y \<equiv> \<epsilon>\<^bsub>2 y x\<^esub>"
   by (simp_all add: order_functors.flip_counit_eq_unit)
 
 lemma order_equivalenceI:
   assumes "(tdfr.L \<Rrightarrow>\<^sub>m tdfr.R) l" and "(tdfr.R \<Rrightarrow>\<^sub>m tdfr.L) r"
   and "rel_equivalence_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and "rel_equivalence_on (in_field (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>) \<epsilon>\<^sub>1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)" and "transitive (\<le>\<^bsub>R1\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> ((\<le>\<^bsub>L2 x x\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> ((\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 x' x'\<^esub>)) (l2\<^bsub>x' (r1 x')\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> ((\<le>\<^bsub>R2 x' x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') x'\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x x\<^esub>)) (r2\<^bsub>x (l1 x)\<^esub>)"
   and "\<And>x. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> rel_equivalence_on (in_field (\<le>\<^bsub>L2 x x\<^esub>)) (\<le>\<^bsub>L2 x x\<^esub>) (\<eta>\<^bsub>2 x (l1 x)\<^esub>)"
   and "\<And>x'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow>
     rel_equivalence_on (in_field (\<le>\<^bsub>R2 x' x'\<^esub>)) (\<le>\<^bsub>R2 x' x'\<^esub>) (\<epsilon>\<^bsub>2 (r1 x') x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x1) x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x2' x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' (\<epsilon>\<^sub>1 x2')\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x y. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> in_dom (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>) y \<Longrightarrow>
     (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub> y) \<le> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y)"
   and "\<And>x y. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> in_codom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) y \<Longrightarrow>
     (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub> y) \<le> (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y)"
   and "\<And>x' y'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> in_dom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>) y' \<Longrightarrow>
     (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub> y') \<le> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y')"
   and "\<And>x' y'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> in_codom (\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>) y' \<Longrightarrow>
     (\<ge>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub> y') \<le> (\<ge>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y')"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>R1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1 x2\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)) l r"
   using assms
   by (intro order_equivalenceI rel_equivalence_on_unitI flip.rel_equivalence_on_unitI
     mono_wrt_rel_leftI flip.mono_wrt_rel_leftI)
   auto
 
 lemma order_equivalence_if_preorder_equivalenceI:
   assumes pre_equiv1: "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and order_equiv2: "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow>
     ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and L2_les: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
     "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x1) x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
     "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
     "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and R2_les: "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x2' x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
     "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
     "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
     "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' (\<epsilon>\<^sub>1 x2')\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x1' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>) (l2\<^bsub>x2' (r1 x2')\<^esub>)"
   and l2_bi_rel: "\<And>x y. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> in_field (\<le>\<^bsub>L2 x x\<^esub>) y \<Longrightarrow>
     l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y \<equiv>\<^bsub>R2 (l1 x) (l1 x)\<^esub> l2\<^bsub>(l1 x) x\<^esub> y"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_codom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>) (r2\<^bsub>x2 (l1 x2)\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow>
     ([in_dom (\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x1)\<^esub>) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
   and r2_bi_rel: "\<And>x' y'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> in_field (\<le>\<^bsub>R2 x' x'\<^esub>) y' \<Longrightarrow>
     r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y' \<equiv>\<^bsub>L2 (r1 x') (r1 x')\<^esub> r2\<^bsub>(r1 x') x'\<^esub> y'"
   and trans_L2: "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and trans_R2: "\<And>x1 x2. x1 \<le>\<^bsub>R1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1 x2\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)) l r"
 proof -
   from pre_equiv1 L2_les have L2_unit_eq1: "(\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>) = (\<le>\<^bsub>L2 x x\<^esub>)"
     and L2_unit_eq2: "(\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) = (\<le>\<^bsub>L2 x x\<^esub>)"
     if "x \<le>\<^bsub>L1\<^esub> x" for x using \<open>x \<le>\<^bsub>L1\<^esub> x\<close>
     by (auto elim!: t1.preorder_equivalence_order_equivalenceE
       intro!: tdfr.left_rel2_unit_eqs_left_rel2I bi_related_if_rel_equivalence_on
       simp del: t1.unit_eq)
   from pre_equiv1 R2_les have R2_counit_eq1: "(\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>) = (\<le>\<^bsub>R2 x' x'\<^esub>)"
     and R2_counit_eq2: "(\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>) = (\<le>\<^bsub>R2 x' x'\<^esub>)" (is ?goal2)
     if "x' \<le>\<^bsub>R1\<^esub> x'" for x' using \<open>x' \<le>\<^bsub>R1\<^esub> x'\<close>
     by (auto elim!: t1.preorder_equivalence_order_equivalenceE
       intro!: flip.tdfr.left_rel2_unit_eqs_left_rel2I bi_related_if_rel_equivalence_on
       simp del: t1.counit_eq)
   from order_equiv2 have
     mono_l2: "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>)"
     and mono_r2: "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x) x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x (r1 x')\<^esub>)) (r2\<^bsub>x x'\<^esub>)"
     by auto
   moreover have "rel_equivalence_on (in_field (\<le>\<^bsub>L2 x x\<^esub>)) (\<le>\<^bsub>L2 x x\<^esub>) (\<eta>\<^bsub>2 x (l1 x)\<^esub>)" (is ?goal1)
     and "((\<le>\<^bsub>L2 x x\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>)" (is ?goal2)
     if [iff]: "x \<le>\<^bsub>L1\<^esub> x" for x
   proof -
     from pre_equiv1 have "x \<^bsub>L1\<^esub>\<lessapprox> l1 x"
       by (auto intro!: t1.left_GaloisI
         elim!: t1.preorder_equivalence_order_equivalenceE t1.order_equivalenceE)
     with order_equiv2 have "((\<le>\<^bsub>L2 x x\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>)) (l2\<^bsub>(l1 x) x\<^esub>) (r2\<^bsub>x (l1 x)\<^esub>)"
       by (auto simp flip: L2_unit_eq2)
     then show ?goal1 ?goal2 by (auto elim: order_functors.order_equivalenceE)
   qed
   moreover have
     "rel_equivalence_on (in_field (\<le>\<^bsub>R2 x' x'\<^esub>)) (\<le>\<^bsub>R2 x' x'\<^esub>) (\<epsilon>\<^bsub>2 (r1 x') x'\<^esub>)" (is ?goal1)
     and "((\<le>\<^bsub>R2 x' x'\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>)) (r2\<^bsub>(r1 x') x'\<^esub>)" (is ?goal2)
     if [iff]: "x' \<le>\<^bsub>R1\<^esub> x'" for x'
   proof -
     from pre_equiv1 have "r1 x' \<^bsub>L1\<^esub>\<lessapprox> x'" by blast
     with order_equiv2 have "((\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R2 x' x'\<^esub>)) (l2\<^bsub>x' (r1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub>)"
       by (auto simp flip: R2_counit_eq1)
     then show ?goal1 ?goal2 by (auto elim: order_functors.order_equivalenceE)
   qed
   moreover from mono_l2 tdfr.mono_wrt_rel_left2_if_mono_wrt_rel_left2_if_left_GaloisI
     have "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> ((\<le>\<^bsub>L2 (r1 x1') (r1 x2')\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2 x1' x2'\<^esub>)) (l2\<^bsub>x2' (r1 x1')\<^esub>)"
     using pre_equiv1 R2_les(2) by blast
   moreover from pre_equiv1 have "((\<le>\<^bsub>L1\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R1\<^esub>)) l1 r1"
     by (intro t1.half_galois_prop_right_left_right_if_transitive_if_order_equivalence)
     (auto elim!: t1.preorder_equivalence_order_equivalenceE)
   moreover with mono_r2 tdfr.mono_wrt_rel_right2_if_mono_wrt_rel_right2_if_left_GaloisI
     have "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
     using pre_equiv1 by blast
   moreover with L2_les
     have "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> ((\<le>\<^bsub>R2 (l1 x1) (l1 x2)\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2 x1 x2\<^esub>)) (r2\<^bsub>x1 (l1 x2)\<^esub>)"
     by blast
   moreover have "in_dom (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>) y \<Longrightarrow>
       (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub> y) \<le> (\<le>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y)"
       (is "_ \<Longrightarrow> ?goal1")
     and "in_codom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) y \<Longrightarrow>
       (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) x\<^esub> y) \<le> (\<ge>\<^bsub>R2 (l1 x) (l1 x)\<^esub>) (l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y)"
       (is "_ \<Longrightarrow> ?goal2")
     if [iff]: "x \<le>\<^bsub>L1\<^esub> x" for x y
   proof -
     presume "in_dom (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x) x\<^esub>) y \<or> in_codom (\<le>\<^bsub>L2 x (\<eta>\<^sub>1 x)\<^esub>) y"
     then have "in_field (\<le>\<^bsub>L2 x x\<^esub>) y" using L2_unit_eq1 L2_unit_eq2 by auto
     with l2_bi_rel have "l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y \<equiv>\<^bsub>R2 (l1 x) (l1 x)\<^esub> l2\<^bsub>(l1 x) x\<^esub> y" by blast
     moreover from pre_equiv1 have \<open>l1 x \<le>\<^bsub>R1\<^esub> l1 x\<close> by blast
     ultimately show ?goal1 ?goal2 using trans_R2 by blast+
   qed auto
   moreover have "in_dom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>) y' \<Longrightarrow>
       (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub> y') \<le> (\<le>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y')"
       (is "_ \<Longrightarrow> ?goal1")
     and "in_codom (\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>) y' \<Longrightarrow>
       (\<ge>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') x'\<^esub> y') \<le> (\<ge>\<^bsub>L2 (r1 x') (r1 x')\<^esub>) (r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y')"
       (is "_ \<Longrightarrow> ?goal2")
     if [iff]: "x' \<le>\<^bsub>R1\<^esub> x'" for x' y'
   proof -
     presume "in_dom (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x') x'\<^esub>) y' \<or> in_codom (\<le>\<^bsub>R2 x' (\<epsilon>\<^sub>1 x')\<^esub>) y'"
     then have "in_field (\<le>\<^bsub>R2 x' x'\<^esub>) y'" using R2_counit_eq1 R2_counit_eq2 by auto
     with r2_bi_rel have "r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y' \<equiv>\<^bsub>L2 (r1 x') (r1 x')\<^esub> r2\<^bsub>(r1 x') x'\<^esub> y'"
       by blast
     moreover from pre_equiv1 have \<open>r1 x' \<le>\<^bsub>L1\<^esub> r1 x'\<close> by blast
     ultimately show ?goal1 ?goal2 using trans_L2 by blast+
   qed auto
   ultimately show ?thesis using assms
     by (intro order_equivalenceI
       tdfr.mono_wrt_rel_left_if_transitiveI
       tdfr.mono_wrt_rel_left2_if_mono_wrt_rel_left2_if_left_GaloisI
       tdfr.mono_wrt_rel_right_if_transitiveI
       tdfr.mono_wrt_rel_right2_if_mono_wrt_rel_right2_if_left_GaloisI)
     (auto elim!: t1.preorder_equivalence_order_equivalenceE)
 qed
 
 lemma order_equivalence_if_preorder_equivalenceI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x2 x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 (\<eta>\<^sub>1 x1) x2\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 x1\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> (\<le>\<^bsub>L2 x1 (\<eta>\<^sub>1 x2)\<^esub>) \<le> (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x2' x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 (\<epsilon>\<^sub>1 x1') x2'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' x1'\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "\<And>x1' x2'. x1' \<le>\<^bsub>R1\<^esub> x2' \<Longrightarrow> (\<le>\<^bsub>R2 x1' (\<epsilon>\<^sub>1 x2')\<^esub>) \<le> (\<le>\<^bsub>R2 x1' x2'\<^esub>)"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "\<And>x y. x \<le>\<^bsub>L1\<^esub> x \<Longrightarrow> in_field (\<le>\<^bsub>L2 x x\<^esub>) y \<Longrightarrow>
     l2\<^bsub>(l1 x) (\<eta>\<^sub>1 x)\<^esub> y \<equiv>\<^bsub>R2 (l1 x) (l1 x)\<^esub> l2\<^bsub>(l1 x) x\<^esub> y"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x' y'. x' \<le>\<^bsub>R1\<^esub> x' \<Longrightarrow> in_field (\<le>\<^bsub>R2 x' x'\<^esub>) y' \<Longrightarrow>
     r2\<^bsub>(r1 x') (\<epsilon>\<^sub>1 x')\<^esub> y' \<equiv>\<^bsub>L2 (r1 x') (r1 x')\<^esub> r2\<^bsub>(r1 x') x'\<^esub> y'"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>R1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1 x2\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro order_equivalence_if_preorder_equivalenceI
     tdfr.order_equivalence_if_order_equivalence_mono_assms_leftI
     tdfr.order_equivalence_if_order_equivalence_mono_assms_rightI
     reflexive_on_in_field_if_transitive_if_rel_equivalence_on)
   (auto elim!: t1.preorder_equivalence_order_equivalenceE)
 
 lemma order_equivalence_if_mono_if_preorder_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | \<eta>\<^sub>1 x2 \<le>\<^bsub>L1\<^esub> x1] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | (x2 \<le>\<^bsub>L1\<^esub> x3 \<and> x4 \<le>\<^bsub>L1\<^esub> \<eta>\<^sub>1 x3)] \<Rrightarrow> (\<ge>)) L2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | \<epsilon>\<^sub>1 x2' \<le>\<^bsub>R1\<^esub> x1'] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | (x2' \<le>\<^bsub>R1\<^esub> x3' \<and> x4' \<le>\<^bsub>R1\<^esub> \<epsilon>\<^sub>1 x3')] \<Rrightarrow> (\<ge>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   and "\<And>x1 x2. x1 \<le>\<^bsub>L1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>L2 x1 x2\<^esub>)"
   and "\<And>x1 x2. x1 \<le>\<^bsub>R1\<^esub> x2 \<Longrightarrow> transitive (\<le>\<^bsub>R2 x1 x2\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro order_equivalence_if_preorder_equivalenceI'
     tdfr.l2_unit_bi_rel_selfI tdfr.r2_counit_bi_rel_selfI
     tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_leftI
     flip.tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_leftI
     tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_rightI
     flip.tdfr.left_rel_right_iff_left_right_rel_if_galois_prop_le_assms_rightI
     t1.galois_connection_left_right_if_transitive_if_order_equivalence
     flip.t1.galois_connection_left_right_if_transitive_if_order_equivalence
     reflexive_on_in_field_if_transitive_if_rel_equivalence_on)
   (auto elim!: t1.preorder_equivalence_order_equivalenceE)
 
 theorem order_equivalence_if_mono_if_preorder_equivalenceI':
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "\<And>x x'. x \<^bsub>L1\<^esub>\<lessapprox> x' \<Longrightarrow> ((\<le>\<^bsub>L2 x (r1 x')\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R2 (l1 x) x'\<^esub>)) (l2\<^bsub>x' x\<^esub>) (r2\<^bsub>x x'\<^esub>)"
   and "([x1 x2 \<Colon> (\<ge>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x3 x4 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x1 \<le>\<^bsub>L1\<^esub> x3] \<Rrightarrow> (\<le>)) L2"
   and "([x1' x2' \<Colon> (\<ge>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x3' x4' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x1' \<le>\<^bsub>R1\<^esub> x3'] \<Rrightarrow> (\<le>)) R2"
   and "([x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>)] \<Rrightarrow>\<^sub>m [x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)) l2"
   and "([x1 x2 \<Colon> (\<le>\<^bsub>L1\<^esub>)] \<Rrightarrow>\<^sub>m [x1' x2' \<Colon> (\<le>\<^bsub>R1\<^esub>) | x2 \<^bsub>L1\<^esub>\<lessapprox> x1'] \<Rrightarrow>
     [in_field (\<le>\<^bsub>R2 (l1 x1) x2'\<^esub>)] \<Rrightarrow> (\<le>\<^bsub>L2 x1 (r1 x2')\<^esub>)) r2"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro order_equivalence_if_mono_if_preorder_equivalenceI
     tdfr.galois_equivalence_if_mono_if_galois_equivalence_mono_assms_leftI
     flip.tdfr.galois_equivalence_if_mono_if_galois_equivalence_mono_assms_leftI
     tdfr.transitive_left2_if_preorder_equivalenceI
     tdfr.transitive_right2_if_preorder_equivalenceI
     t1.preorder_on_in_field_left_if_transitive_if_order_equivalence
     flip.t1.preorder_on_in_field_left_if_transitive_if_order_equivalence
     t1.galois_equivalence_left_right_if_transitive_if_order_equivalence
     flip.t1.galois_equivalence_left_right_if_transitive_if_order_equivalence)
   (auto elim!: t1.preorder_equivalence_order_equivalenceE
     t2.preorder_equivalence_order_equivalenceE)
 
 end
 
 
 paragraph \<open>Monotone Function Relator\<close>
 
 context transport_Mono_Fun_Rel
 begin
 
 interpretation flip : transport_Mono_Fun_Rel R1 L1 r1 l1 R2 L2 r2 l2 .
 
 lemma inflationary_on_unitI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "inflationary_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and "reflexive_on (in_codom (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>)"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "inflationary_on (in_codom (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>) \<eta>\<^sub>2"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   shows "inflationary_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   using assms by (intro tpdfr.inflationary_on_unitI
     tfr.mono_wrt_rel_leftI flip.tfr.mono_wrt_rel_leftI)
   simp_all
 
 lemma deflationary_on_counitI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "deflationary_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>) \<epsilon>\<^sub>1"
   and "reflexive_on (in_dom (\<le>\<^bsub>R1\<^esub>)) (\<le>\<^bsub>R1\<^esub>)"
   and "transitive (\<le>\<^bsub>R1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "deflationary_on (in_dom (\<le>\<^bsub>R2\<^esub>)) (\<le>\<^bsub>R2\<^esub>) \<epsilon>\<^sub>2"
   and "transitive (\<le>\<^bsub>R2\<^esub>)"
   shows "deflationary_on (in_field (\<le>\<^bsub>R\<^esub>)) (\<le>\<^bsub>R\<^esub>) \<epsilon>"
   using assms by (intro tpdfr.deflationary_on_counitI
     tfr.mono_wrt_rel_leftI flip.tfr.mono_wrt_rel_leftI)
   simp_all
 
 lemma rel_equivalence_on_unitI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>R1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L1\<^esub>)) r1"
   and "rel_equivalence_on (in_field (\<le>\<^bsub>L1\<^esub>)) (\<le>\<^bsub>L1\<^esub>) \<eta>\<^sub>1"
   and "transitive (\<le>\<^bsub>L1\<^esub>)"
   and "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and "((\<le>\<^bsub>R2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>L2\<^esub>)) r2"
   and "rel_equivalence_on (in_field (\<le>\<^bsub>L2\<^esub>)) (\<le>\<^bsub>L2\<^esub>) \<eta>\<^sub>2"
   and "transitive (\<le>\<^bsub>L2\<^esub>)"
   shows "rel_equivalence_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   using assms by (intro tpdfr.rel_equivalence_on_unitI
     tfr.mono_wrt_rel_leftI flip.tfr.mono_wrt_rel_leftI)
   simp_all
 
 lemma order_equivalenceI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R1\<^esub>)) l1 r1"
   and "((\<le>\<^bsub>L2\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R2\<^esub>)) l2 r2"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro tpdfr.order_equivalenceI
     tfr.mono_wrt_rel_leftI flip.tfr.mono_wrt_rel_leftI)
   (auto elim!: tdfrs.t1.preorder_equivalence_order_equivalenceE
     tdfrs.t2.preorder_equivalence_order_equivalenceE)
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Base.thy b/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Base.thy
--- a/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Base.thy
+++ b/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Base.thy
@@ -1,663 +1,663 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 section \<open>Transport for Natural Functors\<close>
 subsection \<open>Basic Setup\<close>
 theory Transport_Natural_Functors_Base
   imports
     HOL.BNF_Def
     HOL_Alignment_Functions
     Transport_Base
 begin
 
 paragraph \<open>Summary\<close>
 text \<open>Basic setup for closure proofs and simple lemmas.\<close>
 
 text \<open>In the following, we willingly use granular apply-style proofs since,
 in practice, these theorems have to be automatically generated whenever we
 declare a new natural functor.
 
 Note that "HOL-Library" provides a command \<open>bnf_axiomatization\<close> which allows
 one to axiomatically declare a bounded natural functor. However, we only need a
 subset of these axioms - the boundedness of the functor is irrelevant for our
 purposes. For this reason - and the sake of completeness - we state all the
 required axioms explicitly below.\<close>
 
 lemma Grp_UNIV_eq_eq_comp: "BNF_Def.Grp UNIV f = (=) \<circ> f"
   by (intro ext) (auto elim: GrpE intro: GrpI)
 
 lemma eq_comp_rel_comp_eq_comp: "(=) \<circ> f \<circ>\<circ> R = R \<circ> f"
   by (intro ext) auto
 
 lemma Domain_Collect_case_prod_eq_Collect_in_dom:
   "Domain {(x, y). R x y} = {x. in_dom R x}"
   by blast
 
 lemma ball_in_dom_iff_ball_ex:
   "(\<forall>x \<in> S. in_dom R x) \<longleftrightarrow> (\<forall>x \<in> S. \<exists>y. R x y)"
   by blast
 
 lemma pair_mem_Collect_case_prod_iff: "(x, y) \<in> {(x, y). R x y} \<longleftrightarrow> R x y"
   by blast
 
 
 paragraph \<open>Natural Functor Axiomatisation\<close>
 
 typedecl ('d, 'a, 'b, 'c) F
 
 consts Fmap :: "('a1 \<Rightarrow> 'a2) \<Rightarrow> ('b1 \<Rightarrow> 'b2) \<Rightarrow> ('c1 \<Rightarrow> 'c2) \<Rightarrow>
     ('d, 'a1, 'b1, 'c1) F \<Rightarrow> ('d, 'a2, 'b2, 'c2) F"
   Fset1 :: "('d, 'a, 'b, 'c) F \<Rightarrow> 'a set"
   Fset2 :: "('d, 'a, 'b, 'c) F \<Rightarrow> 'b set"
   Fset3 :: "('d, 'a, 'b, 'c) F \<Rightarrow> 'c set"
 
 axiomatization
   where Fmap_id: "Fmap id id id = id"
   and Fmap_comp: "\<And>f1 f2 f3 g1 g2 g3.
     Fmap (g1 \<circ> f1) (g2 \<circ> f2) (g3 \<circ> f3) = Fmap g1 g2 g3 \<circ> Fmap f1 f2 f3"
   and Fmap_cong: "\<And>f1 f2 f3 g1 g2 g3 x.
     (\<And>x1. x1 \<in> Fset1 x \<Longrightarrow> f1 x1 = g1 x1) \<Longrightarrow>
     (\<And>x2. x2 \<in> Fset2 x \<Longrightarrow> f2 x2 = g2 x2) \<Longrightarrow>
     (\<And>x3. x3 \<in> Fset3 x \<Longrightarrow> f3 x3 = g3 x3) \<Longrightarrow>
     Fmap f1 f2 f3 x = Fmap g1 g2 g3 x"
   and Fset1_natural: "\<And>f1 f2 f3. Fset1 \<circ> Fmap f1 f2 f3 = image f1 \<circ> Fset1"
   and Fset2_natural: "\<And>f1 f2 f3. Fset2 \<circ> Fmap f1 f2 f3 = image f2 \<circ> Fset2"
   and Fset3_natural: "\<And>f1 f2 f3. Fset3 \<circ> Fmap f1 f2 f3 = image f3 \<circ> Fset3"
 
 lemma Fmap_id_eq_self: "Fmap id id id x = x"
   by (subst Fmap_id, subst id_eq_self, rule refl)
 
 lemma Fmap_comp_eq_Fmap_Fmap:
   "Fmap (g1 \<circ> f1) (g2 \<circ> f2) (g3 \<circ> f3) x = Fmap g1 g2 g3 (Fmap f1 f2 f3 x)"
   by (fact fun_cong[OF Fmap_comp, simplified comp_eq])
 
 lemma Fset1_Fmap_eq_image_Fset1: "Fset1 (Fmap f1 f2 f3 x) = f1 ` Fset1 x"
   by (fact fun_cong[OF Fset1_natural, simplified comp_eq])
 
 lemma Fset2_Fmap_eq_image_Fset2: "Fset2 (Fmap f1 f2 f3 x) = f2 ` Fset2 x"
   by (fact fun_cong[OF Fset2_natural, simplified comp_eq])
 
 lemma Fset3_Fmap_eq_image_Fset3: "Fset3 (Fmap f1 f2 f3 x) = f3 ` Fset3 x"
   by (fact fun_cong[OF Fset3_natural, simplified comp_eq])
 
 lemmas Fset_Fmap_eqs = Fset1_Fmap_eq_image_Fset1 Fset2_Fmap_eq_image_Fset2
   Fset3_Fmap_eq_image_Fset3
 
 paragraph \<open>Relator\<close>
 
 definition Frel :: "('a1 \<Rightarrow> 'a2 \<Rightarrow> bool) \<Rightarrow> ('b1 \<Rightarrow> 'b2 \<Rightarrow> bool) \<Rightarrow> ('c1 \<Rightarrow> 'c2 \<Rightarrow> bool) \<Rightarrow>
   ('d, 'a1, 'b1, 'c1) F \<Rightarrow> ('d, 'a2, 'b2, 'c2) F \<Rightarrow> bool"
   where "Frel R1 R2 R3 x y \<equiv> (\<exists>z.
     z \<in> {x. Fset1 x \<subseteq> {(x, y). R1 x y} \<and> Fset2 x \<subseteq> {(x, y). R2 x y}
       \<and> Fset3 x \<subseteq> {(x, y). R3 x y}}
     \<and> Fmap fst fst fst z = x
     \<and> Fmap snd snd snd z = y)"
 
 lemma FrelI:
   assumes "Fset1 z \<subseteq> {(x, y). R1 x y}"
   and "Fset2 z \<subseteq> {(x, y). R2 x y}"
   and "Fset3 z \<subseteq> {(x, y). R3 x y}"
   and "Fmap fst fst fst z = x"
   and "Fmap snd snd snd z = y"
   shows "Frel R1 R2 R3 x y"
   apply (subst Frel_def)
   apply (intro exI conjI CollectI)
   apply (fact assms)+
   done
 
 lemma FrelE:
   assumes "Frel R1 R2 R3 x y"
   obtains z where "Fset1 z \<subseteq> {(x, y). R1 x y}" "Fset2 z \<subseteq> {(x, y). R2 x y}"
     "Fset3 z \<subseteq> {(x, y). R3 x y}" "Fmap fst fst fst z = x" "Fmap snd snd snd z = y"
   apply (insert assms)
   apply (subst (asm) Frel_def)
   apply (elim exE CollectE conjE)
   apply assumption
   done
 
 lemma Grp_UNIV_Fmap_eq_Frel_Grp: "BNF_Def.Grp UNIV (Fmap f1 f2 f3) =
   Frel (BNF_Def.Grp UNIV f1) (BNF_Def.Grp UNIV f2) (BNF_Def.Grp UNIV f3)"
   apply (intro ext iffI)
     apply (rule FrelI[where
       ?z="Fmap (BNF_Def.convol id f1) (BNF_Def.convol id f2) (BNF_Def.convol id f3) _"])
     apply (subst Fset_Fmap_eqs,
       rule image_subsetI,
       rule convol_mem_GrpI[simplified Fun_id_eq_id],
       rule UNIV_I)+
     apply (unfold Fmap_comp_eq_Fmap_Fmap[symmetric]
       fst_convol[simplified Fun_comp_eq_comp]
       snd_convol[simplified Fun_comp_eq_comp]
       Fmap_id id_eq_self)
     apply (rule refl)
     apply (subst (asm) Grp_UNIV_eq_eq_comp)
     apply (subst (asm) comp_eq)
     apply assumption
     apply (erule FrelE)
     apply hypsubst
     apply (subst Grp_UNIV_eq_eq_comp)
     apply (subst comp_eq)
     apply (subst Fmap_comp_eq_Fmap_Fmap[symmetric])
     apply (rule Fmap_cong;
       rule Collect_case_prod_Grp_eqD[simplified Fun_comp_eq_comp],
       drule rev_subsetD,
       assumption+)
   done
 
 lemma Frel_Grp_UNIV_Fmap:
   "Frel (BNF_Def.Grp UNIV f1) (BNF_Def.Grp UNIV f2) (BNF_Def.Grp UNIV f3)
     x (Fmap f1 f2 f3 x)"
   apply (subst Grp_UNIV_Fmap_eq_Frel_Grp[symmetric])
   apply (subst Grp_UNIV_eq_eq_comp)
   apply (subst comp_eq)
   apply (rule refl)
   done
 
 lemma Frel_Grp_UNIV_iff_eq_Fmap:
   "Frel (BNF_Def.Grp UNIV f1) (BNF_Def.Grp UNIV f2) (BNF_Def.Grp UNIV f3) x y \<longleftrightarrow>
     (y = Fmap f1 f2 f3 x)"
   by (subst eq_commute[of y])
   (fact fun_cong[OF fun_cong[OF Grp_UNIV_Fmap_eq_Frel_Grp],
     simplified Grp_UNIV_eq_eq_comp comp_eq, folded Grp_UNIV_eq_eq_comp, symmetric])
 
 lemma Frel_eq: "Frel (=) (=) (=) = (=)"
   apply (unfold BNF_Def.eq_alt[simplified Fun_id_eq_id])
   apply (subst Grp_UNIV_Fmap_eq_Frel_Grp[symmetric])
   apply (subst Fmap_id)
   apply (fold BNF_Def.eq_alt[simplified Fun_id_eq_id])
   apply (rule refl)
   done
 
 corollary Frel_eq_self: "Frel (=) (=) (=) x x"
   by (fact iffD2[OF fun_cong[OF fun_cong[OF Frel_eq]] refl])
 
 lemma Frel_mono_strong:
   assumes "Frel R1 R2 R3 x y"
   and "\<And>x1 y1. x1 \<in> Fset1 x \<Longrightarrow> y1 \<in> Fset1 y \<Longrightarrow> R1 x1 y1 \<Longrightarrow> S1 x1 y1"
   and "\<And>x2 y2. x2 \<in> Fset2 x \<Longrightarrow> y2 \<in> Fset2 y \<Longrightarrow> R2 x2 y2 \<Longrightarrow> S2 x2 y2"
   and "\<And>x3 y3. x3 \<in> Fset3 x \<Longrightarrow> y3 \<in> Fset3 y \<Longrightarrow> R3 x3 y3 \<Longrightarrow> S3 x3 y3"
   shows "Frel S1 S2 S3 x y"
   apply (insert assms(1))
   apply (erule FrelE)
   apply (rule FrelI)
     apply (rule subsetI,
       frule rev_subsetD,
       assumption,
       frule imageI[of _ "Fset1 _" fst]
         imageI[of _ "Fset2 _" fst]
         imageI[of _ "Fset3 _" fst],
       drule imageI[of _ "Fset1 _" snd]
         imageI[of _ "Fset2 _" snd]
         imageI[of _ "Fset3 _" snd],
       (subst (asm) Fset_Fmap_eqs[symmetric])+,
       intro CollectI case_prodI2,
       rule assms;
       hypsubst,
       unfold fst_conv snd_conv,
       (elim CollectE case_prodE Pair_inject, hypsubst)?,
       assumption)+
     apply assumption+
   done
 
 corollary Frel_mono:
   assumes "R1 \<le> S1" "R2 \<le> S2" "R3 \<le> S3"
   shows "Frel R1 R2 R3 \<le> Frel S1 S2 S3"
   apply (intro le_relI)
   apply (rule Frel_mono_strong)
     apply assumption
     apply (insert assms)
     apply (drule le_relD[OF assms(1)] le_relD[OF assms(2)] le_relD[OF assms(3)],
       assumption)+
   done
 
 lemma Frel_refl_strong:
   assumes "\<And>x1. x1 \<in> Fset1 x \<Longrightarrow> R1 x1 x1"
   and "\<And>x2. x2 \<in> Fset2 x \<Longrightarrow> R2 x2 x2"
   and "\<And>x3. x3 \<in> Fset3 x \<Longrightarrow> R3 x3 x3"
   shows "Frel R1 R2 R3 x x"
   by (rule Frel_mono_strong[OF Frel_eq_self[of x]];
     drule assms, hypsubst, assumption)
 
 lemma Frel_cong:
   assumes "\<And>x1 y1. x1 \<in> Fset1 x \<Longrightarrow> y1 \<in> Fset1 y \<Longrightarrow> R1 x1 y1 \<longleftrightarrow> R1' x1 y1"
   and "\<And>x2 y2. x2 \<in> Fset2 x \<Longrightarrow> y2 \<in> Fset2 y \<Longrightarrow> R2 x2 y2 \<longleftrightarrow> R2' x2 y2"
   and "\<And>x3 y3. x3 \<in> Fset3 x \<Longrightarrow> y3 \<in> Fset3 y \<Longrightarrow> R3 x3 y3 \<longleftrightarrow> R3' x3 y3"
   shows "Frel R1 R2 R3 x y = Frel R1' R2' R3' x y"
   by (rule iffI;
     rule Frel_mono_strong,
     assumption;
     rule iffD1[OF assms(1)] iffD1[OF assms(2)] iffD1[OF assms(3)]
       iffD2[OF assms(1)] iffD2[OF assms(2)] iffD2[OF assms(3)];
     assumption)
 
 lemma Frel_rel_inv_eq_rel_inv_Frel: "Frel R1\<inverse> R2\<inverse> R3\<inverse> = (Frel R1 R2 R3)\<inverse>"
   by (intro ext iffI;
     unfold rel_inv_iff_rel,
     erule FrelE,
     hypsubst,
     rule FrelI[where ?z="Fmap prod.swap prod.swap prod.swap _"];
       ((subst Fset_Fmap_eqs,
       rule image_subsetI,
       drule rev_subsetD,
       assumption,
       elim CollectE case_prodE,
       hypsubst,
       subst swap_simp,
       subst pair_mem_Collect_case_prod_iff,
       assumption) |
       (subst Fmap_comp_eq_Fmap_Fmap[symmetric],
         rule Fmap_cong;
         unfold comp_eq fst_swap snd_swap,
         rule refl)))
 
 text \<open>Given the former axioms, the following axiom - subdistributivity of the
 relator - is equivalent to the (F, Fmap) functor preserving weak pullbacks.\<close>
 
 axiomatization
   where Frel_comp_le_Frel_rel_comp: "\<And>R1 R2 R3 S1 S2 S3.
     Frel R1 R2 R3 \<circ>\<circ> Frel S1 S2 S3 \<le> Frel (R1 \<circ>\<circ> S1) (R2 \<circ>\<circ> S2) (R3 \<circ>\<circ> S3)"
 
 lemma fst_sndOp_eq_snd_fstOp: "fst \<circ> BNF_Def.sndOp P Q = snd \<circ> BNF_Def.fstOp P Q"
   unfolding fstOp_def sndOp_def by (intro ext) simp
 
 lemma Frel_rel_comp_le_Frel_comp:
   "Frel (R1 \<circ>\<circ> S1) (R2 \<circ>\<circ> S2) (R3 \<circ>\<circ> S3) \<le> (Frel R1 R2 R3 \<circ>\<circ> Frel S1 S2 S3)"
   apply (rule le_relI)
   apply (erule FrelE)
   apply (rule rel_compI[where ?y="Fmap (snd \<circ> BNF_Def.fstOp R1 S1)
     (snd \<circ> BNF_Def.fstOp R2 S2) (snd \<circ> BNF_Def.fstOp R3 S3) _"])
   apply (rule FrelI[where ?z="Fmap (BNF_Def.fstOp R1 S1)
     (BNF_Def.fstOp R2 S2) (BNF_Def.fstOp R3 S3) _"])
     apply (subst Fset_Fmap_eqs,
       intro image_subsetI,
       rule fstOp_in[unfolded relcompp_eq_rel_comp],
       drule rev_subsetD,
       assumption+)+
     apply (subst Fmap_comp_eq_Fmap_Fmap[symmetric])
     apply (fold ext[of fst "fst \<circ> _", OF fst_fstOp[unfolded Fun_comp_eq_comp]])
     apply hypsubst
     apply (rule refl)
     apply (subst Fmap_comp_eq_Fmap_Fmap[symmetric])
     apply (rule refl)
     apply (rule FrelI[where ?z="Fmap (BNF_Def.sndOp R1 S1)
       (BNF_Def.sndOp R2 S2) (BNF_Def.sndOp R3 S3) _"])
     apply (subst Fset_Fmap_eqs,
       intro image_subsetI,
       rule sndOp_in[unfolded relcompp_eq_rel_comp],
       drule rev_subsetD,
       assumption+)+
     apply (subst Fmap_comp_eq_Fmap_Fmap[symmetric])
     apply (unfold fst_sndOp_eq_snd_fstOp)
     apply (rule refl)
     apply (subst Fmap_comp_eq_Fmap_Fmap[symmetric])
     apply (fold ext[of snd "snd \<circ> _", OF snd_sndOp[unfolded Fun_comp_eq_comp]])
     apply hypsubst
     apply (rule refl)
   done
 
 corollary Frel_comp_eq_Frel_rel_comp:
   "Frel R1 R2 R3 \<circ>\<circ> Frel S1 S2 S3 = Frel (R1 \<circ>\<circ> S1) (R2 \<circ>\<circ> S2) (R3 \<circ>\<circ> S3)"
   by (rule antisym; rule Frel_comp_le_Frel_rel_comp Frel_rel_comp_le_Frel_comp)
 
 lemma Frel_Fmap_eq1: "Frel R1 R2 R3 (Fmap f1 f2 f3 x) y =
   Frel (\<lambda>x. R1 (f1 x)) (\<lambda>x. R2 (f2 x)) (\<lambda>x. R3 (f3 x)) x y"
   apply (rule iffI)
     apply (fold comp_eq[of R1] comp_eq[of R2] comp_eq[of R3])
     apply (drule rel_compI[where ?R="Frel _ _ _" and ?S="Frel _ _ _",
       OF Frel_Grp_UNIV_Fmap])
     apply (unfold Grp_UNIV_eq_eq_comp)
     apply (drule le_relD[OF Frel_comp_le_Frel_rel_comp])
     apply (unfold eq_comp_rel_comp_eq_comp)
     apply assumption
     apply (fold eq_comp_rel_comp_eq_comp[where ?R=R1]
       eq_comp_rel_comp_eq_comp[where ?R=R2]
       eq_comp_rel_comp_eq_comp[where ?R=R3]
       Grp_UNIV_eq_eq_comp)
     apply (drule le_relD[OF Frel_rel_comp_le_Frel_comp])
     apply (erule rel_compE)
     apply (subst (asm) Frel_Grp_UNIV_iff_eq_Fmap)
     apply hypsubst
     apply assumption
   done
 
 lemma Frel_Fmap_eq2: "Frel R1 R2 R3 x (Fmap g1 g2 g3 y) =
   Frel (\<lambda>x y. R1 x (g1 y)) (\<lambda>x y. R2 x (g2 y)) (\<lambda>x y. R3 x (g3 y)) x y"
   apply (subst rel_inv_iff_rel[of "Frel _ _ _", symmetric])
   apply (subst Frel_rel_inv_eq_rel_inv_Frel[symmetric])
   apply (subst Frel_Fmap_eq1)
   apply (rule sym)
   apply (subst rel_inv_iff_rel[of "Frel _ _ _", symmetric])
   apply (subst Frel_rel_inv_eq_rel_inv_Frel[symmetric])
   apply (unfold rel_inv_iff_rel)
   apply (rule refl)
   done
 
 lemmas Frel_Fmap_eqs = Frel_Fmap_eq1 Frel_Fmap_eq2
 
 
 paragraph \<open>Predicator\<close>
 
 definition Fpred :: "('a \<Rightarrow> bool) \<Rightarrow> ('b \<Rightarrow> bool) \<Rightarrow> ('c \<Rightarrow> bool) \<Rightarrow>
   ('d, 'a, 'b, 'c) F \<Rightarrow> bool"
   where "Fpred P1 P2 P3 x \<equiv> Frel ((=)\<restriction>\<^bsub>P1\<^esub>) ((=)\<restriction>\<^bsub>P2\<^esub>) ((=)\<restriction>\<^bsub>P3\<^esub>) x x"
 
 lemma Fpred_mono_strong:
   assumes "Fpred P1 P2 P3 x"
   and "\<And>x1. x1 \<in> Fset1 x \<Longrightarrow> P1 x1 \<Longrightarrow> Q1 x1"
   and "\<And>x2. x2 \<in> Fset2 x \<Longrightarrow> P2 x2 \<Longrightarrow> Q2 x2"
   and "\<And>x3. x3 \<in> Fset3 x \<Longrightarrow> P3 x3 \<Longrightarrow> Q3 x3"
   shows "Fpred Q1 Q2 Q3 x"
   apply (insert assms(1))
   apply (unfold Fpred_def)
   apply (rule Frel_mono_strong,
     assumption;
-    erule restrict_leftE,
-    rule restrict_leftI,
+    erule bin_rel_restrict_leftE,
+    rule bin_rel_restrict_leftI,
     assumption,
     rule assms,
     assumption+)
   done
 
 lemma Fpred_top: "Fpred \<top> \<top> \<top> x"
   apply (subst Fpred_def)
   apply (rule Frel_refl_strong;
-    subst restrict_left_top_eq,
+    subst bin_rel_restrict_left_top_eq,
     rule refl)
   done
 
 lemma FpredI:
   assumes "\<And>x1. x1 \<in> Fset1 x \<Longrightarrow> P1 x1"
   and "\<And>x2. x2 \<in> Fset2 x \<Longrightarrow> P2 x2"
   and "\<And>x3. x3 \<in> Fset3 x \<Longrightarrow> P3 x3"
   shows "Fpred P1 P2 P3 x"
   using assms by (rule Fpred_mono_strong[OF Fpred_top])
 
 lemma FpredE:
   assumes "Fpred P1 P2 P3 x"
   obtains "\<And>x1. x1 \<in> Fset1 x \<Longrightarrow> P1 x1"
     "\<And>x2. x2 \<in> Fset2 x \<Longrightarrow> P2 x2"
     "\<And>x3. x3 \<in> Fset3 x \<Longrightarrow> P3 x3"
   by (elim meta_impE; (assumption |
     insert assms,
     subst (asm) Fpred_def,
     erule FrelE,
     hypsubst,
     subst (asm) Fset_Fmap_eqs,
     subst (asm) Domain_fst[symmetric],
     drule rev_subsetD,
     rule Domain_mono,
     assumption,
-    unfold Domain_Collect_case_prod_eq_Collect_in_dom in_dom_restrict_left_eq,
+    unfold Domain_Collect_case_prod_eq_Collect_in_dom in_dom_bin_rel_restrict_left_eq,
     elim CollectE inf1E,
     assumption))
 
 lemma Fpred_eq_ball: "Fpred P1 P2 P3 =
   (\<lambda>x. Ball (Fset1 x) P1 \<and> Ball (Fset2 x) P2 \<and> Ball (Fset3 x) P3)"
   by (intro ext iffI conjI ballI FpredI; elim FpredE conjE bspec)
 
 lemma Fpred_Fmap_eq:
   "Fpred P1 P2 P3 (Fmap f1 f2 f3 x) = Fpred (P1 \<circ> f1) (P2 \<circ> f2) (P3 \<circ> f3) x"
   by (unfold Fpred_def Frel_Fmap_eqs)
   (rule iffI;
     erule FrelE,
     hypsubst,
     unfold Frel_Fmap_eqs,
     rule Frel_refl_strong;
-    rule restrict_leftI,
+    rule bin_rel_restrict_leftI,
     rule refl,
     drule rev_subsetD,
     assumption,
-    elim CollectE case_prodE restrict_leftE,
+    elim CollectE case_prodE bin_rel_restrict_leftE,
     hypsubst,
     unfold comp_eq fst_conv,
     assumption)
 
 lemma Fpred_in_dom_if_in_dom_Frel:
   assumes "in_dom (Frel R1 R2 R3) x"
   shows "Fpred (in_dom R1) (in_dom R2) (in_dom R3) x"
   apply (insert assms)
   apply (elim in_domE FrelE)
   apply hypsubst
   apply (subst Fpred_Fmap_eq)
   apply (rule FpredI;
     drule rev_subsetD,
     assumption,
     elim CollectE case_prodE,
     hypsubst,
     unfold comp_eq fst_conv,
     rule in_domI,
     assumption)
   done
 
 lemma in_dom_Frel_if_Fpred_in_dom:
   assumes "Fpred (in_dom R1) (in_dom R2) (in_dom R3) x"
   shows "in_dom (Frel R1 R2 R3) x"
   apply (insert assms)
   apply (subst (asm) Fpred_eq_ball)
   apply (elim conjE)
   apply (subst (asm) ball_in_dom_iff_ball_ex,
     drule bchoice, \<comment>\<open>requires the axiom of choice.\<close>
     erule exE)+
   apply (rule in_domI[where ?x=x and ?y="Fmap _ _ _ x" for x])
   apply (subst Frel_Fmap_eq2)
   apply (rule Frel_refl_strong)
   apply (drule bspec[of "Fset1 _"])
   apply assumption+
   apply (drule bspec[of "Fset2 _"])
   apply assumption+
   apply (drule bspec[of "Fset3 _"])
   apply assumption+
   done
 
 lemma in_dom_Frel_eq_Fpred_in_dom:
   "in_dom (Frel R1 R2 R3) = Fpred (in_dom R1) (in_dom R2) (in_dom R3)"
   by (intro ext iffI; rule Fpred_in_dom_if_in_dom_Frel in_dom_Frel_if_Fpred_in_dom)
 
 lemma in_codom_Frel_eq_Fpred_in_codom:
   "in_codom (Frel R1 R2 R3) = Fpred (in_codom R1) (in_codom R2) (in_codom R3)"
   apply (subst in_dom_rel_inv_eq_in_codom[symmetric])
   apply (subst Frel_rel_inv_eq_rel_inv_Frel[symmetric])
   apply (subst in_dom_Frel_eq_Fpred_in_dom)
   apply (subst in_dom_rel_inv_eq_in_codom)+
   apply (rule refl)
   done
 
 lemma in_field_Frel_eq_Fpred_in_in_field:
   "in_field (Frel R1 R2 R3) =
     Fpred (in_dom R1) (in_dom R2) (in_dom R3) \<squnion>
     Fpred (in_codom R1) (in_codom R2) (in_codom R3)"
   apply (subst in_field_eq_in_dom_sup_in_codom)
   apply (subst in_dom_Frel_eq_Fpred_in_dom)
   apply (subst in_codom_Frel_eq_Fpred_in_codom)
   apply (rule refl)
   done
 
 lemma Frel_restrict_left_Fpred_eq_Frel_restrict_left:
   fixes R1 :: "'a1 \<Rightarrow> 'a2 \<Rightarrow> bool"
   and R2 :: "'b1 \<Rightarrow> 'b2 \<Rightarrow> bool"
   and R3 :: "'c1 \<Rightarrow> 'c2 \<Rightarrow> bool"
   and P1 :: "'a1 \<Rightarrow> bool"
   and P2 :: "'b1 \<Rightarrow> bool"
   and P3 :: "'c1 \<Rightarrow> bool"
   shows "(Frel R1 R2 R3 :: ('d, 'a1, 'b1, 'c1) F \<Rightarrow> _)\<restriction>\<^bsub>Fpred P1 P2 P3 :: ('d, 'a1, 'b1, 'c1) F \<Rightarrow> _\<^esub> =
     Frel (R1\<restriction>\<^bsub>P1\<^esub>) (R2\<restriction>\<^bsub>P2\<^esub>) (R3\<restriction>\<^bsub>P3\<^esub>)"
   apply (intro ext)
   apply (rule iffI)
-    apply (erule restrict_leftE)
+    apply (erule bin_rel_restrict_leftE)
     apply (elim FpredE)
     apply (rule Frel_mono_strong,
       assumption;
-      rule restrict_leftI,
+      rule bin_rel_restrict_leftI,
       assumption+)
-    apply (rule restrict_leftI)
+    apply (rule bin_rel_restrict_leftI)
       apply (rule Frel_mono_strong,
         assumption;
-        erule restrict_leftE,
+        erule bin_rel_restrict_leftE,
         assumption)
       apply (drule in_domI[of "Frel (R1\<restriction>\<^bsub>P1\<^esub>) (R2\<restriction>\<^bsub>P2\<^esub>) (R3\<restriction>\<^bsub>P3\<^esub>)"])
       apply (drule Fpred_in_dom_if_in_dom_Frel)
       apply (rule Fpred_mono_strong,
         assumption;
-        unfold in_dom_restrict_left_eq inf_apply inf_bool_def;
+        unfold in_dom_bin_rel_restrict_left_eq inf_apply inf_bool_def;
         rule conjunct2,
         assumption)
   done
 
 lemma Frel_restrict_right_Fpred_eq_Frel_restrict_right:
   fixes R1 :: "'a1 \<Rightarrow> 'a2 \<Rightarrow> bool"
   and R2 :: "'b1 \<Rightarrow> 'b2 \<Rightarrow> bool"
   and R3 :: "'c1 \<Rightarrow> 'c2 \<Rightarrow> bool"
   and P1 :: "'a2 \<Rightarrow> bool"
   and P2 :: "'b2 \<Rightarrow> bool"
   and P3 :: "'c2 \<Rightarrow> bool"
   shows "(Frel R1 R2 R3 :: _ \<Rightarrow> ('d, 'a2, 'b2, 'c2) F \<Rightarrow> _)\<upharpoonleft>\<^bsub>Fpred P1 P2 P3 :: ('d, 'a2, 'b2, 'c2) F \<Rightarrow> _\<^esub> =
     Frel (R1\<upharpoonleft>\<^bsub>P1\<^esub>) (R2\<upharpoonleft>\<^bsub>P2\<^esub>) (R3\<upharpoonleft>\<^bsub>P3\<^esub>)"
-  apply (subst restrict_right_eq)
+  apply (subst bin_rel_restrict_right_eq)
   apply (subst Frel_rel_inv_eq_rel_inv_Frel[symmetric])
   apply (subst Frel_restrict_left_Fpred_eq_Frel_restrict_left)
   apply (subst Frel_rel_inv_eq_rel_inv_Frel[symmetric])
-  apply (fold restrict_right_eq)
+  apply (fold bin_rel_restrict_right_eq)
   apply (rule refl)
   done
 
 locale transport_natural_functor =
   t1 : transport L1 R1 l1 r1 + t2 : transport L2 R2 l2 r2 +
   t3 : transport L3 R3 l3 r3
   for L1 :: "'a1 \<Rightarrow> 'a1 \<Rightarrow> bool"
   and R1 :: "'b1 \<Rightarrow> 'b1 \<Rightarrow> bool"
   and l1 :: "'a1 \<Rightarrow> 'b1"
   and r1 :: "'b1 \<Rightarrow> 'a1"
   and L2 :: "'a2 \<Rightarrow> 'a2 \<Rightarrow> bool"
   and R2 :: "'b2 \<Rightarrow> 'b2 \<Rightarrow> bool"
   and l2 :: "'a2 \<Rightarrow> 'b2"
   and r2 :: "'b2 \<Rightarrow> 'a2"
   and L3 :: "'a3 \<Rightarrow> 'a3 \<Rightarrow> bool"
   and R3 :: "'b3 \<Rightarrow> 'b3 \<Rightarrow> bool"
   and l3 :: "'a3 \<Rightarrow> 'b3"
   and r3 :: "'b3 \<Rightarrow> 'a3"
 begin
 
 notation L1 (infix "\<le>\<^bsub>L1\<^esub>" 50)
 notation R1 (infix "\<le>\<^bsub>R1\<^esub>" 50)
 notation L2 (infix "\<le>\<^bsub>L2\<^esub>" 50)
 notation R2 (infix "\<le>\<^bsub>R2\<^esub>" 50)
 notation L3 (infix "\<le>\<^bsub>L3\<^esub>" 50)
 notation R3 (infix "\<le>\<^bsub>R3\<^esub>" 50)
 
 notation t1.ge_left (infix "\<ge>\<^bsub>L1\<^esub>" 50)
 notation t1.ge_right (infix "\<ge>\<^bsub>R1\<^esub>" 50)
 notation t2.ge_left (infix "\<ge>\<^bsub>L2\<^esub>" 50)
 notation t2.ge_right (infix "\<ge>\<^bsub>R2\<^esub>" 50)
 notation t3.ge_left (infix "\<ge>\<^bsub>L3\<^esub>" 50)
 notation t3.ge_right (infix "\<ge>\<^bsub>R3\<^esub>" 50)
 
 notation t1.left_Galois (infix "\<^bsub>L1\<^esub>\<lessapprox>" 50)
 notation t1.right_Galois (infix "\<^bsub>R1\<^esub>\<lessapprox>" 50)
 notation t2.left_Galois (infix "\<^bsub>L2\<^esub>\<lessapprox>" 50)
 notation t2.right_Galois (infix "\<^bsub>R2\<^esub>\<lessapprox>" 50)
 notation t3.left_Galois (infix "\<^bsub>L3\<^esub>\<lessapprox>" 50)
 notation t3.right_Galois (infix "\<^bsub>R3\<^esub>\<lessapprox>" 50)
 
 notation t1.ge_Galois_left (infix "\<greaterapprox>\<^bsub>L1\<^esub>" 50)
 notation t1.ge_Galois_right (infix "\<greaterapprox>\<^bsub>R1\<^esub>" 50)
 notation t2.ge_Galois_left (infix "\<greaterapprox>\<^bsub>L2\<^esub>" 50)
 notation t2.ge_Galois_right (infix "\<greaterapprox>\<^bsub>R2\<^esub>" 50)
 notation t3.ge_Galois_left (infix "\<greaterapprox>\<^bsub>L3\<^esub>" 50)
 notation t3.ge_Galois_right (infix "\<greaterapprox>\<^bsub>R3\<^esub>" 50)
 
 notation t1.right_ge_Galois (infix "\<^bsub>R1\<^esub>\<greaterapprox>" 50)
 notation t1.Galois_right (infix "\<lessapprox>\<^bsub>R1\<^esub>" 50)
 notation t2.right_ge_Galois (infix "\<^bsub>R2\<^esub>\<greaterapprox>" 50)
 notation t2.Galois_right (infix "\<lessapprox>\<^bsub>R2\<^esub>" 50)
 notation t3.right_ge_Galois (infix "\<^bsub>R3\<^esub>\<greaterapprox>" 50)
 notation t3.Galois_right (infix "\<lessapprox>\<^bsub>R3\<^esub>" 50)
 
 notation t1.left_ge_Galois (infix "\<^bsub>L1\<^esub>\<greaterapprox>" 50)
 notation t1.Galois_left (infix "\<lessapprox>\<^bsub>L1\<^esub>" 50)
 notation t2.left_ge_Galois (infix "\<^bsub>L2\<^esub>\<greaterapprox>" 50)
 notation t2.Galois_left (infix "\<lessapprox>\<^bsub>L2\<^esub>" 50)
 notation t3.left_ge_Galois (infix "\<^bsub>L3\<^esub>\<greaterapprox>" 50)
 notation t3.Galois_left (infix "\<lessapprox>\<^bsub>L3\<^esub>" 50)
 
 notation t1.unit ("\<eta>\<^sub>1")
 notation t1.counit ("\<epsilon>\<^sub>1")
 notation t2.unit ("\<eta>\<^sub>2")
 notation t2.counit ("\<epsilon>\<^sub>2")
 notation t3.unit ("\<eta>\<^sub>3")
 notation t3.counit ("\<epsilon>\<^sub>3")
 
 definition "L \<equiv> Frel (\<le>\<^bsub>L1\<^esub>) (\<le>\<^bsub>L2\<^esub>) (\<le>\<^bsub>L3\<^esub>)"
 
 lemma left_rel_eq_Frel: "L = Frel (\<le>\<^bsub>L1\<^esub>) (\<le>\<^bsub>L2\<^esub>) (\<le>\<^bsub>L3\<^esub>)"
   unfolding L_def ..
 
 definition "l \<equiv> Fmap l1 l2 l3"
 
 lemma left_eq_Fmap: "l = Fmap l1 l2 l3"
   unfolding l_def ..
 
 context
 begin
 
 interpretation flip :
   transport_natural_functor R1 L1 r1 l1 R2 L2 r2 l2 R3 L3 r3 l3 .
 
 abbreviation "R \<equiv> flip.L"
 abbreviation "r \<equiv> flip.l"
 
 lemma right_rel_eq_Frel: "R = Frel (\<le>\<^bsub>R1\<^esub>) (\<le>\<^bsub>R2\<^esub>) (\<le>\<^bsub>R3\<^esub>)"
   unfolding flip.left_rel_eq_Frel ..
 
 lemma right_eq_Fmap: "r = Fmap r1 r2 r3"
   unfolding flip.left_eq_Fmap ..
 
 lemmas transport_defs = left_rel_eq_Frel left_eq_Fmap
   right_rel_eq_Frel right_eq_Fmap
 
 end
 
 sublocale transport L R l r .
 
 (*FIXME: somehow the notation for the fixed parameters L and R, defined in
 Order_Functions_Base.thy, is lost. We hence re-declare it here.*)
 notation L (infix "\<le>\<^bsub>L\<^esub>" 50)
 notation R (infix "\<le>\<^bsub>R\<^esub>" 50)
 
 lemma unit_eq_Fmap: "\<eta> = Fmap \<eta>\<^sub>1 \<eta>\<^sub>2 \<eta>\<^sub>3"
   unfolding unit_eq_comp by (simp only: right_eq_Fmap left_eq_Fmap
     flip: Fmap_comp t1.unit_eq_comp t2.unit_eq_comp t3.unit_eq_comp)
 
 interpretation flip_inv : transport_natural_functor "(\<ge>\<^bsub>R1\<^esub>)" "(\<ge>\<^bsub>L1\<^esub>)" r1 l1
   "(\<ge>\<^bsub>R2\<^esub>)" "(\<ge>\<^bsub>L2\<^esub>)" r2 l2 "(\<ge>\<^bsub>R3\<^esub>)" "(\<ge>\<^bsub>L3\<^esub>)" r3 l3
   rewrites "flip_inv.unit \<equiv> \<epsilon>" and "flip_inv.t1.unit \<equiv> \<epsilon>\<^sub>1"
   and "flip_inv.t2.unit \<equiv> \<epsilon>\<^sub>2" and "flip_inv.t3.unit \<equiv> \<epsilon>\<^sub>3"
   by (simp_all only: order_functors.flip_counit_eq_unit)
 
 lemma counit_eq_Fmap: "\<epsilon> = Fmap \<epsilon>\<^sub>1 \<epsilon>\<^sub>2 \<epsilon>\<^sub>3"
   by (fact flip_inv.unit_eq_Fmap)
 
 lemma flip_inv_right_eq_ge_left: "flip_inv.R = (\<ge>\<^bsub>L\<^esub>)"
   unfolding left_rel_eq_Frel flip_inv.right_rel_eq_Frel
   by (fact Frel_rel_inv_eq_rel_inv_Frel)
 
 interpretation flip :
   transport_natural_functor R1 L1 r1 l1 R2 L2 r2 l2 R3 L3 r3 l3 .
 
 lemma flip_inv_left_eq_ge_right: "flip_inv.L \<equiv> (\<ge>\<^bsub>R\<^esub>)"
   unfolding flip.flip_inv_right_eq_ge_left .
 
 lemma mono_wrt_rel_leftI:
   assumes "((\<le>\<^bsub>L1\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R1\<^esub>)) l1"
   and "((\<le>\<^bsub>L2\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R2\<^esub>)) l2"
   and "((\<le>\<^bsub>L3\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R3\<^esub>)) l3"
   shows "((\<le>\<^bsub>L\<^esub>) \<Rrightarrow>\<^sub>m (\<le>\<^bsub>R\<^esub>)) l"
   apply (unfold left_rel_eq_Frel right_rel_eq_Frel left_eq_Fmap)
   apply (rule dep_mono_wrt_relI)
   apply (unfold Frel_Fmap_eqs)
   apply (fold rel_map_eq)
   apply (rule le_relD[OF Frel_mono])
     apply (subst mono_wrt_rel_iff_le_rel_map[symmetric], rule assms)+
     apply assumption
   done
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Galois_Relator.thy b/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Galois_Relator.thy
--- a/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Galois_Relator.thy
+++ b/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Galois_Relator.thy
@@ -1,55 +1,55 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Galois Relator\<close>
 theory Transport_Natural_Functors_Galois_Relator
   imports
     Transport_Natural_Functors_Base
 begin
 
 context transport_natural_functor
 begin
 
 lemma left_Galois_Frel_left_Galois: "(\<^bsub>L\<^esub>\<lessapprox>) \<le> Frel (\<^bsub>L1\<^esub>\<lessapprox>) (\<^bsub>L2\<^esub>\<lessapprox>) (\<^bsub>L3\<^esub>\<lessapprox>)"
   apply (rule le_relI)
   apply (erule left_GaloisE)
   apply (unfold left_rel_eq_Frel right_rel_eq_Frel right_eq_Fmap)
   apply (subst (asm) in_codom_Frel_eq_Fpred_in_codom)
   apply (erule FpredE)
   apply (subst (asm) Frel_Fmap_eq2)
   apply (rule Frel_mono_strong,
     assumption;
     rule t1.left_GaloisI t2.left_GaloisI t3.left_GaloisI;
     assumption)
   done
 
 lemma Frel_left_Galois_le_left_Galois:
   "Frel (\<^bsub>L1\<^esub>\<lessapprox>) (\<^bsub>L2\<^esub>\<lessapprox>) (\<^bsub>L3\<^esub>\<lessapprox>) \<le> (\<^bsub>L\<^esub>\<lessapprox>)"
   apply (rule le_relI)
   apply (unfold t1.left_Galois_iff_in_codom_and_left_rel_right
     t2.left_Galois_iff_in_codom_and_left_rel_right
     t3.left_Galois_iff_in_codom_and_left_rel_right)
   apply (fold
-    restrict_right_eq[of "\<lambda>x y. x \<le>\<^bsub>L1\<^esub> r1 y" "in_codom (\<le>\<^bsub>R1\<^esub>)",
-      unfolded restrict_left_pred_def rel_inv_iff_rel]
-    restrict_right_eq[of "\<lambda>x y. x \<le>\<^bsub>L2\<^esub> r2 y" "in_codom (\<le>\<^bsub>R2\<^esub>)",
-      unfolded restrict_left_pred_def rel_inv_iff_rel]
-    restrict_right_eq[of "\<lambda>x y. x \<le>\<^bsub>L3\<^esub> r3 y" "in_codom (\<le>\<^bsub>R3\<^esub>)",
-      unfolded restrict_left_pred_def rel_inv_iff_rel])
+    bin_rel_restrict_right_eq[of "\<lambda>x y. x \<le>\<^bsub>L1\<^esub> r1 y" "in_codom (\<le>\<^bsub>R1\<^esub>)",
+      unfolded bin_rel_restrict_left_pred_def rel_inv_iff_rel]
+    bin_rel_restrict_right_eq[of "\<lambda>x y. x \<le>\<^bsub>L2\<^esub> r2 y" "in_codom (\<le>\<^bsub>R2\<^esub>)",
+      unfolded bin_rel_restrict_left_pred_def rel_inv_iff_rel]
+    bin_rel_restrict_right_eq[of "\<lambda>x y. x \<le>\<^bsub>L3\<^esub> r3 y" "in_codom (\<le>\<^bsub>R3\<^esub>)",
+      unfolded bin_rel_restrict_left_pred_def rel_inv_iff_rel])
   apply (subst (asm) Frel_restrict_right_Fpred_eq_Frel_restrict_right[symmetric])
-  apply (erule restrict_rightE)
+  apply (erule bin_rel_restrict_rightE)
   apply (subst (asm) in_codom_Frel_eq_Fpred_in_codom[symmetric])
   apply (erule in_codomE)
   apply (rule left_GaloisI)
     apply (rule in_codomI)
     apply (subst right_rel_eq_Frel)
     apply assumption
     apply (unfold left_rel_eq_Frel right_eq_Fmap Frel_Fmap_eq2)
     apply assumption
   done
 
 corollary left_Galois_eq_Frel_left_Galois: "(\<^bsub>L\<^esub>\<lessapprox>) = Frel (\<^bsub>L1\<^esub>\<lessapprox>) (\<^bsub>L2\<^esub>\<lessapprox>) (\<^bsub>L3\<^esub>\<lessapprox>)"
   by (intro antisym left_Galois_Frel_left_Galois Frel_left_Galois_le_left_Galois)
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Order_Base.thy b/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Order_Base.thy
--- a/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Order_Base.thy
+++ b/thys/Transport/Transport/Natural_Functors/Transport_Natural_Functors_Order_Base.thy
@@ -1,99 +1,99 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 subsection \<open>Basic Order Properties\<close>
 theory Transport_Natural_Functors_Order_Base
   imports
     Transport_Natural_Functors_Base
 begin
 
 lemma reflexive_on_in_field_FrelI:
   assumes "reflexive_on (in_field R1) R1"
   and "reflexive_on (in_field R2) R2"
   and "reflexive_on (in_field R3) R3"
   defines "R \<equiv> Frel R1 R2 R3"
   shows "reflexive_on (in_field R) R"
-  apply (subst reflexive_on_iff_eq_restrict_left_le)
+  apply (subst reflexive_on_iff_eq_restrict_le)
   apply (subst Frel_eq[symmetric])
   apply (unfold R_def)
   apply (subst in_field_Frel_eq_Fpred_in_in_field)
-  apply (subst restrict_left_sup_eq)
+  apply (subst bin_rel_restrict_left_sup_eq)
   apply (subst Frel_restrict_left_Fpred_eq_Frel_restrict_left)+
   apply (rule le_supI;
     rule Frel_mono;
-    subst reflexive_on_iff_eq_restrict_left_le[symmetric],
+    subst reflexive_on_iff_eq_restrict_le[symmetric],
     rule reflexive_on_if_le_pred_if_reflexive_on,
     rule assms,
     rule le_predI[OF in_field_if_in_dom]
       le_predI[OF in_field_if_in_codom],
     assumption)
   done
 
 lemma transitive_FrelI:
   assumes "transitive R1"
   and "transitive R2"
   and "transitive R3"
   shows "transitive (Frel R1 R2 R3)"
   apply (subst transitive_iff_rel_comp_le_self)
   apply (subst Frel_comp_eq_Frel_rel_comp)
   apply (rule Frel_mono;
     subst transitive_iff_rel_comp_le_self[symmetric],
     rule assms)
   done
 
 lemma preorder_on_in_field_FrelI:
   assumes "preorder_on (in_field R1) R1"
   and "preorder_on (in_field R2) R2"
   and "preorder_on (in_field R3) R3"
   defines "R \<equiv> Frel R1 R2 R3"
   shows "preorder_on (in_field R) R"
   apply (unfold R_def)
   apply (insert assms)
   apply (elim preorder_on_in_fieldE)
   apply (rule preorder_onI)
   apply (rule reflexive_on_in_field_FrelI; assumption)
   apply (subst transitive_on_in_field_iff_transitive)
   apply (rule transitive_FrelI; assumption)
   done
 
 lemma symmetric_FrelI:
   assumes "symmetric R1"
   and "symmetric R2"
   and "symmetric R3"
   shows "symmetric (Frel R1 R2 R3)"
   apply (subst symmetric_iff_rel_inv_eq_self)
   apply (subst Frel_rel_inv_eq_rel_inv_Frel[symmetric])
   apply (subst rel_inv_eq_self_if_symmetric, fact)+
   apply (rule refl)
   done
 
 lemma partial_equivalence_rel_FrelI:
   assumes "partial_equivalence_rel R1"
   and "partial_equivalence_rel R2"
   and "partial_equivalence_rel R3"
   shows "partial_equivalence_rel (Frel R1 R2 R3)"
   apply (insert assms)
   apply (elim partial_equivalence_relE preorder_on_in_fieldE)
   apply (rule partial_equivalence_relI;
     rule transitive_FrelI symmetric_FrelI;
     assumption)
   done
 
 context transport_natural_functor
 begin
 
 lemmas reflexive_on_in_field_leftI = reflexive_on_in_field_FrelI
   [of L1 L2 L3, folded transport_defs]
 
 lemmas transitive_leftI = transitive_FrelI[of L1 L2 L3, folded transport_defs]
 
 lemmas preorder_on_in_field_leftI = preorder_on_in_field_FrelI
   [of L1 L2 L3, folded transport_defs]
 
 lemmas symmetricI = symmetric_FrelI[of L1 L2 L3, folded transport_defs]
 
 lemmas partial_equivalence_rel_leftI = partial_equivalence_rel_FrelI
   [of L1 L2 L3, folded transport_defs]
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/Transport/Transport_Bijections.thy b/thys/Transport/Transport/Transport_Bijections.thy
--- a/thys/Transport/Transport/Transport_Bijections.thy
+++ b/thys/Transport/Transport/Transport_Bijections.thy
@@ -1,202 +1,199 @@
 \<^marker>\<open>creator "Kevin Kappelmann"\<close>
 section \<open>Transport using Bijections\<close>
 theory Transport_Bijections
   imports
+    Restricted_Equality
     Functions_Bijection
     Transport_Base
 begin
 
 paragraph \<open>Summary\<close>
 text \<open>Setup for Transport using bijective transport functions.\<close>
 
 locale transport_bijection =
   fixes L :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
   and R :: "'b \<Rightarrow> 'b \<Rightarrow> bool"
   and l :: "'a \<Rightarrow> 'b"
   and r :: "'b \<Rightarrow> 'a"
   assumes mono_wrt_rel_left: "(L \<Rrightarrow>\<^sub>m R) l"
   and mono_wrt_rel_right: "(R \<Rrightarrow>\<^sub>m L) r"
   and inverse_left_right: "inverse_on (in_field L) l r"
   and inverse_right_left: "inverse_on (in_field R) r l"
 begin
 
 interpretation transport L R l r .
 interpretation g_flip_inv : galois "(\<ge>\<^bsub>R\<^esub>)" "(\<ge>\<^bsub>L\<^esub>)" r l .
 
 lemma bijection_on_in_field: "bijection_on (in_field (\<le>\<^bsub>L\<^esub>)) (in_field (\<le>\<^bsub>R\<^esub>)) l r"
   using mono_wrt_rel_left mono_wrt_rel_right inverse_left_right inverse_right_left
   by (intro bijection_onI in_field_if_in_field_if_mono_wrt_rel)
   auto
 
 lemma half_galois_prop_left: "((\<le>\<^bsub>L\<^esub>) \<^sub>h\<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   using mono_wrt_rel_left inverse_right_left
-  by (intro half_galois_prop_leftI)
-  (auto dest!: in_field_if_in_codom inverse_onD)
+  by (intro half_galois_prop_leftI) (fastforce dest: inverse_onD)
 
 lemma half_galois_prop_right: "((\<le>\<^bsub>L\<^esub>) \<unlhd>\<^sub>h (\<le>\<^bsub>R\<^esub>)) l r"
   using mono_wrt_rel_right inverse_left_right
   by (intro half_galois_prop_rightI)
   (force dest: in_field_if_in_dom inverse_onD)
 
 lemma galois_prop: "((\<le>\<^bsub>L\<^esub>) \<unlhd> (\<le>\<^bsub>R\<^esub>)) l r"
   using half_galois_prop_left half_galois_prop_right
   by (intro galois_propI)
 
 lemma galois_connection: "((\<le>\<^bsub>L\<^esub>) \<stileturn> (\<le>\<^bsub>R\<^esub>)) l r"
   using mono_wrt_rel_left mono_wrt_rel_right galois_prop
   by (intro galois_connectionI)
 
 lemma rel_equivalence_on_unitI:
   assumes "reflexive_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   shows "rel_equivalence_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>) \<eta>"
   using assms inverse_left_right
   by (subst rel_equivalence_on_unit_iff_reflexive_on_if_inverse_on)
 
 interpretation flip : transport_bijection R L r l
   rewrites "order_functors.unit r l \<equiv> \<epsilon>"
   using mono_wrt_rel_left mono_wrt_rel_right inverse_left_right inverse_right_left
   by unfold_locales (simp_all only: flip_unit_eq_counit)
 
 lemma galois_equivalence: "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>G (\<le>\<^bsub>R\<^esub>)) l r"
   using galois_connection flip.galois_prop by (intro galois_equivalenceI)
 
 lemmas rel_equivalence_on_counitI = flip.rel_equivalence_on_unitI
 
 lemma order_equivalenceI:
   assumes "reflexive_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   and "reflexive_on (in_field (\<le>\<^bsub>R\<^esub>)) (\<le>\<^bsub>R\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^sub>o (\<le>\<^bsub>R\<^esub>)) l r"
   using assms mono_wrt_rel_left mono_wrt_rel_right rel_equivalence_on_unitI
     rel_equivalence_on_counitI
   by (intro order_equivalenceI)
 
 lemma preorder_equivalenceI:
   assumes "preorder_on (in_field (\<le>\<^bsub>L\<^esub>)) (\<le>\<^bsub>L\<^esub>)"
   and "preorder_on (in_field (\<le>\<^bsub>R\<^esub>)) (\<le>\<^bsub>R\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>pre\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro preorder_equivalence_if_galois_equivalenceI
     galois_equivalence)
   simp_all
 
 lemma partial_equivalence_rel_equivalenceI:
   assumes "partial_equivalence_rel (\<le>\<^bsub>L\<^esub>)"
   and "partial_equivalence_rel (\<le>\<^bsub>R\<^esub>)"
   shows "((\<le>\<^bsub>L\<^esub>) \<equiv>\<^bsub>PER\<^esub> (\<le>\<^bsub>R\<^esub>)) l r"
   using assms by (intro partial_equivalence_rel_equivalence_if_galois_equivalenceI
     galois_equivalence)
   simp_all
 
 end
 
 locale transport_reflexive_on_in_field_bijection =
   fixes L :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
   and R :: "'b \<Rightarrow> 'b \<Rightarrow> bool"
   and l :: "'a \<Rightarrow> 'b"
   and r :: "'b \<Rightarrow> 'a"
   assumes reflexive_on_in_field_left: "reflexive_on (in_field L) L"
   and reflexive_on_in_field_right: "reflexive_on (in_field R) R"
   and transport_bijection: "transport_bijection L R l r"
 begin
 
 sublocale tbij? : transport_bijection L R l r
   rewrites "reflexive_on (in_field L) L \<equiv> True"
   and "reflexive_on (in_field R) R \<equiv> True"
   and "\<And>P. (True \<Longrightarrow> P) \<equiv> Trueprop P"
   using transport_bijection reflexive_on_in_field_left reflexive_on_in_field_right
   by auto
 
 lemmas rel_equivalence_on_unit = rel_equivalence_on_unitI
 lemmas rel_equivalence_on_counit = rel_equivalence_on_counitI
 lemmas order_equivalence = order_equivalenceI
 
 end
 
 locale transport_preorder_on_in_field_bijection =
   fixes L :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
   and R :: "'b \<Rightarrow> 'b \<Rightarrow> bool"
   and l :: "'a \<Rightarrow> 'b"
   and r :: "'b \<Rightarrow> 'a"
   assumes preorder_on_in_field_left: "preorder_on (in_field L) L"
   and preorder_on_in_field_right: "preorder_on (in_field R) R"
   and transport_bijection: "transport_bijection L R l r"
 begin
 
 sublocale trefl_bij? : transport_reflexive_on_in_field_bijection L R l r
   rewrites "preorder_on (in_field L) L \<equiv> True"
   and "preorder_on (in_field R) R \<equiv> True"
   and "\<And>P. (True \<Longrightarrow> P) \<equiv> Trueprop P"
   using transport_bijection
   by (intro transport_reflexive_on_in_field_bijection.intro)
   (insert preorder_on_in_field_left preorder_on_in_field_right, auto)
 
 lemmas preorder_equivalence = preorder_equivalenceI
 
 end
 
 locale transport_partial_equivalence_rel_bijection =
   fixes L :: "'a \<Rightarrow> 'a \<Rightarrow> bool"
   and R :: "'b \<Rightarrow> 'b \<Rightarrow> bool"
   and l :: "'a \<Rightarrow> 'b"
   and r :: "'b \<Rightarrow> 'a"
   assumes partial_equivalence_rel_left: "partial_equivalence_rel L"
   and partial_equivalence_rel_right: "partial_equivalence_rel R"
   and transport_bijection: "transport_bijection L R l r"
 begin
 
 sublocale tpre_bij? : transport_preorder_on_in_field_bijection L R l r
   rewrites "partial_equivalence_rel L \<equiv> True"
   and "partial_equivalence_rel R \<equiv> True"
   and "\<And>P. (True \<Longrightarrow> P) \<equiv> Trueprop P"
   using transport_bijection
   by (intro transport_preorder_on_in_field_bijection.intro)
   (insert partial_equivalence_rel_left partial_equivalence_rel_right, auto)
 
 lemmas partial_equivalence_rel_equivalence = partial_equivalence_rel_equivalenceI
 
 end
 
 locale transport_eq_restrict_bijection =
   fixes P :: "'a \<Rightarrow> bool"
   and Q :: "'b \<Rightarrow> bool"
   and l :: "'a \<Rightarrow> 'b"
   and r :: "'b \<Rightarrow> 'a"
   assumes bijection_on_in_field:
     "bijection_on (in_field ((=\<^bsub>P\<^esub>) :: 'a \<Rightarrow> _)) (in_field ((=\<^bsub>Q\<^esub>) :: 'b \<Rightarrow> _)) l r"
 begin
 
 interpretation transport "(=\<^bsub>P\<^esub>)" "(=\<^bsub>Q\<^esub>)" l r .
 
 sublocale tper_bij? : transport_partial_equivalence_rel_bijection "(=\<^bsub>P\<^esub>)" "(=\<^bsub>Q\<^esub>)" l r
   using bijection_on_in_field partial_equivalence_rel_eq_restrict
-    eq_restrict_le_eq
   by unfold_locales
   (auto elim: bijection_onE intro!:
-    mono_wrt_rel_left_if_reflexive_on_if_le_eq_if_mono_wrt_in_field
-      [of "in_field (=\<^bsub>Q\<^esub>)"]
-    flip_of.mono_wrt_rel_left_if_reflexive_on_if_le_eq_if_mono_wrt_in_field
-      [of "in_field (=\<^bsub>P\<^esub>)"])
+    mono_wrt_rel_left_if_reflexive_on_if_le_eq_if_mono_wrt_in_field[of "in_field (=\<^bsub>Q\<^esub>)"]
+    flip_of.mono_wrt_rel_left_if_reflexive_on_if_le_eq_if_mono_wrt_in_field[of "in_field (=\<^bsub>P\<^esub>)"])
 
 lemma left_Galois_eq_Galois_eq_eq_restrict: "(\<^bsub>L\<^esub>\<lessapprox>) = (galois_rel.Galois (=) (=) r)\<restriction>\<^bsub>P\<^esub>\<upharpoonleft>\<^bsub>Q\<^esub>"
   by (subst galois_rel.left_Galois_restrict_left_eq_left_Galois_left_restrict_left
     galois_rel.left_Galois_restrict_right_eq_left_Galois_right_restrict_right
-    restrict_right_eq rel_inv_eq_self_if_symmetric)+
-  (auto simp: eq_restrict_eq_eq_restrict_left)
+    bin_rel_restrict_right_eq rel_inv_eq_self_if_symmetric)+
+  auto
 
 end
 
 locale transport_eq_bijection =
   fixes l :: "'a \<Rightarrow> 'b"
   and r :: "'b \<Rightarrow> 'a"
   assumes bijection_on_in_field:
     "bijection_on (in_field ((=) :: 'a \<Rightarrow> _)) (in_field ((=) :: 'b \<Rightarrow> _)) l r"
 begin
 
 sublocale teq_restr_bij? : transport_eq_restrict_bijection \<top> \<top> l r
   rewrites "(=\<^bsub>\<top> :: 'a \<Rightarrow> bool\<^esub>) = ((=) :: 'a \<Rightarrow> _)"
   and "(=\<^bsub>\<top> :: 'b \<Rightarrow> bool\<^esub>) = ((=) :: 'b \<Rightarrow> _)"
   using bijection_on_in_field by unfold_locales simp_all
 
 end
 
 
 end
\ No newline at end of file
diff --git a/thys/Transport/document/root.bib b/thys/Transport/document/root.bib
--- a/thys/Transport/document/root.bib
+++ b/thys/Transport/document/root.bib
@@ -1,20 +1,23 @@
-@misc{transport,
-  title={{Transport via Partial Galois Connections and Equivalences}},
-  author={{Kevin Kappelmann}},
-  year={2023},
-  eprint={2303.05244},
-  archivePrefix={arXiv},
-  primaryClass={cs.PL},
-  doi={10.48550/arXiv.2303.05244}
+@InProceedings{transport,
+  author="Kappelmann, Kevin",
+  editor="Hur, Chung-Kil",
+  title="Transport via Partial Galois Connections and Equivalences",
+  booktitle="Programming Languages and Systems",
+  year="2023",
+  publisher="Springer Nature Singapore",
+  address="Singapore",
+  pages="225--245",
+  abstract="Multiple types can represent the same concept. For example, lists and trees can both represent sets. Unfortunately, this easily leads to incomplete libraries: some set-operations may only be available on lists, others only on trees. Similarly, subtypes and quotients are commonly used to construct new type abstractions in formal verification. In such cases, one often wishes to reuse operations on the representation type for the new type abstraction, but to no avail: the types are not the same. To address these problems, we present a new framework that transports programs via equivalences. Existing transport frameworks are either designed for dependently typed, constructive proof assistants, use univalence, or are restricted to partial quotient types. Our framework (1) is designed for simple type theory, (2) generalises previous approaches working on partial quotient types, and (3) is based on standard mathematical concepts, particularly Galois connections and equivalences. We introduce the notions of partial Galois connection and equivalence and prove their closure properties under (dependent) function relators, (co)datatypes, and compositions. We formalised the framework in Isabelle/HOL and provide a prototype.",
+  isbn="978-981-99-8311-7"
 }
 
 @inproceedings{lifting,
   title={{Lifting and Transfer: A modular design for quotients in Isabelle/HOL}},
   author={{Huffman, Brian and Kun{\v{c}}ar, Ond{\v{r}}ej}},
   booktitle={Certified Programs and Proofs: Third International Conference, CPP 2013, Melbourne, VIC, Australia, December 11-13, 2013, Proceedings 3},
   pages={131--146},
   year={2013},
   organization={Springer},
   doi={10.1007/978-3-319-03545-1_9}
 }