diff --git a/thys/Complex_Bounded_Operators/Cblinfun_Matrix.thy b/thys/Complex_Bounded_Operators/Cblinfun_Matrix.thy
--- a/thys/Complex_Bounded_Operators/Cblinfun_Matrix.thy
+++ b/thys/Complex_Bounded_Operators/Cblinfun_Matrix.thy
@@ -1,1572 +1,1576 @@
 section \<open>\<open>Cblinfun_Matrix\<close> -- Matrix representation of bounded operators\<close>
 
 theory Cblinfun_Matrix
   imports
     Complex_L2
 
     "Jordan_Normal_Form.Gram_Schmidt"
     "HOL-Analysis.Starlike"
     "Complex_Bounded_Operators.Extra_Jordan_Normal_Form"
 begin
 
 hide_const (open) Order.bottom Order.top
 hide_type (open) Finite_Cartesian_Product.vec
 hide_const (open) Finite_Cartesian_Product.mat
 hide_fact (open) Finite_Cartesian_Product.mat_def
 hide_const (open) Finite_Cartesian_Product.vec
 hide_fact (open) Finite_Cartesian_Product.vec_def
 hide_const (open) Finite_Cartesian_Product.row
 hide_fact (open) Finite_Cartesian_Product.row_def
 no_notation Finite_Cartesian_Product.vec_nth (infixl "$" 90)
 
 unbundle jnf_notation
 unbundle cblinfun_notation
 
 subsection \<open>Isomorphism between vectors\<close>
 
 text \<open>We define the canonical isomorphism between vectors in some complex vector space \<^typ>\<open>'a::basis_enum\<close> and the
   complex \<^term>\<open>n\<close>-dimensional vectors (where \<^term>\<open>n\<close> is the dimension of \<^typ>\<open>'a\<close>).
   This is possible if \<^typ>\<open>'a\<close>, \<^typ>\<open>'b\<close> are of class \<^class>\<open>basis_enum\<close>
   since that class fixes a finite canonical basis. Vector are represented using
   the \<^typ>\<open>complex vec\<close> type from \<^session>\<open>Jordan_Normal_Form\<close>.
   (The isomorphism will be called \<^term>\<open>vec_of_onb_enum\<close> below.)\<close>
 
 definition vec_of_basis_enum :: \<open>'a::basis_enum \<Rightarrow> complex vec\<close> where
   \<comment> \<open>Maps \<^term>\<open>v\<close> to a \<^typ>\<open>'a vec\<close> represented in basis \<^const>\<open>canonical_basis\<close>\<close>
   \<open>vec_of_basis_enum v = vec_of_list (map (crepresentation (set canonical_basis) v) canonical_basis)\<close>
 
 lemma dim_vec_of_basis_enum'[simp]:
   \<open>dim_vec (vec_of_basis_enum (v::'a)) = length (canonical_basis::'a::basis_enum list)\<close>
-  unfolding vec_of_basis_enum_def 
-  by simp  
+  unfolding vec_of_basis_enum_def
+  by simp
 
 
 definition basis_enum_of_vec :: \<open>complex vec \<Rightarrow> 'a::basis_enum\<close> where
-  \<open>basis_enum_of_vec v = 
+  \<open>basis_enum_of_vec v =
     (if dim_vec v = length (canonical_basis :: 'a list)
      then sum_list (map2 (*\<^sub>C) (list_of_vec v) (canonical_basis::'a list))
      else 0)\<close>
 
 lemma vec_of_basis_enum_inverse[simp]:
   fixes w::"'a::basis_enum"
   shows  "basis_enum_of_vec (vec_of_basis_enum w) = w"
-  unfolding vec_of_basis_enum_def basis_enum_of_vec_def 
-  unfolding list_vec zip_map1 zip_same_conv_map map_map 
+  unfolding vec_of_basis_enum_def basis_enum_of_vec_def
+  unfolding list_vec zip_map1 zip_same_conv_map map_map
   apply (simp add: o_def)
   apply (subst sum.distinct_set_conv_list[symmetric], simp)
   apply (rule complex_vector.sum_representation_eq)
   using  is_generator_set by auto
 
 lemma basis_enum_of_vec_inverse[simp]:
   fixes v::"complex vec"
   defines "n \<equiv> length (canonical_basis :: 'a::basis_enum list)"
   assumes f1: "dim_vec v = n"
   shows "vec_of_basis_enum ((basis_enum_of_vec v)::'a) = v"
 proof (rule eq_vecI)
   show \<open>dim_vec (vec_of_basis_enum (basis_enum_of_vec v :: 'a)) = dim_vec v\<close>
     by (auto simp: vec_of_basis_enum_def f1 n_def)
 next
-  fix j assume j_v: \<open>j < dim_vec v\<close> 
+  fix j assume j_v: \<open>j < dim_vec v\<close>
   define w where "w = list_of_vec v"
   define basis where "basis = (canonical_basis::'a list)"
   have [simp]: "length w = n" "length basis = n" \<open>dim_vec v = n\<close> \<open>length (canonical_basis::'a list) = n\<close>
     \<open>j < n\<close>
     using j_v by (auto simp: f1 basis_def w_def n_def)
   have [simp]: \<open>cindependent (set basis)\<close> \<open>cspan (set basis) = UNIV\<close>
     by (auto simp: basis_def is_cindependent_set is_generator_set)
 
   have \<open>vec_of_basis_enum ((basis_enum_of_vec v)::'a) $ j
        = map (crepresentation (set basis) (sum_list (map2 (*\<^sub>C) w basis))) basis ! j\<close>
     by (auto simp: vec_of_list_index vec_of_basis_enum_def basis_enum_of_vec_def simp flip: w_def basis_def)
   also have \<open>\<dots> = crepresentation (set basis) (sum_list (map2 (*\<^sub>C) w basis)) (basis!j)\<close>
     by simp
   also have \<open>\<dots> = crepresentation (set basis) (\<Sum>i<n. (w!i) *\<^sub>C (basis!i)) (basis!j)\<close>
     by (auto simp: sum_list_sum_nth atLeast0LessThan)
   also have \<open>\<dots> = (\<Sum>i<n. (w!i) *\<^sub>C crepresentation (set basis) (basis!i) (basis!j))\<close>
     by (auto simp: complex_vector.representation_sum complex_vector.representation_scale)
   also have \<open>\<dots> = w!j\<close>
     apply (subst sum_single[where i=j])
       apply (auto simp: complex_vector.representation_basis)
     using \<open>j < n\<close> \<open>length basis = n\<close> basis_def distinct_canonical_basis nth_eq_iff_index_eq by blast
   also have \<open>\<dots> = v $ j\<close>
     by (simp add: w_def)
   finally show \<open>vec_of_basis_enum (basis_enum_of_vec v :: 'a) $ j = v $ j\<close>
     by -
 qed
 
 lemma basis_enum_eq_vec_of_basis_enumI:
   fixes a b :: "_::basis_enum"
   assumes "vec_of_basis_enum a = vec_of_basis_enum b"
   shows "a = b"
   by (metis assms vec_of_basis_enum_inverse)
 
 subsection \<open>Operations on vectors\<close>
 
 
 lemma basis_enum_of_vec_add:
-  assumes [simp]: \<open>dim_vec v1 = length (canonical_basis :: 'a::basis_enum list)\<close> 
+  assumes [simp]: \<open>dim_vec v1 = length (canonical_basis :: 'a::basis_enum list)\<close>
     \<open>dim_vec v2 = length (canonical_basis :: 'a list)\<close>
   shows \<open>((basis_enum_of_vec (v1 + v2)) :: 'a) = basis_enum_of_vec v1 + basis_enum_of_vec v2\<close>
 proof -
   have \<open>length (list_of_vec v1) = length (list_of_vec v2)\<close> and \<open>length (list_of_vec v2) = length (canonical_basis :: 'a list)\<close>
     by simp_all
   then have \<open>sum_list (map2 (*\<^sub>C) (map2 (+) (list_of_vec v1) (list_of_vec v2)) (canonical_basis::'a list))
     = sum_list (map2 (*\<^sub>C) (list_of_vec v1) canonical_basis) + sum_list (map2 (*\<^sub>C) (list_of_vec v2) canonical_basis)\<close>
     apply (induction rule: list_induct3)
     by (auto simp: scaleC_add_left)
   then show ?thesis
     using assms by (auto simp: basis_enum_of_vec_def list_of_vec_plus)
 qed
 
 lemma basis_enum_of_vec_mult:
-  assumes [simp]: \<open>dim_vec v = length (canonical_basis :: 'a::basis_enum list)\<close> 
+  assumes [simp]: \<open>dim_vec v = length (canonical_basis :: 'a::basis_enum list)\<close>
   shows \<open>((basis_enum_of_vec (c \<cdot>\<^sub>v v)) :: 'a) =  c *\<^sub>C basis_enum_of_vec v\<close>
 proof -
   have *: \<open>monoid_add_hom ((*\<^sub>C) c :: 'a \<Rightarrow> _)\<close>
     by (simp add: monoid_add_hom_def plus_hom.intro scaleC_add_right semigroup_add_hom.intro zero_hom.intro)
   show ?thesis
     apply (auto simp: basis_enum_of_vec_def list_of_vec_mult map_zip_map
         monoid_add_hom.hom_sum_list[OF *])
     by (metis case_prod_unfold comp_apply scaleC_scaleC)
 qed
 
 
 lemma vec_of_basis_enum_add:
   "vec_of_basis_enum (b1 + b2) = vec_of_basis_enum b1 + vec_of_basis_enum b2"
   by (auto simp: vec_of_basis_enum_def complex_vector.representation_add)
 
 lemma vec_of_basis_enum_scaleC:
   "vec_of_basis_enum (c *\<^sub>C b) = c \<cdot>\<^sub>v (vec_of_basis_enum b)"
   by (auto simp: vec_of_basis_enum_def complex_vector.representation_scale)
 
 lemma vec_of_basis_enum_scaleR:
   "vec_of_basis_enum (r *\<^sub>R b) = complex_of_real r \<cdot>\<^sub>v (vec_of_basis_enum b)"
   by (simp add: scaleR_scaleC vec_of_basis_enum_scaleC)
 
 lemma vec_of_basis_enum_uminus:
   "vec_of_basis_enum (- b2) = - vec_of_basis_enum b2"
   unfolding scaleC_minus1_left[symmetric, of b2]
   unfolding scaleC_minus1_left_vec[symmetric]
   by (rule vec_of_basis_enum_scaleC)
 
 
 lemma vec_of_basis_enum_minus:
   "vec_of_basis_enum (b1 - b2) = vec_of_basis_enum b1 - vec_of_basis_enum b2"
-  by (metis (mono_tags, hide_lams) carrier_vec_dim_vec diff_conv_add_uminus diff_zero index_add_vec(2) minus_add_uminus_vec vec_of_basis_enum_add vec_of_basis_enum_uminus)
+  by (metis (mono_tags, opaque_lifting) carrier_vec_dim_vec diff_conv_add_uminus diff_zero
+      index_add_vec(2) minus_add_uminus_vec vec_of_basis_enum_add vec_of_basis_enum_uminus)
 
 lemma cinner_basis_enum_of_vec:
   defines "n \<equiv> length (canonical_basis :: 'a::onb_enum list)"
   assumes [simp]: "dim_vec x = n" "dim_vec y = n"
   shows  "\<langle>basis_enum_of_vec x :: 'a, basis_enum_of_vec y\<rangle> = y \<bullet>c x"
 proof -
   have \<open>\<langle>basis_enum_of_vec x :: 'a, basis_enum_of_vec y\<rangle>
     = (\<Sum>i<n. x$i *\<^sub>C canonical_basis ! i :: 'a) \<bullet>\<^sub>C (\<Sum>i<n. y$i *\<^sub>C canonical_basis ! i)\<close>
     by (auto simp: basis_enum_of_vec_def sum_list_sum_nth atLeast0LessThan simp flip: n_def)
   also have \<open>\<dots> = (\<Sum>i<n. \<Sum>j<n. cnj (x$i) *\<^sub>C y$j *\<^sub>C ((canonical_basis ! i :: 'a) \<bullet>\<^sub>C (canonical_basis ! j)))\<close>
     apply (subst cinner_sum_left)
     apply (subst cinner_sum_right)
     by (auto simp: mult_ac)
   also have \<open>\<dots> = (\<Sum>i<n. \<Sum>j<n. cnj (x$i) *\<^sub>C y$j *\<^sub>C (if i=j then 1 else 0))\<close>
     apply (rule sum.cong[OF refl])
     apply (rule sum.cong[OF refl])
     by (auto simp: cinner_canonical_basis n_def)
   also have \<open>\<dots> = (\<Sum>i<n. cnj (x$i) *\<^sub>C y$i)\<close>
     apply (rule sum.cong[OF refl])
     apply (subst sum_single)
     by auto
   also have \<open>\<dots> = y \<bullet>c x\<close>
     by (smt (z3) assms(2) complex_scaleC_def conjugate_complex_def dim_vec_conjugate lessThan_atLeast0 lessThan_iff mult.commute scalar_prod_def sum.cong vec_index_conjugate)
   finally show ?thesis
     by -
 qed
 
 lemma cscalar_prod_vec_of_basis_enum: "cscalar_prod (vec_of_basis_enum \<phi>) (vec_of_basis_enum \<psi>) = cinner \<psi> \<phi>"
   for \<psi> :: "'a::onb_enum"
   apply (subst cinner_basis_enum_of_vec[symmetric, where 'a='a])
   by simp_all
 
 lemma norm_ell2_vec_of_basis_enum: "norm \<psi> =
   (let \<psi>' = vec_of_basis_enum \<psi> in
     sqrt (\<Sum> i \<in> {0 ..< dim_vec \<psi>'}. let z = vec_index \<psi>' i in (Re z)\<^sup>2 + (Im z)\<^sup>2))"
   (is "_ = ?rhs") for \<psi> :: "'a::onb_enum"
 proof -
-  have "norm \<psi> = sqrt (cmod (\<Sum>i = 0..<dim_vec (vec_of_basis_enum \<psi>). 
+  have "norm \<psi> = sqrt (cmod (\<Sum>i = 0..<dim_vec (vec_of_basis_enum \<psi>).
             vec_of_basis_enum \<psi> $ i * conjugate (vec_of_basis_enum \<psi>) $ i))"
     unfolding norm_eq_sqrt_cinner[where 'a='a] cscalar_prod_vec_of_basis_enum[symmetric] scalar_prod_def dim_vec_conjugate
     by rule
-  also have "\<dots> = sqrt (cmod (\<Sum>x = 0..<dim_vec (vec_of_basis_enum \<psi>). 
+  also have "\<dots> = sqrt (cmod (\<Sum>x = 0..<dim_vec (vec_of_basis_enum \<psi>).
                     let z = vec_of_basis_enum \<psi> $ x in (Re z)\<^sup>2 + (Im z)\<^sup>2))"
     apply (subst sum.cong, rule refl)
      apply (subst vec_index_conjugate)
     by (auto simp: Let_def complex_mult_cnj)
   also have "\<dots> = ?rhs"
     unfolding Let_def norm_of_real
     apply (subst abs_of_nonneg)
      apply (rule sum_nonneg)
     by auto
   finally show ?thesis
     by -
 qed
 
 lemma basis_enum_of_vec_unit_vec:
   defines "basis \<equiv> (canonical_basis::'a::basis_enum list)"
     and "n \<equiv> length (canonical_basis :: 'a list)"
-  assumes a3: "i < n"  
+  assumes a3: "i < n"
   shows "basis_enum_of_vec (unit_vec n i) = basis!i"
 proof-
   define L::"complex list" where "L = list_of_vec (unit_vec n i)"
   define I::"nat list" where "I = [0..<n]"
   have "length L = n"
-    by (simp add: L_def)    
+    by (simp add: L_def)
   moreover have "length basis = n"
     by (simp add: basis_def n_def)
   ultimately have "map2 (*\<^sub>C) L basis = map (\<lambda>j. L!j *\<^sub>C basis!j) I"
-    by (simp add: I_def list_eq_iff_nth_eq)  
+    by (simp add: I_def list_eq_iff_nth_eq)
   hence "sum_list (map2 (*\<^sub>C) L basis) = sum_list (map (\<lambda>j. L!j *\<^sub>C basis!j) I)"
     by simp
   also have "\<dots> = sum (\<lambda>j. L!j *\<^sub>C basis!j) {0..n-1}"
   proof-
     have "set I = {0..n-1}"
-      using I_def a3 by auto      
-    thus ?thesis 
+      using I_def a3 by auto
+    thus ?thesis
       using Groups_List.sum_code[where xs = I and g = "(\<lambda>j. L!j *\<^sub>C basis!j)"]
-      by (simp add: I_def)      
+      by (simp add: I_def)
   qed
   also have "\<dots> = sum (\<lambda>j. (list_of_vec (unit_vec n i))!j *\<^sub>C basis!j) {0..n-1}"
     unfolding L_def by blast
   finally have "sum_list (map2 (*\<^sub>C) (list_of_vec (unit_vec n i)) basis)
        = sum (\<lambda>j. (list_of_vec (unit_vec n i))!j *\<^sub>C basis!j) {0..n-1}"
-    using L_def by blast    
+    using L_def by blast
   also have "\<dots> = basis ! i"
   proof-
     have "(\<Sum>j = 0..n - 1. list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j) =
           (\<Sum>j \<in> {0..n - 1}. list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j)"
       by simp
     also have "\<dots> = list_of_vec (unit_vec n i) ! i *\<^sub>C basis ! i
                + (\<Sum>j \<in> {0..n - 1}-{i}. list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j)"
     proof-
       define a where "a j = list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j" for j
       define S where "S = {0..n - 1}"
       have "finite S"
-        by (simp add: S_def)        
+        by (simp add: S_def)
       hence "(\<Sum>j \<in> insert i S. a j) = a i + (\<Sum>j\<in>S-{i}. a j)"
         using Groups_Big.comm_monoid_add_class.sum.insert_remove
         by auto
       moreover have "S-{i} = {0..n-1}-{i}"
         unfolding S_def
-        by blast 
+        by blast
       moreover have "insert i S = {0..n-1}"
-        using S_def Suc_diff_1 a3 atLeastAtMost_iff diff_is_0_eq' le_SucE le_numeral_extra(4) 
+        using S_def Suc_diff_1 a3 atLeastAtMost_iff diff_is_0_eq' le_SucE le_numeral_extra(4)
           less_imp_le not_gr_zero
-        by fastforce 
+        by fastforce
       ultimately show ?thesis
         using \<open>a \<equiv> \<lambda>j. list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j\<close>
-        by simp 
+        by simp
     qed
     also have "\<dots> = list_of_vec (unit_vec n i) ! i *\<^sub>C basis ! i"
     proof-
       have "j \<in> {0..n - 1}-{i} \<Longrightarrow> list_of_vec (unit_vec n i) ! j = 0"
         for j
-        using a3 atMost_atLeast0 atMost_iff diff_Suc_less index_unit_vec(1) le_less_trans 
-          list_of_vec_index member_remove zero_le by fastforce         
+        using a3 atMost_atLeast0 atMost_iff diff_Suc_less index_unit_vec(1) le_less_trans
+          list_of_vec_index member_remove zero_le by fastforce
       hence "j \<in> {0..n - 1}-{i} \<Longrightarrow> list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j = 0"
         for j
-        by auto         
+        by auto
       hence "(\<Sum>j \<in> {0..n - 1}-{i}. list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j) = 0"
-        by (simp add: \<open>\<And>j. j \<in> {0..n - 1} - {i} \<Longrightarrow> list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j = 0\<close>)        
+        by (simp add: \<open>\<And>j. j \<in> {0..n - 1} - {i} \<Longrightarrow> list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j = 0\<close>)
       thus ?thesis by simp
     qed
     also have "\<dots> = basis ! i"
-      by (simp add: a3)      
+      by (simp add: a3)
     finally show ?thesis
       using \<open>(\<Sum>j = 0..n - 1. list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j)
              = list_of_vec (unit_vec n i) ! i *\<^sub>C basis ! i + (\<Sum>j\<in>{0..n - 1} - {i}. list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j)\<close>
         \<open>list_of_vec (unit_vec n i) ! i *\<^sub>C basis ! i + (\<Sum>j\<in>{0..n - 1} - {i}. list_of_vec (unit_vec n i) ! j *\<^sub>C basis ! j)
            = list_of_vec (unit_vec n i) ! i *\<^sub>C basis ! i\<close>
-        \<open>list_of_vec (unit_vec n i) ! i *\<^sub>C basis ! i = basis ! i\<close> 
-      by auto 
+        \<open>list_of_vec (unit_vec n i) ! i *\<^sub>C basis ! i = basis ! i\<close>
+      by auto
   qed
   finally have "sum_list (map2 (*\<^sub>C) (list_of_vec (unit_vec n i)) basis)
       = basis ! i"
-    by (simp add: assms)    
+    by (simp add: assms)
   hence "sum_list (map2 scaleC (list_of_vec (unit_vec n i)) (canonical_basis::'a list))
-      = (canonical_basis::'a list) ! i"     
+      = (canonical_basis::'a list) ! i"
     by (simp add: assms)
-  thus ?thesis 
+  thus ?thesis
     unfolding basis_enum_of_vec_def
-    by (simp add: assms) 
+    by (simp add: assms)
 qed
 
 
 lemma vec_of_basis_enum_ket:
-  "vec_of_basis_enum (ket i) = unit_vec (CARD('a)) (enum_idx i)" 
+  "vec_of_basis_enum (ket i) = unit_vec (CARD('a)) (enum_idx i)"
   for i::"'a::enum"
 proof-
-  have "dim_vec (vec_of_basis_enum (ket i)) 
+  have "dim_vec (vec_of_basis_enum (ket i))
       = dim_vec (unit_vec (CARD('a)) (enum_idx i))"
   proof-
-    have "dim_vec (unit_vec (CARD('a)) (enum_idx i)) 
+    have "dim_vec (unit_vec (CARD('a)) (enum_idx i))
       = CARD('a)"
-      by simp     
+      by simp
     moreover have "dim_vec (vec_of_basis_enum (ket i)) = CARD('a)"
       unfolding vec_of_basis_enum_def vec_of_basis_enum_def by auto
     ultimately show ?thesis by simp
   qed
   moreover have "vec_of_basis_enum (ket i) $ j =
     (unit_vec (CARD('a)) (enum_idx i)) $ j"
     if "j < dim_vec (vec_of_basis_enum (ket i))"
     for j
   proof-
     have j_bound: "j < length (canonical_basis::'a ell2 list)"
       by (metis dim_vec_of_basis_enum' that)
     have y1: "cindependent (set (canonical_basis::'a ell2 list))"
       using is_cindependent_set by blast
     have y2: "canonical_basis ! j \<in> set (canonical_basis::'a ell2 list)"
       using j_bound by auto
     have p1: "enum_class.enum ! enum_idx i = i"
       using enum_idx_correct by blast
     moreover have p2: "(canonical_basis::'a ell2 list) ! t  = ket ((enum_class.enum::'a list) ! t)"
       if "t < length (enum_class.enum::'a list)"
       for t
-      unfolding canonical_basis_ell2_def 
+      unfolding canonical_basis_ell2_def
       using that by auto
     moreover have p3: "enum_idx i < length (enum_class.enum::'a list)"
     proof-
       have "set (enum_class.enum::'a list) = UNIV"
         using UNIV_enum by blast
       hence "i \<in> set (enum_class.enum::'a list)"
         by blast
       thus ?thesis
         unfolding enum_idx_def
-        by (metis index_of_bound length_greater_0_conv length_pos_if_in_set) 
+        by (metis index_of_bound length_greater_0_conv length_pos_if_in_set)
     qed
     ultimately have p4: "(canonical_basis::'a ell2 list) ! (enum_idx i)  = ket i"
       by auto
     have "enum_idx i < length (enum_class.enum::'a list)"
       using p3
       by auto
     moreover have "length (enum_class.enum::'a list) = dim_vec (vec_of_basis_enum (ket i))"
       unfolding vec_of_basis_enum_def canonical_basis_ell2_def
       using dim_vec_of_basis_enum'[where v = "ket i"]
-      unfolding canonical_basis_ell2_def by simp              
+      unfolding canonical_basis_ell2_def by simp
     ultimately have enum_i_dim_vec: "enum_idx i < dim_vec (unit_vec (CARD('a)) (enum_idx i))"
-      using \<open>dim_vec (vec_of_basis_enum (ket i)) = dim_vec (unit_vec (CARD('a)) (enum_idx i))\<close> by auto            
+      using \<open>dim_vec (vec_of_basis_enum (ket i)) = dim_vec (unit_vec (CARD('a)) (enum_idx i))\<close> by auto
     hence r1: "(unit_vec (CARD('a)) (enum_idx i)) $ j
         = (if enum_idx i = j then 1 else 0)"
       using \<open>dim_vec (vec_of_basis_enum (ket i)) = dim_vec (unit_vec (CARD('a)) (enum_idx i))\<close> that by auto
     moreover have "vec_of_basis_enum (ket i) $ j = (if enum_idx i = j then 1 else 0)"
     proof(cases "enum_idx i = j")
-      case True                        
-      have "crepresentation (set (canonical_basis::'a ell2 list)) 
-          ((canonical_basis::'a ell2 list) ! j) ((canonical_basis::'a ell2 list) ! j) = 1"        
-        using y1 y2 complex_vector.representation_basis[where 
-            basis = "set (canonical_basis::'a ell2 list)" 
+      case True
+      have "crepresentation (set (canonical_basis::'a ell2 list))
+          ((canonical_basis::'a ell2 list) ! j) ((canonical_basis::'a ell2 list) ! j) = 1"
+        using y1 y2 complex_vector.representation_basis[where
+            basis = "set (canonical_basis::'a ell2 list)"
             and b = "(canonical_basis::'a ell2 list) ! j"]
         by smt
 
       hence "vec_of_basis_enum ((canonical_basis::'a ell2 list) ! j) $ j = 1"
         unfolding vec_of_basis_enum_def
-        by (metis j_bound nth_map vec_of_list_index) 
-      hence "vec_of_basis_enum ((canonical_basis::'a ell2 list) ! (enum_idx i)) 
+        by (metis j_bound nth_map vec_of_list_index)
+      hence "vec_of_basis_enum ((canonical_basis::'a ell2 list) ! (enum_idx i))
             $ enum_idx i = 1"
         using True by simp
       hence "vec_of_basis_enum (ket i) $ enum_idx i = 1"
         using p4
         by simp
       thus ?thesis using True unfolding vec_of_basis_enum_def by auto
     next
       case False
-      have "crepresentation (set (canonical_basis::'a ell2 list)) 
-          ((canonical_basis::'a ell2 list) ! (enum_idx i)) ((canonical_basis::'a ell2 list) ! j) = 0"        
-        using y1 y2 complex_vector.representation_basis[where 
-            basis = "set (canonical_basis::'a ell2 list)" 
+      have "crepresentation (set (canonical_basis::'a ell2 list))
+          ((canonical_basis::'a ell2 list) ! (enum_idx i)) ((canonical_basis::'a ell2 list) ! j) = 0"
+        using y1 y2 complex_vector.representation_basis[where
+            basis = "set (canonical_basis::'a ell2 list)"
             and b = "(canonical_basis::'a ell2 list) ! j"]
-        by (metis (mono_tags, hide_lams) False enum_i_dim_vec basis_enum_of_vec_inverse basis_enum_of_vec_unit_vec canonical_basis_length_ell2 index_unit_vec(3) j_bound list_of_vec_index list_vec nth_map r1 vec_of_basis_enum_def)
+        by (metis (mono_tags, opaque_lifting) False enum_i_dim_vec basis_enum_of_vec_inverse
+            basis_enum_of_vec_unit_vec canonical_basis_length_ell2 index_unit_vec(3) j_bound
+            list_of_vec_index list_vec nth_map r1 vec_of_basis_enum_def)
       hence "vec_of_basis_enum ((canonical_basis::'a ell2 list) ! (enum_idx i)) $ j = 0"
-        unfolding vec_of_basis_enum_def by (smt j_bound nth_map vec_of_list_index)        
+        unfolding vec_of_basis_enum_def by (smt j_bound nth_map vec_of_list_index)
       hence "vec_of_basis_enum ((canonical_basis::'a ell2 list) ! (enum_idx i)) $ j = 0"
         by auto
       hence "vec_of_basis_enum (ket i) $ j = 0"
         using p4
         by simp
       thus ?thesis using False unfolding vec_of_basis_enum_def by simp
     qed
     ultimately show ?thesis by auto
   qed
-  ultimately show ?thesis 
+  ultimately show ?thesis
     using Matrix.eq_vecI
     by auto
 qed
 
 lemma vec_of_basis_enum_zero:
-  defines "nA \<equiv> length (canonical_basis :: 'a::basis_enum list)" 
+  defines "nA \<equiv> length (canonical_basis :: 'a::basis_enum list)"
   shows "vec_of_basis_enum (0::'a) = 0\<^sub>v nA"
   by (metis assms carrier_vecI dim_vec_of_basis_enum' minus_cancel_vec right_minus_eq vec_of_basis_enum_minus)
 
 lemma (in complex_vec_space) vec_of_basis_enum_cspan:
   fixes X :: "'a::basis_enum set"
   assumes "length (canonical_basis :: 'a list) = n"
   shows "vec_of_basis_enum ` cspan X = span (vec_of_basis_enum ` X)"
 proof -
   have carrier: "vec_of_basis_enum ` X \<subseteq> carrier_vec n"
     by (metis assms carrier_vecI dim_vec_of_basis_enum' image_subsetI)
-  have lincomb_sum: "lincomb c A = vec_of_basis_enum (\<Sum>b\<in>B. c' b *\<^sub>C b)" 
+  have lincomb_sum: "lincomb c A = vec_of_basis_enum (\<Sum>b\<in>B. c' b *\<^sub>C b)"
     if B_def: "B = basis_enum_of_vec ` A" and \<open>finite A\<close>
       and AX: "A \<subseteq> vec_of_basis_enum ` X" and c'_def: "\<And>b. c' b = c (vec_of_basis_enum b)"
     for c c' A and B::"'a set"
     unfolding B_def using \<open>finite A\<close> AX
   proof induction
     case empty
     then show ?case
       by (simp add: assms vec_of_basis_enum_zero)
   next
     case (insert x F)
     then have IH: "lincomb c F = vec_of_basis_enum (\<Sum>b\<in>basis_enum_of_vec ` F. c' b *\<^sub>C b)"
       (is "_ = ?sum")
       by simp
     have xx: "vec_of_basis_enum (basis_enum_of_vec x :: 'a) = x"
       apply (rule basis_enum_of_vec_inverse)
       using assms carrier carrier_vecD insert.prems by auto
     have "lincomb c (insert x F) = c x \<cdot>\<^sub>v x + lincomb c F"
       apply (rule lincomb_insert2)
       using insert.hyps insert.prems carrier by auto
     also have "c x \<cdot>\<^sub>v x = vec_of_basis_enum (c' (basis_enum_of_vec x) *\<^sub>C (basis_enum_of_vec x :: 'a))"
       by (simp add: xx vec_of_basis_enum_scaleC c'_def)
     also note IH
     also have
       "vec_of_basis_enum (c' (basis_enum_of_vec x) *\<^sub>C (basis_enum_of_vec x :: 'a)) + ?sum
           = vec_of_basis_enum (\<Sum>b\<in>basis_enum_of_vec ` insert x F. c' b *\<^sub>C b)"
       apply simp apply (rule sym)
       apply (subst sum.insert)
-      using \<open>finite F\<close> \<open>x \<notin> F\<close> dim_vec_of_basis_enum' insert.prems 
+      using \<open>finite F\<close> \<open>x \<notin> F\<close> dim_vec_of_basis_enum' insert.prems
         vec_of_basis_enum_add c'_def by auto
     finally show ?case
       by -
   qed
 
   show ?thesis
   proof auto
     fix x assume "x \<in> local.span (vec_of_basis_enum ` X)"
     then obtain c A where xA: "x = lincomb c A" and "finite A" and AX: "A \<subseteq> vec_of_basis_enum ` X"
       unfolding span_def by auto
     define B::"'a set" and c' where "B = basis_enum_of_vec ` A"
       and "c' b = c (vec_of_basis_enum b)" for b::'a
     note xA
     also have "lincomb c A = vec_of_basis_enum (\<Sum>b\<in>B. c' b *\<^sub>C b)"
       using B_def \<open>finite A\<close> AX c'_def by (rule lincomb_sum)
     also have "\<dots> \<in> vec_of_basis_enum ` cspan X"
       unfolding complex_vector.span_explicit
       apply (rule imageI) apply (rule CollectI)
       apply (rule exI) apply (rule exI)
       using \<open>finite A\<close> AX by (auto simp: B_def)
     finally show "x \<in> vec_of_basis_enum ` cspan X"
       by -
   next
-    fix x assume "x \<in> cspan X" 
+    fix x assume "x \<in> cspan X"
     then obtain c' B where x: "x = (\<Sum>b\<in>B. c' b *\<^sub>C b)" and "finite B" and BX: "B \<subseteq> X"
       unfolding complex_vector.span_explicit by auto
     define A and c where "A = vec_of_basis_enum ` B"
       and "c b = c' (basis_enum_of_vec b)" for b
     have "vec_of_basis_enum x = vec_of_basis_enum (\<Sum>b\<in>B. c' b *\<^sub>C b)"
       using x by simp
     also have "\<dots> = lincomb c A"
       apply (rule lincomb_sum[symmetric])
       unfolding A_def c_def using BX \<open>finite B\<close>
       by (auto simp: image_image)
     also have "\<dots> \<in> span (vec_of_basis_enum ` X)"
       unfolding span_def apply (rule CollectI)
       apply (rule exI, rule exI)
       unfolding A_def using \<open>finite B\<close> BX by auto
     finally show "vec_of_basis_enum x \<in> local.span (vec_of_basis_enum ` X)"
       by -
   qed
 qed
 
 lemma (in complex_vec_space) basis_enum_of_vec_span:
   assumes "length (canonical_basis :: 'a list) = n"
   assumes "Y \<subseteq> carrier_vec n"
   shows "basis_enum_of_vec ` local.span Y = cspan (basis_enum_of_vec ` Y :: 'a::basis_enum set)"
 proof -
   define X::"'a set" where "X = basis_enum_of_vec ` Y"
   then have "cspan (basis_enum_of_vec ` Y :: 'a set) = basis_enum_of_vec ` vec_of_basis_enum ` cspan X"
     by (simp add: image_image)
   also have "\<dots> = basis_enum_of_vec ` local.span (vec_of_basis_enum ` X)"
     apply (subst vec_of_basis_enum_cspan)
     using assms by simp_all
   also have "vec_of_basis_enum ` X = Y"
     unfolding X_def image_image
     apply (rule image_cong[where g=id and M=Y and N=Y, simplified])
     using assms(1) assms(2) by auto
   finally show ?thesis
     by simp
 qed
 
 lemma vec_of_basis_enum_canonical_basis:
   assumes "i < length (canonical_basis :: 'a list)"
   shows "vec_of_basis_enum (canonical_basis!i :: 'a)
        = unit_vec (length (canonical_basis :: 'a::basis_enum list)) i"
   by (metis assms basis_enum_of_vec_inverse basis_enum_of_vec_unit_vec index_unit_vec(3))
 
-lemma vec_of_basis_enum_times: 
+lemma vec_of_basis_enum_times:
   fixes \<psi> \<phi> :: "'a::one_dim"
   shows "vec_of_basis_enum (\<psi> * \<phi>)
    = vec_of_list [vec_index (vec_of_basis_enum \<psi>) 0 * vec_index (vec_of_basis_enum \<phi>) 0]"
 proof -
   have [simp]: \<open>crepresentation {1} x 1 = one_dim_iso x\<close> for x :: 'a
     apply (subst one_dim_scaleC_1[where x=x, symmetric])
     apply (subst complex_vector.representation_scale)
     by (auto simp add: complex_vector.span_base complex_vector.representation_basis)
   show ?thesis
     apply (rule eq_vecI)
     by (auto simp: vec_of_basis_enum_def)
 qed
 
-lemma vec_of_basis_enum_to_inverse: 
+lemma vec_of_basis_enum_to_inverse:
   fixes \<psi> :: "'a::one_dim"
   shows "vec_of_basis_enum (inverse \<psi>) = vec_of_list [inverse (vec_index (vec_of_basis_enum \<psi>) 0)]"
 proof -
   have [simp]: \<open>crepresentation {1} x 1 = one_dim_iso x\<close> for x :: 'a
     apply (subst one_dim_scaleC_1[where x=x, symmetric])
     apply (subst complex_vector.representation_scale)
     by (auto simp add: complex_vector.span_base complex_vector.representation_basis)
   show ?thesis
     apply (rule eq_vecI)
      apply (auto simp: vec_of_basis_enum_def)
     by (metis complex_vector.scale_cancel_right one_dim_inverse one_dim_scaleC_1 zero_neq_one)
 qed
 
-lemma vec_of_basis_enum_divide: 
+lemma vec_of_basis_enum_divide:
   fixes \<psi> \<phi> :: "'a::one_dim"
   shows "vec_of_basis_enum (\<psi> / \<phi>)
    = vec_of_list [vec_index (vec_of_basis_enum \<psi>) 0 / vec_index (vec_of_basis_enum \<phi>) 0]"
   by (simp add: divide_inverse vec_of_basis_enum_to_inverse vec_of_basis_enum_times)
 
 lemma vec_of_basis_enum_1: "vec_of_basis_enum (1 :: 'a::one_dim) = vec_of_list [1]"
 proof -
   have [simp]: \<open>crepresentation {1} x 1 = one_dim_iso x\<close> for x :: 'a
     apply (subst one_dim_scaleC_1[where x=x, symmetric])
     apply (subst complex_vector.representation_scale)
     by (auto simp add: complex_vector.span_base complex_vector.representation_basis)
   show ?thesis
     apply (rule eq_vecI)
     by (auto simp: vec_of_basis_enum_def)
 qed
 
 lemma vec_of_basis_enum_ell2_component:
-  fixes \<psi> :: \<open>'a::enum ell2\<close> 
+  fixes \<psi> :: \<open>'a::enum ell2\<close>
   assumes [simp]: \<open>i < CARD('a)\<close>
   shows \<open>vec_of_basis_enum \<psi> $ i = Rep_ell2 \<psi> (Enum.enum ! i)\<close>
 proof -
   let ?i = \<open>Enum.enum ! i\<close>
   have \<open>Rep_ell2 \<psi> (Enum.enum ! i) = \<langle>ket ?i, \<psi>\<rangle>\<close>
     by (simp add: cinner_ket_left)
   also have \<open>\<dots> = vec_of_basis_enum \<psi> \<bullet>c vec_of_basis_enum (ket ?i :: 'a ell2)\<close>
     by (rule cscalar_prod_vec_of_basis_enum[symmetric])
   also have \<open>\<dots> = vec_of_basis_enum \<psi> \<bullet>c unit_vec (CARD('a)) i\<close>
     by (simp add: vec_of_basis_enum_ket enum_idx_enum)
   also have \<open>\<dots> = vec_of_basis_enum \<psi> \<bullet> unit_vec (CARD('a)) i\<close>
     by (smt (verit, best) assms carrier_vecI conjugate_conjugate_sprod conjugate_id conjugate_vec_sprod_comm dim_vec_conjugate eq_vecI index_unit_vec(3) scalar_prod_left_unit vec_index_conjugate)
   also have \<open>\<dots> = vec_of_basis_enum \<psi> $ i\<close>
     by simp
   finally show ?thesis
     by simp
 qed
 
 
 lemma corthogonal_vec_of_basis_enum:
   fixes S :: "'a::onb_enum list"
   shows "corthogonal (map vec_of_basis_enum S) \<longleftrightarrow> is_ortho_set (set S) \<and> distinct S"
 proof auto
   assume assm: \<open>corthogonal (map vec_of_basis_enum S)\<close>
   then show \<open>is_ortho_set (set S)\<close>
     by (smt (verit, ccfv_SIG) cinner_eq_zero_iff corthogonal_def cscalar_prod_vec_of_basis_enum in_set_conv_nth is_ortho_set_def length_map nth_map)
   show \<open>distinct S\<close>
-    using assm corthogonal_distinct distinct_map by blast 
+    using assm corthogonal_distinct distinct_map by blast
 next
   assume \<open>is_ortho_set (set S)\<close> and \<open>distinct S\<close>
   then show \<open>corthogonal (map vec_of_basis_enum S)\<close>
     by (smt (verit, ccfv_threshold) cinner_eq_zero_iff corthogonalI cscalar_prod_vec_of_basis_enum is_ortho_set_def length_map length_map nth_eq_iff_index_eq nth_map nth_map nth_mem nth_mem)
 qed
 
 subsection \<open>Isomorphism between bounded linear functions and matrices\<close>
 
 
 text \<open>We define the canonical isomorphism between \<^typ>\<open>'a::basis_enum \<Rightarrow>\<^sub>C\<^sub>L'b::basis_enum\<close>
-  and the complex \<^term>\<open>n*m\<close>-matrices (where n,m are the dimensions of \<^typ>\<open>'a\<close>, \<^typ>\<open>'b\<close>, 
+  and the complex \<^term>\<open>n*m\<close>-matrices (where n,m are the dimensions of \<^typ>\<open>'a\<close>, \<^typ>\<open>'b\<close>,
   respectively). This is possible if \<^typ>\<open>'a\<close>, \<^typ>\<open>'b\<close> are of class \<^class>\<open>basis_enum\<close>
   since that class fixes a finite canonical basis. Matrices are represented using
   the \<^typ>\<open>complex mat\<close> type from \<^session>\<open>Jordan_Normal_Form\<close>.
   (The isomorphism will be called \<^term>\<open>mat_of_cblinfun\<close> below.)\<close>
 
 definition mat_of_cblinfun :: \<open>'a::{basis_enum,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L'b::{basis_enum,complex_normed_vector} \<Rightarrow> complex mat\<close> where
-  \<open>mat_of_cblinfun f = 
+  \<open>mat_of_cblinfun f =
     mat (length (canonical_basis :: 'b list)) (length (canonical_basis :: 'a list)) (
     \<lambda> (i, j). crepresentation (set (canonical_basis::'b list)) (f *\<^sub>V ((canonical_basis::'a list)!j)) ((canonical_basis::'b list)!i))\<close>
   for f
 
-lift_definition cblinfun_of_mat :: \<open>complex mat \<Rightarrow> 'a::{basis_enum,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L'b::{basis_enum,complex_normed_vector}\<close> is  
+lift_definition cblinfun_of_mat :: \<open>complex mat \<Rightarrow> 'a::{basis_enum,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L'b::{basis_enum,complex_normed_vector}\<close> is
   \<open>\<lambda>M. \<lambda>v. (if M\<in>carrier_mat (length (canonical_basis :: 'b list)) (length (canonical_basis :: 'a list))
            then basis_enum_of_vec (M *\<^sub>v vec_of_basis_enum v)
            else 0)\<close>
 proof
   fix M :: "complex mat"
   define m where "m = length (canonical_basis :: 'b list)"
   define n where "n = length (canonical_basis :: 'a list)"
-  define f::"complex mat \<Rightarrow> 'a \<Rightarrow> 'b" 
+  define f::"complex mat \<Rightarrow> 'a \<Rightarrow> 'b"
     where "f M v = (if M\<in>carrier_mat m n
-        then basis_enum_of_vec (M *\<^sub>v vec_of_basis_enum (v::'a)) 
-        else (0::'b))" 
+        then basis_enum_of_vec (M *\<^sub>v vec_of_basis_enum (v::'a))
+        else (0::'b))"
     for M::"complex mat" and v::'a
 
   show add: \<open>f M (b1 + b2) = f M b1 + f M b2\<close> for b1 b2
     apply (auto simp: f_def)
     by (metis (mono_tags, lifting) carrier_matD(1) carrier_vec_dim_vec dim_mult_mat_vec dim_vec_of_basis_enum' m_def mult_add_distrib_mat_vec n_def basis_enum_of_vec_add vec_of_basis_enum_add)
 
   show scale: \<open>f M (c *\<^sub>C b) = c *\<^sub>C f M b\<close> for c b
     apply (auto simp: f_def)
     by (metis carrier_matD(1) carrier_vec_dim_vec dim_mult_mat_vec dim_vec_of_basis_enum' m_def mult_mat_vec n_def basis_enum_of_vec_mult vec_of_basis_enum_scaleC)
 
   from add scale have \<open>clinear (f M)\<close>
     by (simp add: clinear_iff)
 
   show \<open>\<exists>K. \<forall>b. norm (f M b) \<le> norm b * K\<close>
   proof (cases "M\<in>carrier_mat m n")
     case True
     have f_def': "f M v = basis_enum_of_vec (M *\<^sub>v (vec_of_basis_enum v))" for v
-      using True f_def 
-        m_def n_def by auto      
-    have M_carrier_mat: 
+      using True f_def
+        m_def n_def by auto
+    have M_carrier_mat:
       "M \<in> carrier_mat m n"
       by (simp add: True)
     have "bounded_clinear (f M)"
       apply (rule bounded_clinear_finite_dim) using \<open>clinear (f M)\<close> by auto
     thus ?thesis
-      by (simp add: bounded_clinear.bounded) 
+      by (simp add: bounded_clinear.bounded)
   next
     case False
     thus ?thesis
       unfolding f_def m_def n_def
       by (metis (full_types) order_refl mult_eq_0_iff norm_eq_zero)
   qed
 qed
 
 lemma mat_of_cblinfun_ell2_carrier[simp]: \<open>mat_of_cblinfun (a::'a::enum ell2 \<Rightarrow>\<^sub>C\<^sub>L 'b::enum ell2) \<in> carrier_mat CARD('b) CARD('a)\<close>
   by (simp add: mat_of_cblinfun_def)
 
 lemma dim_row_mat_of_cblinfun[simp]: \<open>dim_row (mat_of_cblinfun (a::'a::enum ell2 \<Rightarrow>\<^sub>C\<^sub>L 'b::enum ell2)) = CARD('b)\<close>
   by (simp add: mat_of_cblinfun_def)
 
 lemma dim_col_mat_of_cblinfun[simp]: \<open>dim_col (mat_of_cblinfun (a::'a::enum ell2 \<Rightarrow>\<^sub>C\<^sub>L 'b::enum ell2)) = CARD('a)\<close>
   by (simp add: mat_of_cblinfun_def)
 
 lemma mat_of_cblinfun_cblinfun_apply:
   "vec_of_basis_enum (F *\<^sub>V u) = mat_of_cblinfun F *\<^sub>v vec_of_basis_enum u"
   for F::"'a::{basis_enum,complex_normed_vector}  \<Rightarrow>\<^sub>C\<^sub>L 'b::{basis_enum,complex_normed_vector}" and u::'a
 proof (rule eq_vecI)
   show \<open>dim_vec (vec_of_basis_enum (F *\<^sub>V u)) = dim_vec (mat_of_cblinfun F *\<^sub>v vec_of_basis_enum u)\<close>
     by (simp add: dim_vec_of_basis_enum' mat_of_cblinfun_def)
 next
   fix i
   define BasisA where "BasisA = (canonical_basis::'a list)"
   define BasisB where "BasisB = (canonical_basis::'b list)"
   define nA where "nA = length (canonical_basis :: 'a list)"
   define nB where "nB = length (canonical_basis :: 'b list)"
   assume \<open>i < dim_vec (mat_of_cblinfun F *\<^sub>v vec_of_basis_enum u)\<close>
   then have [simp]: \<open>i < nB\<close>
     by (simp add: mat_of_cblinfun_def nB_def)
   define v where \<open>v = BasisB ! i\<close>
 
   have [simp]: \<open>dim_row (mat_of_cblinfun F) = nB\<close>
     by (simp add: mat_of_cblinfun_def nB_def)
   have [simp]: \<open>length BasisB = nB\<close>
     by (simp add: nB_def BasisB_def)
   have [simp]: \<open>length BasisA = nA\<close>
     using BasisA_def nA_def by auto
   have [simp]: \<open>cindependent (set BasisA)\<close>
     using BasisA_def is_cindependent_set by auto
   have [simp]: \<open>cindependent (set BasisB)\<close>
     using BasisB_def is_cindependent_set by blast
   have [simp]: \<open>cspan (set BasisB) = UNIV\<close>
     by (simp add: BasisB_def is_generator_set)
   have [simp]: \<open>cspan (set BasisA) = UNIV\<close>
     by (simp add: BasisA_def is_generator_set)
 
-  have \<open>(mat_of_cblinfun F *\<^sub>v vec_of_basis_enum u) $ i = 
+  have \<open>(mat_of_cblinfun F *\<^sub>v vec_of_basis_enum u) $ i =
           (\<Sum>j = 0..<nA. row (mat_of_cblinfun F) i $ j * crepresentation (set BasisA) u (vec_of_list BasisA $ j))\<close>
     by (auto simp: vec_of_basis_enum_def scalar_prod_def simp flip: BasisA_def)
   also have \<open>\<dots> = (\<Sum>j = 0..<nA. crepresentation (set BasisB) (F *\<^sub>V BasisA ! j) v
                                  * crepresentation (set BasisA) u (BasisA ! j))\<close>
     apply (rule sum.cong[OF refl])
     by (auto simp: vec_of_list_index mat_of_cblinfun_def scalar_prod_def v_def simp flip: BasisA_def BasisB_def)
   also have \<open>\<dots> = crepresentation (set BasisB) (F *\<^sub>V u) v\<close> (is \<open>(\<Sum>j=_..<_. ?lhs v j) = _\<close>)
   proof (rule complex_vector.representation_eqI[symmetric, THEN fun_cong])
     show \<open>cindependent (set BasisB)\<close> \<open>F *\<^sub>V u \<in> cspan (set BasisB)\<close>
       by simp_all
     show only_basis: \<open>(\<Sum>j = 0..<nA. ?lhs b j) \<noteq> 0 \<Longrightarrow> b \<in> set BasisB\<close> for b
       by (metis (mono_tags, lifting) complex_vector.representation_ne_zero mult_not_zero sum.not_neutral_contains_not_neutral)
     then show \<open>finite {b. (\<Sum>j = 0..<nA. ?lhs b j) \<noteq> 0}\<close>
       by (smt (z3) List.finite_set finite_subset mem_Collect_eq subsetI)
-    have \<open>(\<Sum>b | (\<Sum>j = 0..<nA. ?lhs b j) \<noteq> 0. (\<Sum>j = 0..<nA. ?lhs b j) *\<^sub>C b) = 
+    have \<open>(\<Sum>b | (\<Sum>j = 0..<nA. ?lhs b j) \<noteq> 0. (\<Sum>j = 0..<nA. ?lhs b j) *\<^sub>C b) =
             (\<Sum>b\<in>set BasisB. (\<Sum>j = 0..<nA. ?lhs b j) *\<^sub>C b)\<close>
       apply (rule sum.mono_neutral_left)
       using only_basis by auto
     also have \<open>\<dots> = (\<Sum>b\<in>set BasisB. (\<Sum>a\<in>set BasisA. crepresentation (set BasisB) (F *\<^sub>V a) b * crepresentation (set BasisA) u a) *\<^sub>C b)\<close>
       apply (subst sum.reindex_bij_betw[where h=\<open>nth BasisA\<close> and T=\<open>set BasisA\<close>])
        apply (metis BasisA_def \<open>length BasisA = nA\<close> atLeast0LessThan bij_betw_nth distinct_canonical_basis)
       by simp
     also have \<open>\<dots> = (\<Sum>a\<in>set BasisA. crepresentation (set BasisA) u a *\<^sub>C (\<Sum>b\<in>set BasisB. crepresentation (set BasisB) (F *\<^sub>V a) b *\<^sub>C b))\<close>
       apply (simp add: scaleC_sum_left scaleC_sum_right)
       apply (subst sum.swap)
       by (metis (no_types, lifting) mult.commute sum.cong)
     also have \<open>\<dots> = (\<Sum>a\<in>set BasisA. crepresentation (set BasisA) u a *\<^sub>C (F *\<^sub>V a))\<close>
       apply (subst complex_vector.sum_representation_eq)
       by auto
     also have \<open>\<dots> = F *\<^sub>V (\<Sum>a\<in>set BasisA. crepresentation (set BasisA) u a *\<^sub>C a)\<close>
       by (simp flip: cblinfun.scaleC_right cblinfun.sum_right)
     also have \<open>\<dots> = F *\<^sub>V u\<close>
       apply (subst complex_vector.sum_representation_eq)
       by auto
     finally show \<open>(\<Sum>b | (\<Sum>j = 0..<nA. ?lhs b j) \<noteq> 0. (\<Sum>j = 0..<nA. ?lhs b j) *\<^sub>C b) = F *\<^sub>V u\<close>
       by auto
   qed
   also have \<open>crepresentation (set BasisB) (F *\<^sub>V u) v = vec_of_basis_enum (F *\<^sub>V u) $ i\<close>
     by (auto simp: vec_of_list_index vec_of_basis_enum_def v_def simp flip: BasisB_def)
   finally show \<open>vec_of_basis_enum (F *\<^sub>V u) $ i = (mat_of_cblinfun F *\<^sub>v vec_of_basis_enum u) $ i\<close>
     by simp
 qed
 
 lemma basis_enum_of_vec_cblinfun_apply:
   fixes M :: "complex mat"
   defines "nA \<equiv> length (canonical_basis :: 'a::{basis_enum,complex_normed_vector} list)"
     and "nB \<equiv> length (canonical_basis :: 'b::{basis_enum,complex_normed_vector} list)"
   assumes "M \<in> carrier_mat nB nA" and "dim_vec x = nA"
   shows "basis_enum_of_vec (M *\<^sub>v x) = (cblinfun_of_mat M :: 'a \<Rightarrow>\<^sub>C\<^sub>L 'b) *\<^sub>V basis_enum_of_vec x"
   by (metis assms basis_enum_of_vec_inverse cblinfun_of_mat.rep_eq)
 
 
 lemma mat_of_cblinfun_inverse:
   "cblinfun_of_mat (mat_of_cblinfun B) = B"
   for B::"'a::{basis_enum,complex_normed_vector}  \<Rightarrow>\<^sub>C\<^sub>L 'b::{basis_enum,complex_normed_vector}"
 proof (rule cblinfun_eqI)
   fix x :: 'a define y where \<open>y = vec_of_basis_enum x\<close>
   then have \<open>cblinfun_of_mat (mat_of_cblinfun B) *\<^sub>V x = ((cblinfun_of_mat (mat_of_cblinfun B) :: 'a\<Rightarrow>\<^sub>C\<^sub>L'b) *\<^sub>V basis_enum_of_vec y)\<close>
     by simp
   also have \<open>\<dots> = basis_enum_of_vec (mat_of_cblinfun B *\<^sub>v vec_of_basis_enum (basis_enum_of_vec y :: 'a))\<close>
     apply (transfer fixing: B)
     by (simp add: mat_of_cblinfun_def)
   also have \<open>\<dots> = basis_enum_of_vec (vec_of_basis_enum (B *\<^sub>V x))\<close>
     by (simp add: mat_of_cblinfun_cblinfun_apply y_def)
   also have \<open>\<dots> = B *\<^sub>V x\<close>
     by simp
   finally show \<open>cblinfun_of_mat (mat_of_cblinfun B) *\<^sub>V x = B *\<^sub>V x\<close>
     by -
 qed
 
 lemma mat_of_cblinfun_inj: "inj mat_of_cblinfun"
   by (metis inj_on_def mat_of_cblinfun_inverse)
 
 lemma cblinfun_of_mat_inverse:
   fixes M::"complex mat"
   defines "nA \<equiv> length (canonical_basis :: 'a::{basis_enum,complex_normed_vector} list)"
     and "nB \<equiv> length (canonical_basis :: 'b::{basis_enum,complex_normed_vector} list)"
   assumes "M \<in> carrier_mat nB nA"
   shows "mat_of_cblinfun (cblinfun_of_mat M :: 'a \<Rightarrow>\<^sub>C\<^sub>L 'b) = M"
   by (smt (verit) assms(3) basis_enum_of_vec_inverse carrier_matD(1) carrier_vecD cblinfun_of_mat.rep_eq dim_mult_mat_vec eq_mat_on_vecI mat_carrier mat_of_cblinfun_def mat_of_cblinfun_cblinfun_apply nA_def nB_def)
 
-lemma cblinfun_of_mat_inj: "inj_on (cblinfun_of_mat::complex mat \<Rightarrow> 'a \<Rightarrow>\<^sub>C\<^sub>L 'b) 
+lemma cblinfun_of_mat_inj: "inj_on (cblinfun_of_mat::complex mat \<Rightarrow> 'a \<Rightarrow>\<^sub>C\<^sub>L 'b)
       (carrier_mat (length (canonical_basis :: 'b::{basis_enum,complex_normed_vector} list))
                    (length (canonical_basis :: 'a::{basis_enum,complex_normed_vector} list)))"
   using cblinfun_of_mat_inverse
   by (metis inj_onI)
 
 
 lemma cblinfun_eq_mat_of_cblinfunI:
   assumes "mat_of_cblinfun a = mat_of_cblinfun b"
   shows "a = b"
   by (metis assms mat_of_cblinfun_inverse)
 
 
 subsection \<open>Matrix operations\<close>
 
 lemma cblinfun_of_mat_plus:
-  defines "nA \<equiv> length (canonical_basis :: 'a::{basis_enum,complex_normed_vector} list)" 
+  defines "nA \<equiv> length (canonical_basis :: 'a::{basis_enum,complex_normed_vector} list)"
     and "nB \<equiv> length (canonical_basis :: 'b::{basis_enum,complex_normed_vector} list)"
   assumes [simp,intro]: "M \<in> carrier_mat nB nA" and [simp,intro]: "N \<in> carrier_mat nB nA"
   shows "(cblinfun_of_mat (M + N) :: 'a \<Rightarrow>\<^sub>C\<^sub>L 'b) = ((cblinfun_of_mat M + cblinfun_of_mat N))"
 proof -
   have [simp]: \<open>vec_of_basis_enum (v :: 'a) \<in> carrier_vec nA\<close> for v
     by (auto simp add: carrier_dim_vec dim_vec_of_basis_enum' nA_def)
   have [simp]: \<open>dim_row M = nB\<close> \<open>dim_row N = nB\<close>
     using carrier_matD(1) by auto
   show ?thesis
     apply (transfer fixing: M N)
     by (auto intro!: ext simp add: add_mult_distrib_mat_vec nA_def[symmetric] nB_def[symmetric]
         add_mult_distrib_mat_vec[where nr=nB and nc=nA] basis_enum_of_vec_add)
 qed
 
 lemma mat_of_cblinfun_zero:
-  "mat_of_cblinfun (0 :: ('a::{basis_enum,complex_normed_vector}  \<Rightarrow>\<^sub>C\<^sub>L 'b::{basis_enum,complex_normed_vector})) 
+  "mat_of_cblinfun (0 :: ('a::{basis_enum,complex_normed_vector}  \<Rightarrow>\<^sub>C\<^sub>L 'b::{basis_enum,complex_normed_vector}))
   = 0\<^sub>m (length (canonical_basis :: 'b list)) (length (canonical_basis :: 'a list))"
   unfolding mat_of_cblinfun_def
   by (auto simp: complex_vector.representation_zero)
 
 lemma mat_of_cblinfun_plus:
   "mat_of_cblinfun (F + G) = mat_of_cblinfun F + mat_of_cblinfun G"
   for F G::"'a::{basis_enum,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L'b::{basis_enum,complex_normed_vector}"
   by (auto simp add: mat_of_cblinfun_def cblinfun.add_left complex_vector.representation_add)
 
 lemma mat_of_cblinfun_id:
   "mat_of_cblinfun (id_cblinfun :: ('a::{basis_enum,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L'a)) = 1\<^sub>m (length (canonical_basis :: 'a list))"
   apply (rule eq_matI)
   by (auto simp: mat_of_cblinfun_def complex_vector.representation_basis is_cindependent_set nth_eq_iff_index_eq)
 
 lemma mat_of_cblinfun_1:
   "mat_of_cblinfun (1 :: ('a::one_dim \<Rightarrow>\<^sub>C\<^sub>L'b::one_dim)) = 1\<^sub>m 1"
   apply (rule eq_matI)
   by (auto simp: mat_of_cblinfun_def complex_vector.representation_basis nth_eq_iff_index_eq)
 
 lemma mat_of_cblinfun_uminus:
-  "mat_of_cblinfun (- M) = - mat_of_cblinfun M" 
+  "mat_of_cblinfun (- M) = - mat_of_cblinfun M"
   for M::"'a::{basis_enum,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L'b::{basis_enum,complex_normed_vector}"
 proof-
   define nA where "nA = length (canonical_basis :: 'a list)"
   define nB where "nB = length (canonical_basis :: 'b list)"
   have M1: "mat_of_cblinfun M \<in> carrier_mat nB nA"
     unfolding nB_def nA_def
     by (metis add.right_neutral add_carrier_mat mat_of_cblinfun_plus mat_of_cblinfun_zero nA_def
-        nB_def zero_carrier_mat) 
+        nB_def zero_carrier_mat)
   have M2: "mat_of_cblinfun (-M) \<in> carrier_mat nB nA"
-    by (metis add_carrier_mat mat_of_cblinfun_plus mat_of_cblinfun_zero diff_0 nA_def nB_def 
+    by (metis add_carrier_mat mat_of_cblinfun_plus mat_of_cblinfun_zero diff_0 nA_def nB_def
         uminus_add_conv_diff zero_carrier_mat)
   have "mat_of_cblinfun (M - M) =  0\<^sub>m nB nA"
     unfolding nA_def nB_def
     by (simp add: mat_of_cblinfun_zero)
   moreover have "mat_of_cblinfun (M - M) = mat_of_cblinfun M + mat_of_cblinfun (- M)"
     by (metis mat_of_cblinfun_plus pth_2)
   ultimately have "mat_of_cblinfun M + mat_of_cblinfun (- M) = 0\<^sub>m nB nA"
     by simp
   thus ?thesis
     using M1 M2
-    by (smt add_uminus_minus_mat assoc_add_mat comm_add_mat left_add_zero_mat minus_r_inv_mat 
-        uminus_carrier_mat) 
+    by (smt add_uminus_minus_mat assoc_add_mat comm_add_mat left_add_zero_mat minus_r_inv_mat
+        uminus_carrier_mat)
 qed
 
 lemma mat_of_cblinfun_minus:
-  "mat_of_cblinfun (M - N) = mat_of_cblinfun M - mat_of_cblinfun N" 
+  "mat_of_cblinfun (M - N) = mat_of_cblinfun M - mat_of_cblinfun N"
   for M::"'a::{basis_enum,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L 'b::{basis_enum,complex_normed_vector}" and N::"'a \<Rightarrow>\<^sub>C\<^sub>L'b"
   by (smt (z3) add_uminus_minus_mat mat_of_cblinfun_uminus mat_carrier mat_of_cblinfun_def mat_of_cblinfun_plus pth_2)
 
 lemma cblinfun_of_mat_uminus:
-  defines "nA \<equiv> length (canonical_basis :: 'a::{basis_enum,complex_normed_vector} list)" 
+  defines "nA \<equiv> length (canonical_basis :: 'a::{basis_enum,complex_normed_vector} list)"
     and "nB \<equiv> length (canonical_basis :: 'b::{basis_enum,complex_normed_vector} list)"
   assumes "M \<in> carrier_mat nB nA"
   shows "(cblinfun_of_mat (-M) :: 'a \<Rightarrow>\<^sub>C\<^sub>L 'b) = - cblinfun_of_mat M"
-  by (smt assms add.group_axioms add.right_neutral add_minus_cancel add_uminus_minus_mat 
-      cblinfun_of_mat_plus group.inverse_inverse mat_of_cblinfun_inverse mat_of_cblinfun_zero 
+  by (smt assms add.group_axioms add.right_neutral add_minus_cancel add_uminus_minus_mat
+      cblinfun_of_mat_plus group.inverse_inverse mat_of_cblinfun_inverse mat_of_cblinfun_zero
       minus_r_inv_mat uminus_carrier_mat)
 
 lemma cblinfun_of_mat_minus:
   fixes M::"complex mat"
-  defines "nA \<equiv> length (canonical_basis :: 'a::{basis_enum,complex_normed_vector} list)" 
+  defines "nA \<equiv> length (canonical_basis :: 'a::{basis_enum,complex_normed_vector} list)"
     and "nB \<equiv> length (canonical_basis :: 'b::{basis_enum,complex_normed_vector} list)"
   assumes "M \<in> carrier_mat nB nA" and "N \<in> carrier_mat nB nA"
   shows "(cblinfun_of_mat (M - N) :: 'a \<Rightarrow>\<^sub>C\<^sub>L 'b) = cblinfun_of_mat M - cblinfun_of_mat N"
   by (metis assms add_uminus_minus_mat cblinfun_of_mat_plus cblinfun_of_mat_uminus pth_2 uminus_carrier_mat)
 
 lemma cblinfun_of_mat_times:
   fixes M N ::"complex mat"
-  defines "nA \<equiv> length (canonical_basis :: 'a::{basis_enum,complex_normed_vector} list)" 
+  defines "nA \<equiv> length (canonical_basis :: 'a::{basis_enum,complex_normed_vector} list)"
     and "nB \<equiv> length (canonical_basis :: 'b::{basis_enum,complex_normed_vector} list)"
     and "nC \<equiv> length (canonical_basis :: 'c::{basis_enum,complex_normed_vector} list)"
   assumes a1: "M \<in> carrier_mat nC nB" and a2: "N \<in> carrier_mat nB nA"
   shows  "cblinfun_of_mat (M * N) = ((cblinfun_of_mat M)::'b \<Rightarrow>\<^sub>C\<^sub>L'c) o\<^sub>C\<^sub>L ((cblinfun_of_mat N)::'a \<Rightarrow>\<^sub>C\<^sub>L'b)"
 proof -
   have b1: "((cblinfun_of_mat M)::'b \<Rightarrow>\<^sub>C\<^sub>L'c) v = basis_enum_of_vec (M *\<^sub>v vec_of_basis_enum v)"
     for v
     by (metis assms(4) cblinfun_of_mat.rep_eq nB_def nC_def)
   have b2: "((cblinfun_of_mat N)::'a \<Rightarrow>\<^sub>C\<^sub>L'b) v = basis_enum_of_vec (N *\<^sub>v vec_of_basis_enum v)"
     for v
     by (metis assms(5) cblinfun_of_mat.rep_eq nA_def nB_def)
   have b3: "((cblinfun_of_mat (M * N))::'a \<Rightarrow>\<^sub>C\<^sub>L'c) v
        = basis_enum_of_vec ((M * N) *\<^sub>v vec_of_basis_enum v)"
     for v
     by (metis assms(4) assms(5) cblinfun_of_mat.rep_eq mult_carrier_mat nA_def nC_def)
   have "(basis_enum_of_vec ((M * N) *\<^sub>v vec_of_basis_enum v)::'c)
       = (basis_enum_of_vec (M *\<^sub>v ( vec_of_basis_enum ( (basis_enum_of_vec (N *\<^sub>v vec_of_basis_enum v))::'b ))))"
     for v::'a
   proof-
     have c1: "vec_of_basis_enum (basis_enum_of_vec x :: 'b) = x"
       if "dim_vec x = nB"
       for x::"complex vec"
       using that unfolding nB_def
       by simp
     have c2: "vec_of_basis_enum v \<in> carrier_vec nA"
-      by (metis (mono_tags, hide_lams) add.commute carrier_vec_dim_vec index_add_vec(2) 
-          index_zero_vec(2) nA_def vec_of_basis_enum_add basis_enum_of_vec_inverse)      
+      by (metis (mono_tags, opaque_lifting) add.commute carrier_vec_dim_vec index_add_vec(2)
+          index_zero_vec(2) nA_def vec_of_basis_enum_add basis_enum_of_vec_inverse)
     have "(M * N) *\<^sub>v vec_of_basis_enum v = M *\<^sub>v (N *\<^sub>v vec_of_basis_enum v)"
-      using Matrix.assoc_mult_mat_vec a1 a2 c2 by blast      
+      using Matrix.assoc_mult_mat_vec a1 a2 c2 by blast
     hence "(basis_enum_of_vec ((M * N) *\<^sub>v vec_of_basis_enum v)::'c)
         = (basis_enum_of_vec (M *\<^sub>v (N *\<^sub>v vec_of_basis_enum v))::'c)"
       by simp
-    also have "\<dots> = 
+    also have "\<dots> =
       (basis_enum_of_vec (M *\<^sub>v ( vec_of_basis_enum ( (basis_enum_of_vec (N *\<^sub>v vec_of_basis_enum v))::'b ))))"
-      using c1 a2 by auto 
+      using c1 a2 by auto
     finally show ?thesis by simp
   qed
   thus ?thesis using b1 b2 b3
-    by (simp add: cblinfun_eqI scaleC_cblinfun.rep_eq)    
+    by (simp add: cblinfun_eqI scaleC_cblinfun.rep_eq)
 qed
 
 lemma cblinfun_of_mat_adjoint:
   defines "nA \<equiv> length (canonical_basis :: 'a::onb_enum list)"
-    and "nB \<equiv> length (canonical_basis :: 'b::onb_enum list)" 
+    and "nB \<equiv> length (canonical_basis :: 'b::onb_enum list)"
   fixes M:: "complex mat"
   assumes "M \<in> carrier_mat nB nA"
   shows "((cblinfun_of_mat (mat_adjoint M)) :: 'b \<Rightarrow>\<^sub>C\<^sub>L 'a) = (cblinfun_of_mat M)*"
 proof (rule adjoint_eqI)
   show "\<langle>cblinfun_of_mat (mat_adjoint M) *\<^sub>V x, y\<rangle> =
            \<langle>x, cblinfun_of_mat M *\<^sub>V y\<rangle>"
     for x::'b and y::'a
   proof-
     define u where "u = vec_of_basis_enum x"
     define v where "v = vec_of_basis_enum y"
     have c1: "vec_of_basis_enum ((cblinfun_of_mat (mat_adjoint M) *\<^sub>V x)::'a) = (mat_adjoint M) *\<^sub>v u"
       unfolding u_def
       by (metis (mono_tags, lifting) assms(3) cblinfun_of_mat_inverse map_carrier_mat mat_adjoint_def' mat_of_cblinfun_cblinfun_apply nA_def nB_def transpose_carrier_mat)
     have c2: "(vec_of_basis_enum ((cblinfun_of_mat M *\<^sub>V y)::'b))
         = M *\<^sub>v v"
       by (metis assms(3) cblinfun_of_mat_inverse mat_of_cblinfun_cblinfun_apply nA_def nB_def v_def)
     have c3: "dim_vec v = nA"
       unfolding v_def nA_def vec_of_basis_enum_def
       by (simp add:)
     have c4: "dim_vec u = nB"
       unfolding u_def nB_def vec_of_basis_enum_def
       by (simp add:)
     have "v \<bullet>c ((mat_adjoint M) *\<^sub>v u) = (M *\<^sub>v v) \<bullet>c u"
-      using c3 c4 cscalar_prod_adjoint assms(3) by blast      
+      using c3 c4 cscalar_prod_adjoint assms(3) by blast
     hence "v \<bullet>c (vec_of_basis_enum ((cblinfun_of_mat (mat_adjoint M) *\<^sub>V x)::'a))
         = (vec_of_basis_enum ((cblinfun_of_mat M *\<^sub>V y)::'b)) \<bullet>c u"
       using c1 c2 by simp
     thus "\<langle>cblinfun_of_mat (mat_adjoint M) *\<^sub>V x, y\<rangle> =
           \<langle>x, cblinfun_of_mat M *\<^sub>V y\<rangle>"
       unfolding u_def v_def
-      by (simp add: cscalar_prod_vec_of_basis_enum)      
+      by (simp add: cscalar_prod_vec_of_basis_enum)
   qed
 qed
 
 lemma mat_of_cblinfun_classical_operator:
   fixes f::"'a::enum \<Rightarrow> 'b::enum option"
   shows "mat_of_cblinfun (classical_operator f) = mat (CARD('b)) (CARD('a))
            (\<lambda>(r,c). if f (Enum.enum!c) = Some (Enum.enum!r) then 1 else 0)"
 proof -
   define nA where "nA = CARD('a)"
   define nB where "nB = CARD('b)"
   define BasisA where "BasisA = (canonical_basis::'a ell2 list)"
   define BasisB where "BasisB = (canonical_basis::'b ell2 list)"
   have "mat_of_cblinfun (classical_operator f) \<in> carrier_mat nB nA"
     unfolding nA_def nB_def by simp
   moreover have "nA = CARD ('a)"
     unfolding nA_def
-    by (simp add:)    
+    by (simp add:)
   moreover have "nB = CARD ('b)"
     unfolding nB_def
     by (simp add:)
   ultimately have "mat_of_cblinfun (classical_operator f) \<in> carrier_mat (CARD('b)) (CARD('a))"
     unfolding nA_def nB_def
     by simp
-  moreover have "(mat_of_cblinfun (classical_operator f))$$(r,c) 
+  moreover have "(mat_of_cblinfun (classical_operator f))$$(r,c)
   = (mat (CARD('b)) (CARD('a))
     (\<lambda>(r,c). if f (Enum.enum!c) = Some (Enum.enum!r) then 1 else 0))$$(r,c)"
     if a1: "r < CARD('b)" and a2: "c < CARD('a)"
     for r c
   proof-
     have "CARD('a) = length (enum_class.enum::'a list)"
       using card_UNIV_length_enum[where 'a = 'a] .
     hence x1: "BasisA!c = ket ((Enum.enum::'a list)!c)"
-      unfolding BasisA_def using a2 canonical_basis_ell2_def 
+      unfolding BasisA_def using a2 canonical_basis_ell2_def
         nth_map[where n = c and xs = "Enum.enum::'a list" and f = ket] by metis
     have cardb: "CARD('b) = length (enum_class.enum::'b list)"
       using card_UNIV_length_enum[where 'a = 'b] .
     hence x2: "BasisB!r = ket ((Enum.enum::'b list)!r)"
-      unfolding BasisB_def using a1 canonical_basis_ell2_def 
+      unfolding BasisB_def using a1 canonical_basis_ell2_def
         nth_map[where n = r and xs = "Enum.enum::'b list" and f = ket] by metis
     have "inj (map (ket::'b \<Rightarrow>_))"
-      by (meson injI ket_injective list.inj_map)      
+      by (meson injI ket_injective list.inj_map)
     hence "length (Enum.enum::'b list) = length (map (ket::'b \<Rightarrow>_) (Enum.enum::'b list))"
-      by simp      
+      by simp
     hence lengthBasisB: "CARD('b) = length BasisB"
-      unfolding BasisB_def canonical_basis_ell2_def using cardb 
+      unfolding BasisB_def canonical_basis_ell2_def using cardb
       by smt
     have v1: "(mat_of_cblinfun (classical_operator f))$$(r,c) = 0"
       if c1: "f (Enum.enum!c) = None"
     proof-
-      have "(classical_operator f) *\<^sub>V ket (Enum.enum!c) 
+      have "(classical_operator f) *\<^sub>V ket (Enum.enum!c)
           = (case f (Enum.enum!c) of None \<Rightarrow> 0 | Some i \<Rightarrow> ket i)"
         using classical_operator_ket_finite .
       also have "\<dots> = 0"
         using c1 by simp
       finally have "(classical_operator f) *\<^sub>V ket (Enum.enum!c) = 0" .
       hence *: "(classical_operator f) *\<^sub>V BasisA!c = 0"
         using x1 by simp
       hence "\<langle>BasisB!r, (classical_operator f) *\<^sub>V BasisA!c\<rangle> = 0"
         by simp
       thus ?thesis
         unfolding mat_of_cblinfun_def BasisA_def BasisB_def
         by (smt (verit, del_insts) BasisA_def * a1 a2 canonical_basis_length_ell2 complex_vector.representation_zero index_mat(1) old.prod.case)
     qed
     have v2: "(mat_of_cblinfun (classical_operator f))$$(r,c) = 0"
-      if c1: "f (Enum.enum!c) = Some (Enum.enum!r')" and c2: "r\<noteq>r'" 
+      if c1: "f (Enum.enum!c) = Some (Enum.enum!r')" and c2: "r\<noteq>r'"
         and c3: "r' < CARD('b)"
       for r'
     proof-
       have x3: "BasisB!r' = ket ((Enum.enum::'b list)!r')"
-        unfolding BasisB_def using cardb c3 canonical_basis_ell2_def 
-          nth_map[where n = r' and xs = "Enum.enum::'b list" and f = ket] 
+        unfolding BasisB_def using cardb c3 canonical_basis_ell2_def
+          nth_map[where n = r' and xs = "Enum.enum::'b list" and f = ket]
         by smt
       have "distinct BasisB"
-        unfolding BasisB_def 
-        by simp        
+        unfolding BasisB_def
+        by simp
       moreover have "r < length BasisB"
         using a1 lengthBasisB by simp
       moreover have "r' < length BasisB"
-        using c3 lengthBasisB by simp        
+        using c3 lengthBasisB by simp
       ultimately have h1: "BasisB!r \<noteq> BasisB!r'"
         using nth_eq_iff_index_eq[where xs = BasisB and i = r and j = r'] c2
         by blast
-      have "(classical_operator f) *\<^sub>V ket (Enum.enum!c) 
+      have "(classical_operator f) *\<^sub>V ket (Enum.enum!c)
           = (case f (Enum.enum!c) of None \<Rightarrow> 0 | Some i \<Rightarrow> ket i)"
         using classical_operator_ket_finite .
       also have "\<dots> = ket (Enum.enum!r')"
         using c1 by simp
       finally have "(classical_operator f) *\<^sub>V ket (Enum.enum!c) = ket (Enum.enum!r')" .
       hence *: "(classical_operator f) *\<^sub>V BasisA!c = BasisB!r'"
         using x1 x3 by simp
       moreover have "\<langle>BasisB!r, BasisB!r'\<rangle> = 0"
         using h1
         using BasisB_def \<open>r < length BasisB\<close> \<open>r' < length BasisB\<close> is_ortho_set_def is_orthonormal nth_mem
         by metis
       ultimately have "\<langle>BasisB!r, (classical_operator f) *\<^sub>V BasisA!c\<rangle> = 0"
         by simp
       thus ?thesis
         unfolding mat_of_cblinfun_def BasisA_def BasisB_def
         by (smt (z3) BasisA_def BasisB_def * \<open>r < length BasisB\<close> \<open>r' < length BasisB\<close> a2 canonical_basis_length_ell2 case_prod_conv complex_vector.representation_basis h1 index_mat(1) is_cindependent_set nth_mem)
     qed
     have "(mat_of_cblinfun (classical_operator f))$$(r,c) = 0"
       if b1: "f (Enum.enum!c) \<noteq> Some (Enum.enum!r)"
     proof (cases "f (Enum.enum!c) = None")
       case True thus ?thesis using v1 by blast
     next
       case False
       hence "\<exists>R. f (Enum.enum!c) = Some R"
         apply (induction "f (Enum.enum!c)")
          apply simp
         by simp
       then obtain R where R0: "f (Enum.enum!c) = Some R"
         by blast
       have "R \<in> set (Enum.enum::'b list)"
         using UNIV_enum by blast
       hence "\<exists>r'. R = (Enum.enum::'b list)!r' \<and> r' < length (Enum.enum::'b list)"
         by (metis in_set_conv_nth)
-      then obtain r' where u1: "R = (Enum.enum::'b list)!r'" 
+      then obtain r' where u1: "R = (Enum.enum::'b list)!r'"
         and u2: "r' < length (Enum.enum::'b list)"
         by blast
       have R1: "f (Enum.enum!c) = Some (Enum.enum!r')"
         using R0 u1 by blast
       have "Some ((Enum.enum::'b list)!r') \<noteq> Some ((Enum.enum::'b list)!r)"
       proof(rule classical)
         assume "\<not>(Some ((Enum.enum::'b list)!r') \<noteq> Some ((Enum.enum::'b list)!r))"
         hence "Some ((Enum.enum::'b list)!r') = Some ((Enum.enum::'b list)!r)"
           by blast
         hence "f (Enum.enum!c) = Some ((Enum.enum::'b list)!r)"
           using R1 by auto
         thus ?thesis
           using b1 by blast
       qed
       hence "((Enum.enum::'b list)!r') \<noteq> ((Enum.enum::'b list)!r)"
         by simp
       hence "r' \<noteq> r"
         by blast
       moreover have "r' < CARD('b)"
         using u2 cardb by simp
       ultimately show ?thesis using R1 v2[where r' = r'] by blast
     qed
     moreover have "(mat_of_cblinfun (classical_operator f))$$(r,c) = 1"
       if b1: "f (Enum.enum!c) = Some (Enum.enum!r)"
     proof-
       have "CARD('b) = length (enum_class.enum::'b list)"
         using card_UNIV_length_enum[where 'a = 'b].
       hence "length (map (ket::'b\<Rightarrow>_) enum_class.enum) = CARD('b)"
-        by simp        
+        by simp
       hence w0: "map (ket::'b\<Rightarrow>_) enum_class.enum ! r = ket (enum_class.enum ! r)"
         by (simp add: a1)
       have "CARD('a) = length (enum_class.enum::'a list)"
         using card_UNIV_length_enum[where 'a = 'a].
       hence "length (map (ket::'a\<Rightarrow>_) enum_class.enum) = CARD('a)"
-        by simp        
+        by simp
       hence "map (ket::'a\<Rightarrow>_) enum_class.enum ! c = ket (enum_class.enum ! c)"
-        by (simp add: a2)        
+        by (simp add: a2)
       hence "(classical_operator f) *\<^sub>V (BasisA!c) = (classical_operator f) *\<^sub>V (ket (Enum.enum!c))"
         unfolding BasisA_def canonical_basis_ell2_def by simp
       also have "... = (case f (enum_class.enum ! c) of None \<Rightarrow> 0 | Some x \<Rightarrow> ket x)"
         by (rule classical_operator_ket_finite)
       also have "\<dots> = BasisB!r"
-        using w0 b1 by (simp add: BasisB_def canonical_basis_ell2_def) 
+        using w0 b1 by (simp add: BasisB_def canonical_basis_ell2_def)
       finally have w1: "(classical_operator f) *\<^sub>V (BasisA!c) = BasisB!r"
-        by simp        
+        by simp
       have "(mat_of_cblinfun (classical_operator f))$$(r,c)
         = \<langle>BasisB!r, (classical_operator f) *\<^sub>V (BasisA!c)\<rangle>"
         unfolding BasisB_def BasisA_def mat_of_cblinfun_def
         using \<open>nA = CARD('a)\<close> \<open>nB = CARD('b)\<close> a1 a2 nA_def nB_def apply auto
         by (metis BasisA_def BasisB_def canonical_basis_length_ell2 cinner_canonical_basis complex_vector.representation_basis is_cindependent_set nth_mem w1)
       also have "\<dots> = \<langle>BasisB!r, BasisB!r\<rangle>"
-        using w1 by simp        
+        using w1 by simp
       also have "\<dots> = 1"
         unfolding BasisB_def
         using \<open>nB = CARD('b)\<close> a1 nB_def
         by (simp add: cinner_canonical_basis)
       finally show ?thesis by blast
     qed
     ultimately show ?thesis
-      by (simp add: a1 a2)            
+      by (simp add: a1 a2)
   qed
-  ultimately show ?thesis 
+  ultimately show ?thesis
     apply (rule_tac eq_matI) by auto
 qed
 
 lemma mat_of_cblinfun_compose:
-  "mat_of_cblinfun (F o\<^sub>C\<^sub>L G) = mat_of_cblinfun F * mat_of_cblinfun G" 
+  "mat_of_cblinfun (F o\<^sub>C\<^sub>L G) = mat_of_cblinfun F * mat_of_cblinfun G"
   for F::"'b::{basis_enum,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L 'c::{basis_enum,complex_normed_vector}"
     and G::"'a::{basis_enum,complex_normed_vector}  \<Rightarrow>\<^sub>C\<^sub>L 'b"
   by (smt (verit, del_insts) cblinfun_of_mat_inverse mat_carrier mat_of_cblinfun_def mat_of_cblinfun_inverse cblinfun_of_mat_times mult_carrier_mat)
 
 lemma mat_of_cblinfun_scaleC:
   "mat_of_cblinfun ((a::complex) *\<^sub>C F) = a \<cdot>\<^sub>m (mat_of_cblinfun F)"
   for F :: "'a::{basis_enum,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L 'b::{basis_enum,complex_normed_vector}"
   by (auto simp add: complex_vector.representation_scale mat_of_cblinfun_def)
 
 lemma mat_of_cblinfun_scaleR:
   "mat_of_cblinfun ((a::real) *\<^sub>R F) = (complex_of_real a) \<cdot>\<^sub>m (mat_of_cblinfun F)"
   unfolding scaleR_scaleC by (rule mat_of_cblinfun_scaleC)
 
 lemma mat_of_cblinfun_adj:
   "mat_of_cblinfun (F*) = mat_adjoint (mat_of_cblinfun F)"
   for F :: "'a::onb_enum \<Rightarrow>\<^sub>C\<^sub>L 'b::onb_enum"
   by (metis (no_types, lifting) cblinfun_of_mat_inverse map_carrier_mat mat_adjoint_def' mat_carrier cblinfun_of_mat_adjoint mat_of_cblinfun_def mat_of_cblinfun_inverse transpose_carrier_mat)
 
 lemma mat_of_cblinfun_vector_to_cblinfun:
   "mat_of_cblinfun (vector_to_cblinfun \<psi>)
        = mat_of_cols (length (canonical_basis :: 'a list)) [vec_of_basis_enum \<psi>]"
-  for \<psi>::"'a::{basis_enum,complex_normed_vector}"  
+  for \<psi>::"'a::{basis_enum,complex_normed_vector}"
   by (auto simp: mat_of_cols_Cons_index_0 mat_of_cblinfun_def vec_of_basis_enum_def vec_of_list_index)
 
 lemma mat_of_cblinfun_proj:
   fixes a::"'a::onb_enum"
   defines   "d \<equiv> length (canonical_basis :: 'a list)"
     and "norm2 \<equiv> (vec_of_basis_enum a) \<bullet>c (vec_of_basis_enum a)"
-  shows  "mat_of_cblinfun (proj a) = 
+  shows  "mat_of_cblinfun (proj a) =
       1 / norm2 \<cdot>\<^sub>m (mat_of_cols d [vec_of_basis_enum a]
                  * mat_of_rows d [conjugate (vec_of_basis_enum a)])" (is \<open>_ = ?rhs\<close>)
 proof (cases "a = 0")
-  case False 
+  case False
   have norm2: \<open>norm2 = (norm a)\<^sup>2\<close>
     by (simp add: cscalar_prod_vec_of_basis_enum norm2_def cdot_square_norm[symmetric, simplified])
   have [simp]: \<open>vec_of_basis_enum a \<in> carrier_vec d\<close>
-    by (simp add: carrier_vecI d_def dim_vec_of_basis_enum')
+    by (simp add: carrier_vecI d_def)
 
   have \<open>mat_of_cblinfun (proj a) = mat_of_cblinfun (proj (a /\<^sub>R norm a))\<close>
-    by (metis (mono_tags, hide_lams) ccspan_singleton_scaleC complex_vector.scale_eq_0_iff nonzero_imp_inverse_nonzero norm_eq_zero scaleR_scaleC scale_left_imp_eq)
+    by (metis (mono_tags, opaque_lifting) ccspan_singleton_scaleC complex_vector.scale_eq_0_iff
+        nonzero_imp_inverse_nonzero norm_eq_zero scaleR_scaleC scale_left_imp_eq)
   also have \<open>\<dots> = mat_of_cblinfun (selfbutter (a /\<^sub>R norm a))\<close>
     apply (subst butterfly_eq_proj)
     by (auto simp add: False)
   also have \<open>\<dots> = 1/norm2 \<cdot>\<^sub>m mat_of_cblinfun (selfbutter a)\<close>
     apply (simp add: mat_of_cblinfun_scaleC norm2)
     by (simp add: inverse_eq_divide power2_eq_square)
   also have \<open>\<dots> = 1 / norm2 \<cdot>\<^sub>m (mat_of_cblinfun (vector_to_cblinfun a :: complex \<Rightarrow>\<^sub>C\<^sub>L 'a) * mat_adjoint (mat_of_cblinfun (vector_to_cblinfun a :: complex \<Rightarrow>\<^sub>C\<^sub>L 'a)))\<close>
     by (simp add: butterfly_def mat_of_cblinfun_compose mat_of_cblinfun_adj)
   also have \<open>\<dots> = ?rhs\<close>
     by (simp add: mat_of_cblinfun_vector_to_cblinfun mat_adjoint_def flip: d_def)
   finally show ?thesis
     by -
 next
   case True
   show ?thesis
     apply (rule eq_matI)
     by (auto simp: True mat_of_cblinfun_zero vec_of_basis_enum_zero scalar_prod_def  mat_of_rows_index
         simp flip: d_def)
 qed
 
 
 lemma mat_of_cblinfun_ell2_component:
-  fixes a :: \<open>'a::enum ell2 \<Rightarrow>\<^sub>C\<^sub>L 'b::enum ell2\<close> 
+  fixes a :: \<open>'a::enum ell2 \<Rightarrow>\<^sub>C\<^sub>L 'b::enum ell2\<close>
   assumes [simp]: \<open>i < CARD('b)\<close> \<open>j < CARD('a)\<close>
   shows \<open>mat_of_cblinfun a $$ (i,j) = Rep_ell2 (a *\<^sub>V ket (Enum.enum ! j)) (Enum.enum ! i)\<close>
 proof -
   let ?i = \<open>Enum.enum ! i\<close> and ?j = \<open>Enum.enum ! j\<close> and ?aj = \<open>a *\<^sub>V ket (Enum.enum ! j)\<close>
   have \<open>Rep_ell2 ?aj (Enum.enum ! i) = vec_of_basis_enum ?aj $ i\<close>
     by (rule vec_of_basis_enum_ell2_component[symmetric], simp)
   also have \<open>\<dots> = (mat_of_cblinfun a *\<^sub>v vec_of_basis_enum (ket (enum_class.enum ! j) :: 'a ell2)) $ i\<close>
     by (simp add: mat_of_cblinfun_cblinfun_apply)
   also have \<open>\<dots> = (mat_of_cblinfun a *\<^sub>v unit_vec CARD('a) j) $ i\<close>
     by (simp add: vec_of_basis_enum_ket enum_idx_enum)
   also have \<open>\<dots> = mat_of_cblinfun a $$ (i, j)\<close>
     apply (subst mat_entry_explicit[where m=\<open>CARD('b)\<close>])
     by auto
   finally show ?thesis
     by auto
 qed
 
 
 lemma mat_of_cblinfun_sandwich:
   fixes a :: "(_::onb_enum, _::onb_enum) cblinfun"
   shows \<open>mat_of_cblinfun (sandwich a *\<^sub>V b) = (let a' = mat_of_cblinfun a in a' * mat_of_cblinfun b * mat_adjoint a')\<close>
   by (simp add: mat_of_cblinfun_compose sandwich_apply Let_def mat_of_cblinfun_adj)
 
 
 subsection \<open>Operations on subspaces\<close>
 
 lemma ccspan_gram_schmidt0_invariant:
   defines "basis_enum \<equiv> (basis_enum_of_vec :: _ \<Rightarrow> 'a::{basis_enum,complex_normed_vector})"
   defines "n \<equiv> length (canonical_basis :: 'a list)"
   assumes "set ws \<subseteq> carrier_vec n"
   shows "ccspan (set (map basis_enum (gram_schmidt0 n ws))) = ccspan (set (map basis_enum ws))"
 proof (transfer fixing: n ws basis_enum)
   interpret complex_vec_space.
   define gs where "gs = gram_schmidt0 n ws"
   have "closure (cspan (set (map basis_enum gs)))
      = cspan (set (map basis_enum gs))"
     apply (rule closure_finite_cspan)
     by simp
   also have "\<dots> = cspan (basis_enum ` set gs)"
     by simp
   also have "\<dots> = basis_enum ` span (set gs)"
     unfolding basis_enum_def
     apply (rule basis_enum_of_vec_span[symmetric])
     using n_def apply simp
     by (simp add: assms(3) cof_vec_space.gram_schmidt0_result(1) gs_def)
   also have "\<dots> = basis_enum ` span (set ws)"
     unfolding gs_def
     apply (subst gram_schmidt0_result(4)[where ws=ws, symmetric])
     using assms by auto
   also have "\<dots> = cspan (basis_enum ` set ws)"
     unfolding basis_enum_def
     apply (rule basis_enum_of_vec_span)
     using n_def apply simp
     by (simp add: assms(3))
   also have "\<dots> = cspan (set (map basis_enum ws))"
     by simp
   also have "\<dots> = closure (cspan (set (map basis_enum ws)))"
     apply (rule closure_finite_cspan[symmetric])
     by simp
   finally show "closure (cspan (set (map basis_enum gs)))
               = closure (cspan (set (map basis_enum ws)))".
 qed
 
-definition "is_subspace_of_vec_list n vs ws = 
+definition "is_subspace_of_vec_list n vs ws =
   (let ws' = gram_schmidt0 n ws in
      \<forall>v\<in>set vs. adjuster n v ws' = - v)"
 
 lemma ccspan_leq_using_vec:
   fixes A B :: "'a::{basis_enum,complex_normed_vector} list"
   shows "(ccspan (set A) \<le> ccspan (set B)) \<longleftrightarrow>
-    is_subspace_of_vec_list (length (canonical_basis :: 'a list)) 
+    is_subspace_of_vec_list (length (canonical_basis :: 'a list))
       (map vec_of_basis_enum A) (map vec_of_basis_enum B)"
 proof -
   define d Av Bv Bo
     where "d = length (canonical_basis :: 'a list)"
       and "Av = map vec_of_basis_enum A"
       and "Bv = map vec_of_basis_enum B"
-      and "Bo = gram_schmidt0 d Bv" 
+      and "Bo = gram_schmidt0 d Bv"
   interpret complex_vec_space d.
 
   have Av_carrier: "set Av \<subseteq> carrier_vec d"
     unfolding Av_def apply auto
     by (simp add: carrier_vecI d_def dim_vec_of_basis_enum')
   have Bv_carrier: "set Bv \<subseteq> carrier_vec d"
     unfolding Bv_def apply auto
     by (simp add: carrier_vecI d_def dim_vec_of_basis_enum')
   have Bo_carrier: "set Bo \<subseteq> carrier_vec d"
     apply (simp add: Bo_def)
     using Bv_carrier by (rule gram_schmidt0_result(1))
   have orth_Bo: "corthogonal Bo"
     apply (simp add: Bo_def)
     using Bv_carrier by (rule gram_schmidt0_result(3))
   have distinct_Bo: "distinct Bo"
     apply (simp add: Bo_def)
     using Bv_carrier by (rule gram_schmidt0_result(2))
 
   have "ccspan (set A) \<le> ccspan (set B) \<longleftrightarrow> cspan (set A) \<subseteq> cspan (set B)"
     apply (transfer fixing: A B)
     apply (subst closure_finite_cspan, simp)
     by (subst closure_finite_cspan, simp_all)
   also have "\<dots> \<longleftrightarrow> span (set Av) \<subseteq> span (set Bv)"
     apply (simp add: Av_def Bv_def)
     apply (subst vec_of_basis_enum_cspan[symmetric], simp add: d_def)
     apply (subst vec_of_basis_enum_cspan[symmetric], simp add: d_def)
     by (metis inj_image_subset_iff inj_on_def vec_of_basis_enum_inverse)
   also have "\<dots> \<longleftrightarrow> span (set Av) \<subseteq> span (set Bo)"
     unfolding Bo_def Av_def Bv_def
     apply (subst gram_schmidt0_result(4)[symmetric])
     by (simp_all add: carrier_dim_vec d_def dim_vec_of_basis_enum' image_subset_iff)
   also have "\<dots> \<longleftrightarrow> (\<forall>v\<in>set Av. adjuster d v Bo = - v)"
   proof (intro iffI ballI)
     fix v assume "v \<in> set Av" and "span (set Av) \<subseteq> span (set Bo)"
     then have "v \<in> span (set Bo)"
       using Av_carrier span_mem by auto
     have "adjuster d v Bo + v = 0\<^sub>v d"
       apply (rule adjuster_already_in_span)
       using Av_carrier \<open>v \<in> set Av\<close> Bo_carrier orth_Bo
         \<open>v \<in> span (set Bo)\<close> by simp_all
     then show "adjuster d v Bo = - v"
       using Av_carrier Bo_carrier \<open>v \<in> set Av\<close>
       by (metis (no_types, lifting) add.inv_equality adjuster_carrier' local.vec_neg subsetD)
   next
     fix v
     assume adj_minusv: "\<forall>v\<in>set Av. adjuster d v Bo = - v"
     have *: "adjuster d v Bo \<in> span (set Bo)" if "v \<in> set Av" for v
       apply (rule adjuster_in_span)
       using Bo_carrier that Av_carrier distinct_Bo by auto
     have "v \<in> span (set Bo)" if "v \<in> set Av" for v
       using *[OF that] adj_minusv[rule_format, OF that]
       apply auto
       by (metis (no_types, lifting) Av_carrier Bo_carrier adjust_nonzero distinct_Bo subsetD that uminus_l_inv_vec)
     then show "span (set Av) \<subseteq> span (set Bo)"
       apply auto
       by (meson Bo_carrier in_mono span_subsetI subsetI)
   qed
   also have "\<dots> = is_subspace_of_vec_list d Av Bv"
     by (simp add: is_subspace_of_vec_list_def d_def Bo_def)
   finally show "ccspan (set A) \<le> ccspan (set B) \<longleftrightarrow> is_subspace_of_vec_list d Av Bv"
     by simp
 qed
 
-lemma cblinfun_apply_ccspan_using_vec: 
+lemma cblinfun_apply_ccspan_using_vec:
   "A *\<^sub>S ccspan (set S) = ccspan (basis_enum_of_vec ` set (map ((*\<^sub>v) (mat_of_cblinfun A)) (map vec_of_basis_enum S)))"
   apply (auto simp: cblinfun_image_ccspan image_image)
   by (metis mat_of_cblinfun_cblinfun_apply vec_of_basis_enum_inverse)
 
 text \<open>\<^term>\<open>mk_projector_orthog d L\<close> takes a list L of d-dimensional vectors
-and returns the projector onto the span of L. (Assuming that all vectors in L are 
+and returns the projector onto the span of L. (Assuming that all vectors in L are
 orthogonal and nonzero.)\<close>
 fun mk_projector_orthog :: "nat \<Rightarrow> complex vec list \<Rightarrow> complex mat" where
   "mk_projector_orthog d [] = zero_mat d d"
 | "mk_projector_orthog d [v] = (let norm2 = cscalar_prod v v in
                                 smult_mat (1/norm2) (mat_of_cols d [v] * mat_of_rows d [conjugate v]))"
 | "mk_projector_orthog d (v#vs) = (let norm2 = cscalar_prod v v in
-                                   smult_mat (1/norm2) (mat_of_cols d [v] * mat_of_rows d [conjugate v]) 
+                                   smult_mat (1/norm2) (mat_of_cols d [v] * mat_of_rows d [conjugate v])
                                         + mk_projector_orthog d vs)"
 
 lemma mk_projector_orthog_correct:
   fixes S :: "'a::onb_enum list"
   defines "d \<equiv> length (canonical_basis :: 'a list)"
   assumes ortho: "is_ortho_set (set S)" and distinct: "distinct S"
-  shows "mk_projector_orthog d (map vec_of_basis_enum S) 
+  shows "mk_projector_orthog d (map vec_of_basis_enum S)
        = mat_of_cblinfun (Proj (ccspan (set S)))"
 proof -
   define Snorm where "Snorm = map (\<lambda>s. s /\<^sub>R norm s) S"
 
   have "distinct Snorm"
   proof (insert ortho distinct, unfold Snorm_def, induction S)
     case Nil
     show ?case by simp
   next
     case (Cons s S)
     then have "is_ortho_set (set S)" and "distinct S"
       unfolding is_ortho_set_def by auto
     note IH = Cons.IH[OF this]
     have "s /\<^sub>R norm s \<notin> (\<lambda>s. s /\<^sub>R norm s) ` set S"
     proof auto
       fix s' assume "s' \<in> set S" and same: "s /\<^sub>R norm s = s' /\<^sub>R norm s'"
       with Cons.prems have "s \<noteq> s'" by auto
       have "s \<noteq> 0"
         by (metis Cons.prems(1) is_ortho_set_def list.set_intros(1))
       then have "0 \<noteq> \<langle>s /\<^sub>R norm s, s /\<^sub>R norm s\<rangle>"
         by simp
       also have \<open>\<langle>s /\<^sub>R norm s, s /\<^sub>R norm s\<rangle> = \<langle>s /\<^sub>R norm s, s' /\<^sub>R norm s'\<rangle>\<close>
         by (simp add: same)
       also have \<open>\<langle>s /\<^sub>R norm s, s' /\<^sub>R norm s'\<rangle> = \<langle>s, s'\<rangle> / (norm s * norm s')\<close>
         by (simp add: scaleR_scaleC divide_inverse_commute)
       also from \<open>s' \<in> set S\<close> \<open>s \<noteq> s'\<close> have "\<dots> = 0"
         using Cons.prems unfolding is_ortho_set_def by simp
       finally show False
         by simp
     qed
     then show ?case
       using IH by simp
   qed
 
   have norm_Snorm: "norm s = 1" if "s \<in> set Snorm" for s
     using that ortho unfolding Snorm_def is_ortho_set_def apply auto
     by (metis left_inverse norm_eq_zero)
 
   have ortho_Snorm: "is_ortho_set (set Snorm)"
     unfolding is_ortho_set_def
   proof (intro conjI ballI impI)
     fix x y
     show "0 \<notin> set Snorm"
       using norm_Snorm[of 0] by auto
     assume "x \<in> set Snorm" and "y \<in> set Snorm" and "x \<noteq> y"
     from \<open>x \<in> set Snorm\<close>
     obtain x' where x: "x = x' /\<^sub>R norm x'" and x': "x' \<in> set S"
       unfolding Snorm_def by auto
     from \<open>y \<in> set Snorm\<close>
     obtain y' where y: "y = y' /\<^sub>R norm y'" and y': "y' \<in> set S"
       unfolding Snorm_def by auto
     from \<open>x \<noteq> y\<close> x y have \<open>x' \<noteq> y'\<close> by auto
     with x' y' ortho have "cinner x' y' = 0"
       unfolding is_ortho_set_def by auto
     then show "cinner x y = 0"
       unfolding x y scaleR_scaleC by auto
   qed
 
   have inj_butter: "inj_on selfbutter (set Snorm)"
   proof (rule inj_onI)
-    fix x y 
+    fix x y
     assume "x \<in> set Snorm" and "y \<in> set Snorm"
     assume "selfbutter x = selfbutter y"
     then obtain c where xcy: "x = c *\<^sub>C y" and "cmod c = 1"
       using inj_selfbutter_upto_phase by auto
     have "0 \<noteq> cmod (cinner x x)"
       using \<open>x \<in> set Snorm\<close> norm_Snorm
       by force
     also have "cmod (cinner x x) = cmod (c * \<langle>x, y\<rangle>)"
       apply (subst (2) xcy) by simp
     also have "\<dots> = cmod \<langle>x, y\<rangle>"
       using \<open>cmod c = 1\<close> by (simp add: norm_mult)
     finally have "\<langle>x, y\<rangle> \<noteq> 0"
       by simp
     then show "x = y"
       using ortho_Snorm \<open>x \<in> set Snorm\<close> \<open>y \<in> set Snorm\<close>
       unfolding is_ortho_set_def by auto
   qed
 
   from \<open>distinct Snorm\<close> inj_butter
   have distinct': "distinct (map selfbutter Snorm)"
     unfolding distinct_map by simp
 
   have Span_Snorm: "ccspan (set Snorm) = ccspan (set S)"
     apply (transfer fixing: Snorm S)
     apply (simp add: scaleR_scaleC Snorm_def)
-    apply (subst complex_vector.span_image_scale) 
+    apply (subst complex_vector.span_image_scale)
     using is_ortho_set_def ortho by fastforce+
 
   have "mk_projector_orthog d (map vec_of_basis_enum S)
       = mat_of_cblinfun (sum_list (map selfbutter Snorm))"
     unfolding Snorm_def
   proof (induction S)
     case Nil
-    show ?case 
+    show ?case
       by (simp add: d_def mat_of_cblinfun_zero)
   next
     case (Cons a S)
     define sumS where "sumS = sum_list (map selfbutter (map (\<lambda>s. s /\<^sub>R norm s) S))"
     with Cons have IH: "mk_projector_orthog d (map vec_of_basis_enum S)
                   = mat_of_cblinfun sumS"
       by simp
 
     define factor where "factor = inverse ((complex_of_real (norm a))\<^sup>2)"
     have factor': "factor = 1 / (vec_of_basis_enum a \<bullet>c vec_of_basis_enum a)"
       unfolding factor_def cscalar_prod_vec_of_basis_enum
       by (simp add: inverse_eq_divide power2_norm_eq_cinner)
 
     have "mk_projector_orthog d (map vec_of_basis_enum (a # S))
-          = factor \<cdot>\<^sub>m (mat_of_cols d [vec_of_basis_enum a] 
+          = factor \<cdot>\<^sub>m (mat_of_cols d [vec_of_basis_enum a]
                     * mat_of_rows d [conjugate (vec_of_basis_enum a)])
             + mat_of_cblinfun sumS"
       apply (cases S)
        apply (auto simp add: factor' sumS_def d_def mat_of_cblinfun_zero)[1]
       by (auto simp add: IH[symmetric] factor' d_def)
 
     also have "\<dots> = factor \<cdot>\<^sub>m (mat_of_cols d [vec_of_basis_enum a] *
          mat_adjoint (mat_of_cols d [vec_of_basis_enum a])) + mat_of_cblinfun sumS"
       apply (rule arg_cong[where f="\<lambda>x. _ \<cdot>\<^sub>m (_ * x) + _"])
       apply (rule mat_eq_iff[THEN iffD2])
       apply (auto simp add: mat_adjoint_def)
       apply (subst mat_of_rows_index) apply auto
       apply (subst mat_of_rows_index) apply auto
       apply (subst mat_of_cols_index) apply auto
       by (simp add: assms(1) dim_vec_of_basis_enum')
     also have "\<dots> = mat_of_cblinfun (selfbutter (a /\<^sub>R norm a)) + mat_of_cblinfun sumS"
       apply (simp add: butterfly_scaleR_left butterfly_scaleR_right power_inverse mat_of_cblinfun_scaleR factor_def)
       apply (simp add: butterfly_def mat_of_cblinfun_compose
           mat_of_cblinfun_adj mat_of_cblinfun_vector_to_cblinfun d_def)
       by (simp add: mat_of_cblinfun_compose mat_of_cblinfun_adj mat_of_cblinfun_vector_to_cblinfun mat_of_cblinfun_scaleC power2_eq_square)
     finally show ?case
       by (simp add: mat_of_cblinfun_plus sumS_def)
   qed
   also have "\<dots> = mat_of_cblinfun (\<Sum>s\<in>set Snorm. selfbutter s)"
     by (metis distinct' distinct_map sum.distinct_set_conv_list)
   also have "\<dots> = mat_of_cblinfun (\<Sum>s\<in>set Snorm. proj s)"
     apply (rule arg_cong[where f="mat_of_cblinfun"])
     apply (rule sum.cong[OF refl])
     apply (rule butterfly_eq_proj)
     using norm_Snorm by simp
   also have "\<dots> = mat_of_cblinfun (Proj (ccspan (set Snorm)))"
     apply (rule arg_cong[of _ _ mat_of_cblinfun])
   proof (insert ortho_Snorm, insert \<open>distinct Snorm\<close>, induction Snorm)
     case Nil
     show ?case
       by simp
   next
     case (Cons a Snorm)
     from Cons.prems have [simp]: "a \<notin> set Snorm"
       by simp
 
     have "sum proj (set (a # Snorm))
         = proj a + sum proj (set Snorm)"
       by auto
     also have "\<dots> = proj a + Proj (ccspan (set Snorm))"
       apply (subst Cons.IH)
       using Cons.prems apply auto
       by (meson Cons.prems(1) is_ortho_set_antimono set_subset_Cons)
     also have "\<dots> = Proj (ccspan ({a} \<union> set Snorm))"
       apply (rule Proj_orthog_ccspan_union[symmetric])
       by (metis Cons.prems(1) \<open>a \<notin> set Snorm\<close> is_ortho_set_def list.set_intros(1) list.set_intros(2) singleton_iff)
     finally show ?case
       by simp
   qed
   also have "\<dots> = mat_of_cblinfun (Proj (ccspan (set S)))"
     unfolding Span_Snorm by simp
   finally show ?thesis
     by -
 qed
 
-lemma mat_of_cblinfun_Proj_ccspan: 
+lemma mat_of_cblinfun_Proj_ccspan:
   fixes S :: "'a::onb_enum list"
   shows "mat_of_cblinfun (Proj (ccspan (set S))) =
-    (let d = length (canonical_basis :: 'a list) in 
+    (let d = length (canonical_basis :: 'a list) in
       mk_projector_orthog d (gram_schmidt0 d (map vec_of_basis_enum S)))"
 proof-
-  define d gs 
+  define d gs
     where "d = length (canonical_basis :: 'a list)"
       and "gs = gram_schmidt0 d (map vec_of_basis_enum S)"
   interpret complex_vec_space d.
   have gs_dim: "x \<in> set gs \<Longrightarrow> dim_vec x = d" for x
     by (smt carrier_vecD carrier_vec_dim_vec d_def dim_vec_of_basis_enum' ex_map_conv gram_schmidt0_result(1) gs_def subset_code(1))
   have ortho_gs: "is_ortho_set (set (map basis_enum_of_vec gs :: 'a list))"
     apply (subst corthogonal_vec_of_basis_enum[THEN iffD1], auto)
     by (smt carrier_dim_vec cof_vec_space.gram_schmidt0_result(1) d_def dim_vec_of_basis_enum' gram_schmidt0_result(3) gs_def imageE map_idI map_map o_apply set_map subset_code(1) basis_enum_of_vec_inverse)
   have distinct_gs: "distinct (map basis_enum_of_vec gs :: 'a list)"
-    by (metis (mono_tags, hide_lams) carrier_vec_dim_vec cof_vec_space.gram_schmidt0_result(2) d_def dim_vec_of_basis_enum' distinct_map gs_def gs_dim image_iff inj_on_inverseI set_map subsetI basis_enum_of_vec_inverse)
+    by (metis (mono_tags, opaque_lifting) carrier_vec_dim_vec cof_vec_space.gram_schmidt0_result(2) d_def dim_vec_of_basis_enum' distinct_map gs_def gs_dim image_iff inj_on_inverseI set_map subsetI basis_enum_of_vec_inverse)
 
-  have "mk_projector_orthog d gs 
+  have "mk_projector_orthog d gs
       = mk_projector_orthog d (map vec_of_basis_enum (map basis_enum_of_vec gs :: 'a list))"
     apply simp
     apply (subst map_cong[where ys=gs and g=id], simp)
     using gs_dim by (auto intro!: vec_of_basis_enum_inverse simp: d_def)
   also have "\<dots> = mat_of_cblinfun (Proj (ccspan (set (map basis_enum_of_vec gs :: 'a list))))"
     unfolding d_def
     apply (subst mk_projector_orthog_correct)
     using ortho_gs distinct_gs by auto
   also have "\<dots> = mat_of_cblinfun (Proj (ccspan (set S)))"
     apply (rule arg_cong[where f="\<lambda>x. mat_of_cblinfun (Proj x)"])
     unfolding gs_def d_def
     apply (subst ccspan_gram_schmidt0_invariant)
     by (auto simp add: carrier_vecI dim_vec_of_basis_enum')
   finally show ?thesis
     unfolding d_def gs_def by auto
 qed
 
 unbundle no_jnf_notation
 unbundle no_cblinfun_notation
 
 end
diff --git a/thys/Complex_Bounded_Operators/Complex_Bounded_Linear_Function.thy b/thys/Complex_Bounded_Operators/Complex_Bounded_Linear_Function.thy
--- a/thys/Complex_Bounded_Operators/Complex_Bounded_Linear_Function.thy
+++ b/thys/Complex_Bounded_Operators/Complex_Bounded_Linear_Function.thy
@@ -1,2981 +1,2981 @@
 section \<open>\<open>Complex_Bounded_Linear_Function\<close> -- Complex bounded linear functions (bounded operators)\<close>
 
 (*
 Authors:
 
   Dominique Unruh, University of Tartu, unruh@ut.ee
   Jose Manuel Rodriguez Caballero, University of Tartu, jose.manuel.rodriguez.caballero@ut.ee
 
 *)
 
 theory Complex_Bounded_Linear_Function
-  imports 
+  imports
     Complex_Inner_Product One_Dimensional_Spaces
     Banach_Steinhaus.Banach_Steinhaus
     "HOL-Types_To_Sets.Types_To_Sets"
     Complex_Bounded_Linear_Function0
 begin
 
 subsection \<open>Misc basic facts and declarations\<close>
 
 notation cblinfun_apply (infixr "*\<^sub>V" 70)
 
 lemma id_cblinfun_apply[simp]: "id_cblinfun *\<^sub>V \<psi> = \<psi>"
   apply transfer by simp
 
 lemma isCont_cblinfun_apply[simp]: "isCont ((*\<^sub>V) A) \<psi>"
   apply transfer
-  by (simp add: clinear_continuous_at) 
+  by (simp add: clinear_continuous_at)
 
 declare cblinfun.scaleC_left[simp]
 
 lemma cblinfun_apply_clinear[simp]: \<open>clinear (cblinfun_apply A)\<close>
   using bounded_clinear.axioms(1) cblinfun_apply by blast
 
 lemma cblinfun_cinner_eqI:
   fixes A B :: \<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'a\<close>
   assumes \<open>\<And>\<psi>. cinner \<psi> (A *\<^sub>V \<psi>) = cinner \<psi> (B *\<^sub>V \<psi>)\<close>
   shows \<open>A = B\<close>
 proof -
   define C where \<open>C = A - B\<close>
   have C0[simp]: \<open>cinner \<psi> (C \<psi>) = 0\<close> for \<psi>
     by (simp add: C_def assms cblinfun.diff_left cinner_diff_right)
   { fix f g \<alpha>
     have \<open>0 = cinner (f + \<alpha> *\<^sub>C g) (C *\<^sub>V (f + \<alpha> *\<^sub>C g))\<close>
       by (simp add: cinner_diff_right minus_cblinfun.rep_eq)
     also have \<open>\<dots> = \<alpha> *\<^sub>C cinner f (C g) + cnj \<alpha> *\<^sub>C cinner g (C f)\<close>
       by (smt (z3) C0 add.commute add.right_neutral cblinfun.add_right cblinfun.scaleC_right cblinfun_cinner_right.rep_eq cinner_add_left cinner_scaleC_left complex_scaleC_def)
     finally have \<open>\<alpha> *\<^sub>C cinner f (C g) = - cnj \<alpha> *\<^sub>C cinner g (C f)\<close>
       by (simp add: eq_neg_iff_add_eq_0)
   }
   then have \<open>cinner f (C g) = 0\<close> for f g
     by (metis complex_cnj_i complex_cnj_one complex_vector.scale_cancel_right complex_vector.scale_left_imp_eq equation_minus_iff i_squared mult_eq_0_iff one_neq_neg_one)
   then have \<open>C g = 0\<close> for g
     using cinner_eq_zero_iff by blast
   then have \<open>C = 0\<close>
     by (simp add: cblinfun_eqI)
   then show \<open>A = B\<close>
     using C_def by auto
 qed
 
 lemma id_cblinfun_not_0[simp]: \<open>(id_cblinfun :: 'a::{complex_normed_vector, not_singleton} \<Rightarrow>\<^sub>C\<^sub>L _) \<noteq> 0\<close>
   by (metis (full_types) Extra_General.UNIV_not_singleton cblinfun.zero_left cblinfun_id_cblinfun_apply ex_norm1 norm_zero one_neq_zero)
 
 lemma cblinfun_norm_geqI:
   assumes \<open>norm (f *\<^sub>V x) / norm x \<ge> K\<close>
   shows \<open>norm f \<ge> K\<close>
   using assms apply transfer
   by (smt (z3) bounded_clinear.bounded_linear le_onorm)
 
 (* This lemma is proven in Complex_Bounded_Linear_Function0 but we add the [simp]
    only here because we try to keep Complex_Bounded_Linear_Function0 as close to
    Bounded_Linear_Function as possible. *)
 declare scaleC_conv_of_complex[simp]
 
 lemma cblinfun_eq_0_on_span:
   fixes S::\<open>'a::complex_normed_vector set\<close>
   assumes "x \<in> cspan S"
     and "\<And>s. s\<in>S \<Longrightarrow> F *\<^sub>V s = 0"
   shows \<open>F *\<^sub>V x = 0\<close>
   apply (rule complex_vector.linear_eq_0_on_span[where f=F])
   using bounded_clinear.axioms(1) cblinfun_apply assms by auto
 
 lemma cblinfun_eq_on_span:
   fixes S::\<open>'a::complex_normed_vector set\<close>
   assumes "x \<in> cspan S"
     and "\<And>s. s\<in>S \<Longrightarrow> F *\<^sub>V s = G *\<^sub>V s"
   shows \<open>F *\<^sub>V x = G *\<^sub>V x\<close>
   apply (rule complex_vector.linear_eq_on_span[where f=F])
   using bounded_clinear.axioms(1) cblinfun_apply assms by auto
 
 lemma cblinfun_eq_0_on_UNIV_span:
   fixes basis::\<open>'a::complex_normed_vector set\<close>
   assumes "cspan basis = UNIV"
     and "\<And>s. s\<in>basis \<Longrightarrow> F *\<^sub>V s = 0"
   shows \<open>F = 0\<close>
   by (metis cblinfun_eq_0_on_span UNIV_I assms cblinfun.zero_left cblinfun_eqI)
 
 lemma cblinfun_eq_on_UNIV_span:
   fixes basis::"'a::complex_normed_vector set" and \<phi>::"'a \<Rightarrow> 'b::complex_normed_vector"
   assumes "cspan basis = UNIV"
     and "\<And>s. s\<in>basis \<Longrightarrow> F *\<^sub>V s = G *\<^sub>V s"
   shows \<open>F = G\<close>
 proof-
   have "F - G = 0"
     apply (rule cblinfun_eq_0_on_UNIV_span[where basis=basis])
     using assms by (auto simp add: cblinfun.diff_left)
   thus ?thesis by simp
 qed
 
 lemma cblinfun_eq_on_canonical_basis:
   fixes f g::"'a::{basis_enum,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector"
   defines "basis == set (canonical_basis::'a list)"
   assumes "\<And>u. u \<in> basis \<Longrightarrow> f *\<^sub>V u = g *\<^sub>V u"
-  shows  "f = g" 
+  shows  "f = g"
   apply (rule cblinfun_eq_on_UNIV_span[where basis=basis])
   using assms is_generator_set is_cindependent_set by auto
 
 lemma cblinfun_eq_0_on_canonical_basis:
   fixes f ::"'a::{basis_enum,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector"
   defines "basis == set (canonical_basis::'a list)"
   assumes "\<And>u. u \<in> basis \<Longrightarrow> f *\<^sub>V u = 0"
   shows  "f = 0"
   by (simp add: assms cblinfun_eq_on_canonical_basis)
 
 lemma cinner_canonical_basis_eq_0:
   defines "basisA == set (canonical_basis::'a::onb_enum list)"
     and   "basisB == set (canonical_basis::'b::onb_enum list)"
   assumes "\<And>u v. u\<in>basisA \<Longrightarrow> v\<in>basisB \<Longrightarrow> \<langle>v, F *\<^sub>V u\<rangle> = 0"
   shows "F = 0"
 proof-
   have "F *\<^sub>V u = 0"
     if "u\<in>basisA" for u
   proof-
     have "\<And>v. v\<in>basisB \<Longrightarrow> \<langle>v, F *\<^sub>V u\<rangle> = 0"
       by (simp add: assms(3) that)
     moreover have "(\<And>v. v\<in>basisB \<Longrightarrow> \<langle>v, x\<rangle> = 0) \<Longrightarrow> x = 0"
       for x
-    proof-     
-      assume r1: "\<And>v. v\<in>basisB \<Longrightarrow> \<langle>v, x\<rangle> = 0"      
+    proof-
+      assume r1: "\<And>v. v\<in>basisB \<Longrightarrow> \<langle>v, x\<rangle> = 0"
       have "\<langle>v, x\<rangle> = 0" for v
       proof-
         have "cspan basisB = UNIV"
-          using basisB_def is_generator_set  by auto 
+          using basisB_def is_generator_set  by auto
         hence "v \<in> cspan basisB"
           by (smt iso_tuple_UNIV_I)
         hence "\<exists>t s. v = (\<Sum>a\<in>t. s a *\<^sub>C a) \<and> finite t \<and> t \<subseteq> basisB"
           using complex_vector.span_explicit
           by (smt mem_Collect_eq)
         then obtain t s where b1: "v = (\<Sum>a\<in>t. s a *\<^sub>C a)" and b2: "finite t" and b3: "t \<subseteq> basisB"
           by blast
         have "\<langle>v, x\<rangle> = \<langle>(\<Sum>a\<in>t. s a *\<^sub>C a), x\<rangle>"
           by (simp add: b1)
         also have "\<dots> = (\<Sum>a\<in>t. \<langle>s a *\<^sub>C a, x\<rangle>)"
           using cinner_sum_left by blast
         also have "\<dots> = (\<Sum>a\<in>t. cnj (s a) * \<langle>a, x\<rangle>)"
           by auto
         also have "\<dots> = 0"
           using b3 r1 subsetD by force
         finally show ?thesis by simp
       qed
       thus ?thesis
-        by (simp add: \<open>\<And>v. \<langle>v, x\<rangle> = 0\<close> cinner_extensionality) 
+        by (simp add: \<open>\<And>v. \<langle>v, x\<rangle> = 0\<close> cinner_extensionality)
     qed
     ultimately show ?thesis by simp
   qed
   thus ?thesis
-    using basisA_def cblinfun_eq_0_on_canonical_basis by auto 
+    using basisA_def cblinfun_eq_0_on_canonical_basis by auto
 qed
 
 lemma cinner_canonical_basis_eq:
   defines "basisA == set (canonical_basis::'a::onb_enum list)"
     and   "basisB == set (canonical_basis::'b::onb_enum list)"
   assumes "\<And>u v. u\<in>basisA \<Longrightarrow> v\<in>basisB \<Longrightarrow> \<langle>v, F *\<^sub>V u\<rangle> = \<langle>v, G *\<^sub>V u\<rangle>"
   shows "F = G"
 proof-
   define H where "H = F - G"
   have "\<And>u v. u\<in>basisA \<Longrightarrow> v\<in>basisB \<Longrightarrow> \<langle>v, H *\<^sub>V u\<rangle> = 0"
     unfolding H_def
-    by (simp add: assms(3) cinner_diff_right minus_cblinfun.rep_eq) 
+    by (simp add: assms(3) cinner_diff_right minus_cblinfun.rep_eq)
   hence "H = 0"
-    by (simp add: basisA_def basisB_def cinner_canonical_basis_eq_0)    
+    by (simp add: basisA_def basisB_def cinner_canonical_basis_eq_0)
   thus ?thesis unfolding H_def by simp
 qed
 
 lemma cinner_canonical_basis_eq':
   defines "basisA == set (canonical_basis::'a::onb_enum list)"
     and   "basisB == set (canonical_basis::'b::onb_enum list)"
   assumes "\<And>u v. u\<in>basisA \<Longrightarrow> v\<in>basisB \<Longrightarrow> \<langle>F *\<^sub>V u, v\<rangle> = \<langle>G *\<^sub>V u, v\<rangle>"
   shows "F = G"
   using cinner_canonical_basis_eq assms
   by (metis cinner_commute')
 
 lemma cblinfun_norm_approx_witness:
   fixes A :: \<open>'a::{not_singleton,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector\<close>
   assumes \<open>\<epsilon> > 0\<close>
   shows \<open>\<exists>\<psi>. norm (A *\<^sub>V \<psi>) \<ge> norm A - \<epsilon> \<and> norm \<psi> = 1\<close>
 proof (transfer fixing: \<epsilon>)
   fix A :: \<open>'a \<Rightarrow> 'b\<close> assume [simp]: \<open>bounded_clinear A\<close>
   have \<open>\<exists>y\<in>{norm (A x) |x. norm x = 1}. y > \<Squnion> {norm (A x) |x. norm x = 1} - \<epsilon>\<close>
     apply (rule Sup_real_close)
     using assms by (auto simp: ex_norm1 bounded_clinear.bounded_linear bdd_above_norm_f)
   also have \<open>\<Squnion> {norm (A x) |x. norm x = 1} = onorm A\<close>
     by (simp add: Complex_Vector_Spaces0.bounded_clinear.bounded_linear onorm_sphere)
-  finally 
+  finally
   show \<open>\<exists>\<psi>. onorm A - \<epsilon> \<le> norm (A \<psi>) \<and> norm \<psi> = 1\<close>
     by force
 qed
 
 lemma cblinfun_norm_approx_witness_mult:
   fixes A :: \<open>'a::{not_singleton,complex_normed_vector} \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector\<close>
   assumes \<open>\<epsilon> < 1\<close>
   shows \<open>\<exists>\<psi>. norm (A *\<^sub>V \<psi>) \<ge> norm A * \<epsilon> \<and> norm \<psi> = 1\<close>
 proof (cases \<open>norm A = 0\<close>)
   case True
   then show ?thesis
     apply auto
     by (simp add: ex_norm1)
 next
   case False
   then have \<open>(1 - \<epsilon>) * norm A > 0\<close>
     using assms by fastforce
   then obtain \<psi> where geq: \<open>norm (A *\<^sub>V \<psi>) \<ge> norm A - ((1 - \<epsilon>) * norm A)\<close> and \<open>norm \<psi> = 1\<close>
     using cblinfun_norm_approx_witness by blast
   have \<open>norm A * \<epsilon> = norm A - (1 - \<epsilon>) * norm A\<close>
     by (simp add: mult.commute right_diff_distrib')
   also have \<open>\<dots> \<le> norm (A *\<^sub>V \<psi>)\<close>
     by (rule geq)
   finally show ?thesis
     using \<open>norm \<psi> = 1\<close> by auto
 qed
 
 
 lemma cblinfun_to_CARD_1_0[simp]: \<open>(A :: _ \<Rightarrow>\<^sub>C\<^sub>L _::CARD_1) = 0\<close>
   apply (rule cblinfun_eqI)
   by auto
 
 lemma cblinfun_from_CARD_1_0[simp]: \<open>(A :: _::CARD_1 \<Rightarrow>\<^sub>C\<^sub>L _) = 0\<close>
   apply (rule cblinfun_eqI)
   apply (subst CARD_1_vec_0)
   by auto
 
 
 lemma cblinfun_cspan_UNIV:
   fixes basis :: \<open>('a::{complex_normed_vector,cfinite_dim} \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector) set\<close>
     and basisA :: \<open>'a set\<close> and basisB :: \<open>'b set\<close>
   assumes \<open>cspan basisA = UNIV\<close> and \<open>cspan basisB = UNIV\<close>
   assumes basis: \<open>\<And>a b. a\<in>basisA \<Longrightarrow> b\<in>basisB \<Longrightarrow> \<exists>F\<in>basis. \<forall>a'\<in>basisA. F *\<^sub>V a' = (if a'=a then b else 0)\<close>
   shows \<open>cspan basis = UNIV\<close>
 proof -
   obtain basisA' where \<open>basisA' \<subseteq> basisA\<close> and \<open>cindependent basisA'\<close> and \<open>cspan basisA' = UNIV\<close>
     by (metis assms(1) complex_vector.maximal_independent_subset complex_vector.span_eq top_greatest)
   then have [simp]: \<open>finite basisA'\<close>
     by (simp add: cindependent_cfinite_dim_finite)
   have basis': \<open>\<And>a b. a\<in>basisA' \<Longrightarrow> b\<in>basisB \<Longrightarrow> \<exists>F\<in>basis. \<forall>a'\<in>basisA'. F *\<^sub>V a' = (if a'=a then b else 0)\<close>
     using basis \<open>basisA' \<subseteq> basisA\<close> by fastforce
 
-  obtain F where F: \<open>F a b \<in> basis \<and> F a b *\<^sub>V a' = (if a'=a then b else 0)\<close> 
+  obtain F where F: \<open>F a b \<in> basis \<and> F a b *\<^sub>V a' = (if a'=a then b else 0)\<close>
     if \<open>a\<in>basisA'\<close> \<open>b\<in>basisB\<close> \<open>a'\<in>basisA'\<close> for a b a'
     apply atomize_elim apply (intro choice allI)
     using basis' by metis
   then have F_apply: \<open>F a b *\<^sub>V a' = (if a'=a then b else 0)\<close>
     if \<open>a\<in>basisA'\<close> \<open>b\<in>basisB\<close> \<open>a'\<in>basisA'\<close> for a b a'
     using that by auto
-  have F_basis: \<open>F a b \<in> basis\<close> 
+  have F_basis: \<open>F a b \<in> basis\<close>
     if \<open>a\<in>basisA'\<close> \<open>b\<in>basisB\<close> for a b
     using that F by auto
   have b_span: \<open>\<exists>G\<in>cspan {F a b|b. b\<in>basisB}. \<forall>a'\<in>basisA'. G *\<^sub>V a' = (if a'=a then b else 0)\<close> if \<open>a\<in>basisA'\<close> for a b
   proof -
     from \<open>cspan basisB = UNIV\<close>
     obtain r t where \<open>finite t\<close> and \<open>t \<subseteq> basisB\<close> and b_lincom: \<open>b = (\<Sum>a\<in>t. r a *\<^sub>C a)\<close>
       unfolding complex_vector.span_alt apply atomize_elim by blast
     define G where \<open>G = (\<Sum>i\<in>t. r i *\<^sub>C F a i)\<close>
     have \<open>G \<in> cspan {F a b|b. b\<in>basisB}\<close>
       using \<open>finite t\<close> \<open>t \<subseteq> basisB\<close> unfolding G_def
       by (smt (verit, ccfv_threshold) complex_vector.span_base complex_vector.span_scale complex_vector.span_sum mem_Collect_eq subset_eq)
     moreover have \<open>G *\<^sub>V a' = (if a'=a then b else 0)\<close> if \<open>a'\<in>basisA'\<close> for a'
       apply (cases \<open>a'=a\<close>)
       using \<open>t \<subseteq> basisB\<close> \<open>a\<in>basisA'\<close> \<open>a'\<in>basisA'\<close>
-      by (auto simp: b_lincom G_def cblinfun.sum_left F_apply intro!: sum.neutral sum.cong) 
+      by (auto simp: b_lincom G_def cblinfun.sum_left F_apply intro!: sum.neutral sum.cong)
     ultimately show ?thesis
       by blast
   qed
 
   have a_span: \<open>cspan (\<Union>a\<in>basisA'. cspan {F a b|b. b\<in>basisB}) = UNIV\<close>
   proof (intro equalityI subset_UNIV subsetI, rename_tac H)
     fix H
     obtain G where G: \<open>G a b \<in> cspan {F a b|b. b\<in>basisB} \<and> G a b *\<^sub>V a' = (if a'=a then b else 0)\<close> if \<open>a\<in>basisA'\<close> and \<open>a'\<in>basisA'\<close> for a b a'
       apply atomize_elim apply (intro choice allI)
       using b_span by blast
     then have G_cspan: \<open>G a b \<in> cspan {F a b|b. b\<in>basisB}\<close> if \<open>a\<in>basisA'\<close> for a b
       using that by auto
     from G have G: \<open>G a b *\<^sub>V a' = (if a'=a then b else 0)\<close> if \<open>a\<in>basisA'\<close> and \<open>a'\<in>basisA'\<close> for a b a'
       using that by auto
     define H' where \<open>H' = (\<Sum>a\<in>basisA'. G a (H *\<^sub>V a))\<close>
     have \<open>H' \<in> cspan (\<Union>a\<in>basisA'. cspan {F a b|b. b\<in>basisB})\<close>
       unfolding H'_def using G_cspan
-      by (smt (verit, del_insts) UN_iff complex_vector.span_clauses(1) complex_vector.span_sum) 
+      by (smt (verit, del_insts) UN_iff complex_vector.span_clauses(1) complex_vector.span_sum)
     moreover have \<open>H' = H\<close>
       using \<open>cspan basisA' = UNIV\<close> apply (rule cblinfun_eq_on_UNIV_span)
       apply (auto simp: H'_def cblinfun.sum_left)
       apply (subst sum_single)
       by (auto simp: G)
     ultimately show \<open>H \<in> cspan (\<Union>a\<in>basisA'. cspan {F a b |b. b \<in> basisB})\<close>
       by simp
   qed
 
   moreover have \<open>cspan basis \<supseteq> cspan (\<Union>a\<in>basisA'. cspan {F a b|b. b\<in>basisB})\<close>
     using F_basis
     by (smt (z3) UN_subset_iff complex_vector.span_alt complex_vector.span_minimal complex_vector.subspace_span mem_Collect_eq subset_iff)
 
   ultimately show \<open>cspan basis = UNIV\<close>
     by auto
 qed
 
 
 instance cblinfun :: (\<open>{cfinite_dim,complex_normed_vector}\<close>, \<open>{cfinite_dim,complex_normed_vector}\<close>) cfinite_dim
 proof intro_classes
   obtain basisA :: \<open>'a set\<close> where [simp]: \<open>cspan basisA = UNIV\<close> \<open>cindependent basisA\<close> \<open>finite basisA\<close>
     using finite_basis by blast
   obtain basisB :: \<open>'b set\<close> where [simp]: \<open>cspan basisB = UNIV\<close> \<open>cindependent basisB\<close> \<open>finite basisB\<close>
     using finite_basis by blast
   define f where \<open>f a b = cconstruct basisA (\<lambda>x. if x=a then b else 0)\<close> for a :: 'a and b :: 'b
   have f_a: \<open>f a b a = b\<close> if \<open>a : basisA\<close> for a b
     by (simp add: complex_vector.construct_basis f_def that)
   have f_not_a: \<open>f a b c = 0\<close> if \<open>a : basisA\<close> and \<open>c : basisA\<close> and \<open>a \<noteq> c\<close>for a b c
     using that by (simp add: complex_vector.construct_basis f_def)
   define F where \<open>F a b = CBlinfun (f a b)\<close> for a b
   have \<open>clinear (f a b)\<close> for a b
     by (auto intro: complex_vector.linear_construct simp: f_def)
   then have \<open>bounded_clinear (f a b)\<close> for a b
     by auto
   then have F_apply: \<open>cblinfun_apply (F a b) = f a b\<close> for a b
     by (simp add: F_def bounded_clinear_CBlinfun_apply)
   define basis where \<open>basis = {F a b| a b. a\<in>basisA \<and> b\<in>basisB}\<close>
   have \<open>cspan basis = UNIV\<close>
     apply (rule cblinfun_cspan_UNIV[where basisA=basisA and basisB=basisB])
       apply (auto simp: basis_def)
     by (metis F_apply f_a f_not_a)
 
   moreover have \<open>finite basis\<close>
     unfolding basis_def apply (rule finite_image_set2) by auto
 
   ultimately show \<open>\<exists>S :: ('a \<Rightarrow>\<^sub>C\<^sub>L 'b) set. finite S \<and> cspan S = UNIV\<close>
     by auto
-qed  
+qed
 
 
 subsection \<open>Relationship to real bounded operators (\<^typ>\<open>_ \<Rightarrow>\<^sub>L _\<close>)\<close>
 
 instantiation blinfun :: (real_normed_vector, complex_normed_vector) "complex_normed_vector"
 begin
 lift_definition scaleC_blinfun :: \<open>complex \<Rightarrow>
  ('a::real_normed_vector, 'b::complex_normed_vector) blinfun \<Rightarrow>
  ('a, 'b) blinfun\<close>
-  is \<open>\<lambda> c::complex. \<lambda> f::'a\<Rightarrow>'b. (\<lambda> x. c *\<^sub>C (f x) )\<close> 
+  is \<open>\<lambda> c::complex. \<lambda> f::'a\<Rightarrow>'b. (\<lambda> x. c *\<^sub>C (f x) )\<close>
 proof
   fix c::complex and f :: \<open>'a\<Rightarrow>'b\<close> and b1::'a and b2::'a
   assume \<open>bounded_linear f\<close>
   show \<open>c *\<^sub>C f (b1 + b2) = c *\<^sub>C f b1 + c *\<^sub>C f b2\<close>
     by (simp add: \<open>bounded_linear f\<close> linear_simps scaleC_add_right)
 
   fix c::complex and f :: \<open>'a\<Rightarrow>'b\<close> and b::'a and r::real
   assume \<open>bounded_linear f\<close>
   show \<open>c *\<^sub>C f (r *\<^sub>R b) = r *\<^sub>R (c *\<^sub>C f b)\<close>
     by (simp add: \<open>bounded_linear f\<close> linear_simps(5) scaleR_scaleC)
 
   fix c::complex and f :: \<open>'a\<Rightarrow>'b\<close>
   assume \<open>bounded_linear f\<close>
 
   have \<open>\<exists> K. \<forall> x. norm (f x) \<le> norm x * K\<close>
     using \<open>bounded_linear f\<close>
-    by (simp add: bounded_linear.bounded)      
+    by (simp add: bounded_linear.bounded)
   then obtain K where \<open>\<forall> x. norm (f x) \<le> norm x * K\<close>
     by blast
   have \<open>cmod c \<ge> 0\<close>
     by simp
   hence \<open>\<forall> x. (cmod c) * norm (f x) \<le> (cmod c) * norm x * K\<close>
-    using  \<open>\<forall> x. norm (f x) \<le> norm x * K\<close> 
+    using  \<open>\<forall> x. norm (f x) \<le> norm x * K\<close>
     by (metis ordered_comm_semiring_class.comm_mult_left_mono vector_space_over_itself.scale_scale)
   moreover have \<open>norm (c *\<^sub>C f x) = (cmod c) * norm (f x)\<close>
     for x
     by simp
   ultimately show \<open>\<exists>K. \<forall>x. norm (c *\<^sub>C f x) \<le> norm x * K\<close>
     by (metis ab_semigroup_mult_class.mult_ac(1) mult.commute)
 qed
 
 instance
 proof
   have "r *\<^sub>R x = complex_of_real r *\<^sub>C x"
     for x :: "('a, 'b) blinfun" and r
     apply transfer
     by (simp add: scaleR_scaleC)
   thus "((*\<^sub>R) r::'a \<Rightarrow>\<^sub>L 'b \<Rightarrow> _) = (*\<^sub>C) (complex_of_real r)" for r
     by auto
   show "a *\<^sub>C (x + y) = a *\<^sub>C x + a *\<^sub>C y"
     for a :: complex and x y :: "'a \<Rightarrow>\<^sub>L 'b"
     apply transfer
     by (simp add: scaleC_add_right)
 
   show "(a + b) *\<^sub>C x = a *\<^sub>C x + b *\<^sub>C x"
     for a b :: complex and x :: "'a \<Rightarrow>\<^sub>L 'b"
     apply transfer
     by (simp add: scaleC_add_left)
 
   show "a *\<^sub>C b *\<^sub>C x = (a * b) *\<^sub>C x"
     for a b :: complex and x :: "'a \<Rightarrow>\<^sub>L 'b"
     apply transfer
     by simp
 
   have \<open>1 *\<^sub>C f x = f x\<close>
     for f :: \<open>'a\<Rightarrow>'b\<close> and x
     by auto
   thus "1 *\<^sub>C x = x"
     for x :: "'a \<Rightarrow>\<^sub>L 'b"
-    by (simp add: scaleC_blinfun.rep_eq blinfun_eqI)   
+    by (simp add: scaleC_blinfun.rep_eq blinfun_eqI)
 
   have \<open>onorm (\<lambda>x. a *\<^sub>C f x) = cmod a * onorm f\<close>
     if \<open>bounded_linear f\<close>
     for f :: \<open>'a \<Rightarrow> 'b\<close> and a :: complex
   proof-
     have \<open>cmod a \<ge> 0\<close>
       by simp
     have \<open>\<exists> K::real. \<forall> x. (\<bar> ereal ((norm (f x)) / (norm x)) \<bar>) \<le> K\<close>
       using \<open>bounded_linear f\<close> le_onorm by fastforce
     then obtain K::real where \<open>\<forall> x. (\<bar> ereal ((norm (f x)) / (norm x)) \<bar>) \<le> K\<close>
       by blast
     hence  \<open>\<forall> x. (cmod a) *(\<bar> ereal ((norm (f x)) / (norm x)) \<bar>) \<le> (cmod a) * K\<close>
-      using \<open>cmod a \<ge> 0\<close> 
+      using \<open>cmod a \<ge> 0\<close>
       by (metis abs_ereal.simps(1) abs_ereal_pos   abs_pos ereal_mult_left_mono  times_ereal.simps(1))
     hence  \<open>\<forall> x.  (\<bar> ereal ((cmod a) * (norm (f x)) / (norm x)) \<bar>) \<le> (cmod a) * K\<close>
       by simp
     hence \<open>bdd_above {ereal (cmod a * (norm (f x)) / (norm x)) | x. True}\<close>
       by simp
     moreover have \<open>{ereal (cmod a * (norm (f x)) / (norm x)) | x. True} \<noteq> {}\<close>
       by auto
     ultimately have p1: \<open>(SUP x. \<bar>ereal (cmod a * (norm (f x)) / (norm x))\<bar>) \<le> cmod a * K\<close>
       using \<open>\<forall> x. \<bar> ereal (cmod a * (norm (f x)) / (norm x)) \<bar> \<le> cmod a * K\<close>
         Sup_least mem_Collect_eq
-      by (simp add: SUP_le_iff) 
+      by (simp add: SUP_le_iff)
     have  p2: \<open>\<And>i. i \<in> UNIV \<Longrightarrow> 0 \<le> ereal (cmod a * norm (f i) / norm i)\<close>
       by simp
     hence \<open>\<bar>SUP x. ereal (cmod a * (norm (f x)) / (norm x))\<bar>
-              \<le> (SUP x. \<bar>ereal (cmod a * (norm (f x)) / (norm x))\<bar>)\<close>    
+              \<le> (SUP x. \<bar>ereal (cmod a * (norm (f x)) / (norm x))\<bar>)\<close>
       using  \<open>bdd_above {ereal (cmod a * (norm (f x)) / (norm x)) | x. True}\<close>
         \<open>{ereal (cmod a * (norm (f x)) / (norm x)) | x. True} \<noteq> {}\<close>
-      by (metis (mono_tags, lifting) SUP_upper2 Sup.SUP_cong UNIV_I 
+      by (metis (mono_tags, lifting) SUP_upper2 Sup.SUP_cong UNIV_I
           p2 abs_ereal_ge0 ereal_le_real)
     hence \<open>\<bar>SUP x. ereal (cmod a * (norm (f x)) / (norm x))\<bar> \<le> cmod a * K\<close>
       using  \<open>(SUP x. \<bar>ereal (cmod a * (norm (f x)) / (norm x))\<bar>) \<le> cmod a * K\<close>
       by simp
     hence \<open>\<bar> ( SUP i\<in>UNIV::'a set. ereal ((\<lambda> x. (cmod a) * (norm (f x)) / norm x) i)) \<bar> \<noteq> \<infinity>\<close>
       by auto
     hence w2: \<open>( SUP i\<in>UNIV::'a set. ereal ((\<lambda> x. cmod a * (norm (f x)) / norm x) i))
              = ereal ( Sup ((\<lambda> x. cmod a * (norm (f x)) / norm x) ` (UNIV::'a set) ))\<close>
-      by (simp add: ereal_SUP) 
+      by (simp add: ereal_SUP)
     have \<open>(UNIV::('a set)) \<noteq> {}\<close>
       by simp
     moreover have \<open>\<And> i. i \<in> (UNIV::('a set)) \<Longrightarrow> (\<lambda> x. (norm (f x)) / norm x :: ereal) i \<ge> 0\<close>
       by simp
     moreover have \<open>cmod a \<ge> 0\<close>
       by simp
-    ultimately have \<open>(SUP i\<in>(UNIV::('a set)). ((cmod a)::ereal) * (\<lambda> x. (norm (f x)) / norm x :: ereal) i ) 
+    ultimately have \<open>(SUP i\<in>(UNIV::('a set)). ((cmod a)::ereal) * (\<lambda> x. (norm (f x)) / norm x :: ereal) i )
         = ((cmod a)::ereal) * ( SUP i\<in>(UNIV::('a set)). (\<lambda> x. (norm (f x)) / norm x :: ereal) i )\<close>
       by (simp add: Sup_ereal_mult_left')
-    hence \<open>(SUP x. ((cmod a)::ereal) * ( (norm (f x)) / norm x :: ereal) ) 
+    hence \<open>(SUP x. ((cmod a)::ereal) * ( (norm (f x)) / norm x :: ereal) )
         = ((cmod a)::ereal) * ( SUP x. ( (norm (f x)) / norm x :: ereal) )\<close>
       by simp
     hence z1: \<open>real_of_ereal ( (SUP x. ((cmod a)::ereal) * ( (norm (f x)) / norm x :: ereal) ) )
         = real_of_ereal ( ((cmod a)::ereal) * ( SUP x. ( (norm (f x)) / norm x :: ereal) ) )\<close>
       by simp
-    have z2: \<open>real_of_ereal (SUP x. ((cmod a)::ereal) * ( (norm (f x)) / norm x :: ereal) ) 
+    have z2: \<open>real_of_ereal (SUP x. ((cmod a)::ereal) * ( (norm (f x)) / norm x :: ereal) )
                   = (SUP x. cmod a * (norm (f x) / norm x))\<close>
       using w2
-      by auto 
+      by auto
     have \<open>real_of_ereal ( ((cmod a)::ereal) * ( SUP x. ( (norm (f x)) / norm x :: ereal) ) )
                 =  (cmod a) * real_of_ereal ( SUP x. ( (norm (f x)) / norm x :: ereal) )\<close>
       by simp
     moreover have \<open>real_of_ereal ( SUP x. ( (norm (f x)) / norm x :: ereal) )
                   = ( SUP x. ((norm (f x)) / norm x) )\<close>
     proof-
       have \<open>\<bar> ( SUP i\<in>UNIV::'a set. ereal ((\<lambda> x. (norm (f x)) / norm x) i)) \<bar> \<noteq> \<infinity>\<close>
       proof-
         have \<open>\<exists> K::real. \<forall> x. (\<bar> ereal ((norm (f x)) / (norm x)) \<bar>) \<le> K\<close>
           using \<open>bounded_linear f\<close> le_onorm by fastforce
         then obtain K::real where \<open>\<forall> x. (\<bar> ereal ((norm (f x)) / (norm x)) \<bar>) \<le> K\<close>
           by blast
         hence \<open>bdd_above {ereal ((norm (f x)) / (norm x)) | x. True}\<close>
           by simp
         moreover have \<open>{ereal ((norm (f x)) / (norm x)) | x. True} \<noteq> {}\<close>
           by auto
         ultimately have \<open>(SUP x. \<bar>ereal ((norm (f x)) / (norm x))\<bar>) \<le> K\<close>
           using \<open>\<forall> x. \<bar> ereal ((norm (f x)) / (norm x)) \<bar> \<le> K\<close>
             Sup_least mem_Collect_eq
-          by (simp add: SUP_le_iff) 
+          by (simp add: SUP_le_iff)
         hence \<open>\<bar>SUP x. ereal ((norm (f x)) / (norm x))\<bar>
               \<le> (SUP x. \<bar>ereal ((norm (f x)) / (norm x))\<bar>)\<close>
           using  \<open>bdd_above {ereal ((norm (f x)) / (norm x)) | x. True}\<close>
             \<open>{ereal ((norm (f x)) / (norm x)) | x. True} \<noteq> {}\<close>
           by (metis (mono_tags, lifting) SUP_upper2 Sup.SUP_cong UNIV_I \<open>\<And>i. i \<in> UNIV \<Longrightarrow> 0 \<le> ereal (norm (f i) / norm i)\<close> abs_ereal_ge0 ereal_le_real)
         hence \<open>\<bar>SUP x. ereal ((norm (f x)) / (norm x))\<bar> \<le> K\<close>
           using  \<open>(SUP x. \<bar>ereal ((norm (f x)) / (norm x))\<bar>) \<le> K\<close>
           by simp
         thus ?thesis
-          by auto 
+          by auto
       qed
       hence \<open> ( SUP i\<in>UNIV::'a set. ereal ((\<lambda> x. (norm (f x)) / norm x) i))
              = ereal ( Sup ((\<lambda> x. (norm (f x)) / norm x) ` (UNIV::'a set) ))\<close>
-        by (simp add: ereal_SUP) 
+        by (simp add: ereal_SUP)
       thus ?thesis
-        by simp         
+        by simp
     qed
     have z3: \<open>real_of_ereal ( ((cmod a)::ereal) * ( SUP x. ( (norm (f x)) / norm x :: ereal) ) )
                 = cmod a * (SUP x. norm (f x) / norm x)\<close>
       by (simp add: \<open>real_of_ereal (SUP x. ereal (norm (f x) / norm x)) = (SUP x. norm (f x) / norm x)\<close>)
     hence w1: \<open>(SUP x. cmod a * (norm (f x) / norm x)) =
           cmod a * (SUP x. norm (f x) / norm x)\<close>
-      using z1 z2 by linarith     
+      using z1 z2 by linarith
     have v1: \<open>onorm (\<lambda>x. a *\<^sub>C f x) = (SUP x. norm (a *\<^sub>C f x) / norm x)\<close>
       by (simp add: onorm_def)
     have v2: \<open>(SUP x. norm (a *\<^sub>C f x) / norm x) = (SUP x. ((cmod a) * norm (f x)) / norm x)\<close>
       by simp
     have v3: \<open>(SUP x. ((cmod a) * norm (f x)) / norm x) =  (SUP x. (cmod a) * ((norm (f x)) / norm x))\<close>
       by simp
     have v4: \<open>(SUP x. (cmod a) * ((norm (f x)) / norm x)) = (cmod a) *  (SUP x. ((norm (f x)) / norm x))\<close>
       using w1
       by blast
     show \<open>onorm (\<lambda>x. a *\<^sub>C f x) = cmod a * onorm f\<close>
       using v1 v2 v3 v4
       by (metis (mono_tags, lifting) onorm_def)
   qed
-  thus \<open>norm (a *\<^sub>C x) = cmod a * norm x\<close> 
+  thus \<open>norm (a *\<^sub>C x) = cmod a * norm x\<close>
     for a::complex and x::\<open>('a, 'b) blinfun\<close>
     apply transfer
     by blast
 qed
 end
 
 (* We do not have clinear_blinfun_compose_right *)
 lemma clinear_blinfun_compose_left: \<open>clinear (\<lambda>x. blinfun_compose x y)\<close>
   by (auto intro!: clinearI simp: blinfun_eqI scaleC_blinfun.rep_eq bounded_bilinear.add_left
                                   bounded_bilinear_blinfun_compose)
 
 instantiation blinfun :: (real_normed_vector, cbanach) "cbanach"
 begin
 instance..
 end
 
 lemma blinfun_compose_assoc: "(A o\<^sub>L B) o\<^sub>L C = A o\<^sub>L (B  o\<^sub>L C)"
   by (simp add: blinfun_eqI)
 
-lift_definition blinfun_of_cblinfun::\<open>'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector 
+lift_definition blinfun_of_cblinfun::\<open>'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector
   \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b\<close> is "id"
   apply transfer by (simp add: bounded_clinear.bounded_linear)
 
-lift_definition blinfun_cblinfun_eq :: 
+lift_definition blinfun_cblinfun_eq ::
   \<open>'a \<Rightarrow>\<^sub>L 'b \<Rightarrow> 'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector \<Rightarrow> bool\<close> is "(=)" .
 
 lemma blinfun_cblinfun_eq_bi_unique[transfer_rule]: \<open>bi_unique blinfun_cblinfun_eq\<close>
   unfolding bi_unique_def apply transfer by auto
 
 lemma blinfun_cblinfun_eq_right_total[transfer_rule]: \<open>right_total blinfun_cblinfun_eq\<close>
   unfolding right_total_def apply transfer
   by (simp add: bounded_clinear.bounded_linear)
 
 named_theorems cblinfun_blinfun_transfer
 
 lemma cblinfun_blinfun_transfer_0[cblinfun_blinfun_transfer]:
   "blinfun_cblinfun_eq (0::(_,_) blinfun) (0::(_,_) cblinfun)"
   apply transfer by simp
 
 lemma cblinfun_blinfun_transfer_plus[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(blinfun_cblinfun_eq ===> blinfun_cblinfun_eq ===> blinfun_cblinfun_eq) (+) (+)"
   unfolding rel_fun_def apply transfer by auto
 
 lemma cblinfun_blinfun_transfer_minus[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(blinfun_cblinfun_eq ===> blinfun_cblinfun_eq ===> blinfun_cblinfun_eq) (-) (-)"
   unfolding rel_fun_def apply transfer by auto
 
 lemma cblinfun_blinfun_transfer_uminus[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(blinfun_cblinfun_eq ===> blinfun_cblinfun_eq) (uminus) (uminus)"
   unfolding rel_fun_def apply transfer by auto
 
 definition "real_complex_eq r c \<longleftrightarrow> complex_of_real r = c"
 
 lemma bi_unique_real_complex_eq[transfer_rule]: \<open>bi_unique real_complex_eq\<close>
   unfolding real_complex_eq_def bi_unique_def by auto
 
 lemma left_total_real_complex_eq[transfer_rule]: \<open>left_total real_complex_eq\<close>
   unfolding real_complex_eq_def left_total_def by auto
 
 lemma cblinfun_blinfun_transfer_scaleC[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(real_complex_eq ===> blinfun_cblinfun_eq ===> blinfun_cblinfun_eq) (scaleR) (scaleC)"
   unfolding rel_fun_def apply transfer
   by (simp add: real_complex_eq_def scaleR_scaleC)
 
 lemma cblinfun_blinfun_transfer_CBlinfun[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(eq_onp bounded_clinear ===> blinfun_cblinfun_eq) Blinfun CBlinfun"
   unfolding rel_fun_def blinfun_cblinfun_eq.rep_eq eq_onp_def
   by (auto simp: CBlinfun_inverse Blinfun_inverse bounded_clinear.bounded_linear)
 
 lemma cblinfun_blinfun_transfer_norm[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(blinfun_cblinfun_eq ===> (=)) norm norm"
   unfolding rel_fun_def apply transfer by auto
 
 lemma cblinfun_blinfun_transfer_dist[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(blinfun_cblinfun_eq ===> blinfun_cblinfun_eq ===> (=)) dist dist"
   unfolding rel_fun_def dist_norm apply transfer by auto
 
 lemma cblinfun_blinfun_transfer_sgn[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(blinfun_cblinfun_eq ===> blinfun_cblinfun_eq) sgn sgn"
-  unfolding rel_fun_def sgn_blinfun_def sgn_cblinfun_def apply transfer 
+  unfolding rel_fun_def sgn_blinfun_def sgn_cblinfun_def apply transfer
   by (auto simp: scaleR_scaleC)
 
 lemma cblinfun_blinfun_transfer_Cauchy[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(((=) ===> blinfun_cblinfun_eq) ===> (=)) Cauchy Cauchy"
 proof -
   note cblinfun_blinfun_transfer[transfer_rule]
   show ?thesis
     unfolding Cauchy_def
     by transfer_prover
 qed
 
 lemma cblinfun_blinfun_transfer_tendsto[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(((=) ===> blinfun_cblinfun_eq) ===> blinfun_cblinfun_eq ===> (=) ===> (=)) tendsto tendsto"
 proof -
   note cblinfun_blinfun_transfer[transfer_rule]
   show ?thesis
     unfolding tendsto_iff
     by transfer_prover
 qed
 
 lemma cblinfun_blinfun_transfer_compose[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(blinfun_cblinfun_eq ===> blinfun_cblinfun_eq ===> blinfun_cblinfun_eq) (o\<^sub>L) (o\<^sub>C\<^sub>L)"
   unfolding rel_fun_def apply transfer by auto
 
 lemma cblinfun_blinfun_transfer_apply[cblinfun_blinfun_transfer]:
   includes lifting_syntax
   shows "(blinfun_cblinfun_eq ===> (=) ===> (=)) blinfun_apply cblinfun_apply"
   unfolding rel_fun_def apply transfer by auto
 
 lemma blinfun_of_cblinfun_inj:
   \<open>blinfun_of_cblinfun f = blinfun_of_cblinfun g \<Longrightarrow> f = g\<close>
   by (metis cblinfun_apply_inject blinfun_of_cblinfun.rep_eq)
 
 lemma blinfun_of_cblinfun_inv:
   assumes "\<And>c. \<And>x. f *\<^sub>v (c *\<^sub>C x) = c *\<^sub>C (f *\<^sub>v x)"
   shows "\<exists>g. blinfun_of_cblinfun g = f"
   using assms
 proof transfer
   show "\<exists>g\<in>Collect bounded_clinear. id g = f"
     if "bounded_linear f"
       and "\<And>c x. f (c *\<^sub>C x) = c *\<^sub>C f x"
     for f :: "'a \<Rightarrow> 'b"
-    using that bounded_linear_bounded_clinear by auto 
-qed  
+    using that bounded_linear_bounded_clinear by auto
+qed
 
 lemma blinfun_of_cblinfun_zero:
   \<open>blinfun_of_cblinfun 0 = 0\<close>
   apply transfer by simp
 
 lemma blinfun_of_cblinfun_uminus:
   \<open>blinfun_of_cblinfun (- f) = - (blinfun_of_cblinfun f)\<close>
   apply transfer
   by auto
 
 lemma blinfun_of_cblinfun_minus:
   \<open>blinfun_of_cblinfun (f - g) = blinfun_of_cblinfun f - blinfun_of_cblinfun g\<close>
   apply transfer
   by auto
 
 lemma blinfun_of_cblinfun_scaleC:
   \<open>blinfun_of_cblinfun (c *\<^sub>C f) = c *\<^sub>C (blinfun_of_cblinfun f)\<close>
   apply transfer
   by auto
 
 lemma blinfun_of_cblinfun_scaleR:
   \<open>blinfun_of_cblinfun (c *\<^sub>R f) = c *\<^sub>R (blinfun_of_cblinfun f)\<close>
   apply transfer by auto
 
 lemma blinfun_of_cblinfun_norm:
   fixes f::\<open>'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector\<close>
   shows \<open>norm f = norm (blinfun_of_cblinfun f)\<close>
   apply transfer by auto
 
 subsection \<open>Composition\<close>
 
 lemma blinfun_of_cblinfun_cblinfun_compose:
   fixes f::\<open>'b::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'c::complex_normed_vector\<close>
     and g::\<open>'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b\<close>
   shows \<open>blinfun_of_cblinfun (f  o\<^sub>C\<^sub>L g) = (blinfun_of_cblinfun f) o\<^sub>L (blinfun_of_cblinfun g)\<close>
   apply transfer by auto
 
-lemma cblinfun_compose_assoc: 
+lemma cblinfun_compose_assoc:
   shows "(A o\<^sub>C\<^sub>L B) o\<^sub>C\<^sub>L C = A o\<^sub>C\<^sub>L (B o\<^sub>C\<^sub>L C)"
   by (metis (no_types, lifting) cblinfun_apply_inject fun.map_comp cblinfun_compose.rep_eq)
 
 lemma cblinfun_compose_zero_right[simp]: "U o\<^sub>C\<^sub>L 0 = 0"
   using bounded_cbilinear.zero_right bounded_cbilinear_cblinfun_compose by blast
 
 lemma cblinfun_compose_zero_left[simp]: "0 o\<^sub>C\<^sub>L U = 0"
   using bounded_cbilinear.zero_left bounded_cbilinear_cblinfun_compose by blast
 
 lemma cblinfun_compose_scaleC_left[simp]:
   fixes A::"'b::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'c::complex_normed_vector"
     and B::"'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b"
   shows \<open>(a *\<^sub>C A) o\<^sub>C\<^sub>L B = a *\<^sub>C (A o\<^sub>C\<^sub>L B)\<close>
   by (simp add: bounded_cbilinear.scaleC_left bounded_cbilinear_cblinfun_compose)
 
 lemma cblinfun_compose_scaleR_left[simp]:
   fixes A::"'b::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'c::complex_normed_vector"
     and B::"'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b"
   shows \<open>(a *\<^sub>R A) o\<^sub>C\<^sub>L B = a *\<^sub>R (A o\<^sub>C\<^sub>L B)\<close>
   by (simp add: scaleR_scaleC)
 
 lemma cblinfun_compose_scaleC_right[simp]:
-  fixes A::"'b::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'c::complex_normed_vector" 
+  fixes A::"'b::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'c::complex_normed_vector"
     and B::"'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b"
   shows \<open>A o\<^sub>C\<^sub>L (a *\<^sub>C B) = a *\<^sub>C (A o\<^sub>C\<^sub>L B)\<close>
   apply transfer by (auto intro!: ext bounded_clinear.clinear complex_vector.linear_scale)
 
 lemma cblinfun_compose_scaleR_right[simp]:
-  fixes A::"'b::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'c::complex_normed_vector" 
+  fixes A::"'b::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'c::complex_normed_vector"
     and B::"'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b"
   shows \<open>A o\<^sub>C\<^sub>L (a *\<^sub>R B) = a *\<^sub>R (A o\<^sub>C\<^sub>L B)\<close>
   by (simp add: scaleR_scaleC)
 
-lemma cblinfun_compose_id_right[simp]: 
+lemma cblinfun_compose_id_right[simp]:
   shows "U o\<^sub>C\<^sub>L id_cblinfun = U"
   apply transfer by auto
 
-lemma cblinfun_compose_id_left[simp]: 
+lemma cblinfun_compose_id_left[simp]:
   shows "id_cblinfun o\<^sub>C\<^sub>L U  = U"
   apply transfer by auto
 
 lemma cblinfun_eq_on:
   fixes A B :: "'a::cbanach \<Rightarrow>\<^sub>C\<^sub>L'b::complex_normed_vector"
   assumes "\<And>x. x \<in> G \<Longrightarrow> A *\<^sub>V x = B *\<^sub>V x" and \<open>t \<in> closure (cspan G)\<close>
   shows "A *\<^sub>V t = B *\<^sub>V t"
   using assms
   apply transfer
   using bounded_clinear_eq_on by blast
 
 lemma cblinfun_eq_gen_eqI:
   fixes A B :: "'a::cbanach \<Rightarrow>\<^sub>C\<^sub>L'b::complex_normed_vector"
   assumes "\<And>x. x \<in> G \<Longrightarrow> A *\<^sub>V x = B *\<^sub>V x" and \<open>ccspan G = \<top>\<close>
   shows "A = B"
   apply (rule cblinfun_eqI)
   apply (rule cblinfun_eq_on[where G=G])
   using assms apply auto
   by (metis ccspan.rep_eq iso_tuple_UNIV_I top_ccsubspace.rep_eq)
 
 lemma cblinfun_compose_add_left: \<open>(a + b) o\<^sub>C\<^sub>L c = (a o\<^sub>C\<^sub>L c) + (b o\<^sub>C\<^sub>L c)\<close>
   by (simp add: bounded_cbilinear.add_left bounded_cbilinear_cblinfun_compose)
 
 lemma cblinfun_compose_add_right: \<open>a o\<^sub>C\<^sub>L (b + c) = (a o\<^sub>C\<^sub>L b) + (a o\<^sub>C\<^sub>L c)\<close>
   by (simp add: bounded_cbilinear.add_right bounded_cbilinear_cblinfun_compose)
 
 lemma cbilinear_cblinfun_compose[simp]: "cbilinear cblinfun_compose"
   by (auto intro!: clinearI simp add: cbilinear_def bounded_cbilinear.add_left bounded_cbilinear.add_right bounded_cbilinear_cblinfun_compose)
 
 
 subsection \<open>Adjoint\<close>
 
 lift_definition
   adj :: "'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_inner \<Rightarrow> 'b \<Rightarrow>\<^sub>C\<^sub>L 'a" ("_*" [99] 100)
   is cadjoint by (fact cadjoint_bounded_clinear)
 
 lemma id_cblinfun_adjoint[simp]: "id_cblinfun* = id_cblinfun"
   apply transfer using cadjoint_id
   by (metis eq_id_iff)
 
-lemma double_adj[simp]: "(A*)* = A" 
+lemma double_adj[simp]: "(A*)* = A"
   apply transfer using double_cadjoint by blast
 
 lemma adj_cblinfun_compose[simp]:
   fixes B::\<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b::chilbert_space\<close>
-    and A::\<open>'b \<Rightarrow>\<^sub>C\<^sub>L 'c::complex_inner\<close> 
+    and A::\<open>'b \<Rightarrow>\<^sub>C\<^sub>L 'c::complex_inner\<close>
   shows "(A o\<^sub>C\<^sub>L B)* =  (B*) o\<^sub>C\<^sub>L (A*)"
 proof transfer
   fix  A :: \<open>'b \<Rightarrow> 'c\<close> and B :: \<open>'a \<Rightarrow> 'b\<close>
   assume \<open>bounded_clinear A\<close> and \<open>bounded_clinear B\<close>
   hence \<open>bounded_clinear (A \<circ> B)\<close>
     by (simp add: comp_bounded_clinear)
   have \<open>\<langle> (A \<circ> B) u, v \<rangle> = \<langle> u, (B\<^sup>\<dagger> \<circ> A\<^sup>\<dagger>) v \<rangle>\<close>
     for u v
-    by (metis (no_types, lifting) cadjoint_univ_prop \<open>bounded_clinear A\<close> \<open>bounded_clinear B\<close> cinner_commute' comp_def)    
+    by (metis (no_types, lifting) cadjoint_univ_prop \<open>bounded_clinear A\<close> \<open>bounded_clinear B\<close> cinner_commute' comp_def)
   thus \<open>(A \<circ> B)\<^sup>\<dagger> = B\<^sup>\<dagger> \<circ> A\<^sup>\<dagger>\<close>
     using \<open>bounded_clinear (A \<circ> B)\<close>
     by (metis cadjoint_eqI cinner_commute')
 qed
 
-lemma scaleC_adj[simp]: "(a *\<^sub>C A)* = (cnj a) *\<^sub>C (A*)" 
+lemma scaleC_adj[simp]: "(a *\<^sub>C A)* = (cnj a) *\<^sub>C (A*)"
   apply transfer
   by (simp add: Complex_Vector_Spaces0.bounded_clinear.bounded_linear bounded_clinear_def complex_vector.linear_scale scaleC_cadjoint)
 
-lemma scaleR_adj[simp]: "(a *\<^sub>R A)* = a *\<^sub>R (A*)" 
+lemma scaleR_adj[simp]: "(a *\<^sub>R A)* = a *\<^sub>R (A*)"
   by (simp add: scaleR_scaleC)
 
 lemma adj_plus: \<open>(A + B)* = (A*) + (B*)\<close>
 proof transfer
   fix A B::\<open>'b \<Rightarrow> 'a\<close>
   assume a1: \<open>bounded_clinear A\<close> and a2: \<open>bounded_clinear B\<close>
   define F where \<open>F = (\<lambda>x. (A\<^sup>\<dagger>) x + (B\<^sup>\<dagger>) x)\<close>
   define G where \<open>G = (\<lambda>x. A x + B x)\<close>
   have \<open>bounded_clinear G\<close>
     unfolding G_def
     by (simp add: a1 a2 bounded_clinear_add)
   moreover have \<open>\<langle>F u,  v\<rangle> = \<langle>u, G v\<rangle>\<close> for u v
     unfolding F_def G_def
     using cadjoint_univ_prop a1 a2 cinner_add_left
-    by (simp add: cadjoint_univ_prop cinner_add_left cinner_add_right) 
+    by (simp add: cadjoint_univ_prop cinner_add_left cinner_add_right)
   ultimately have \<open>F = G\<^sup>\<dagger> \<close>
     using cadjoint_eqI by blast
   thus \<open>(\<lambda>x. A x + B x)\<^sup>\<dagger> = (\<lambda>x. (A\<^sup>\<dagger>) x + (B\<^sup>\<dagger>) x)\<close>
     unfolding F_def G_def
     by auto
 qed
 
-lemma cinner_sup_norm_cblinfun: 
+lemma cinner_sup_norm_cblinfun:
   fixes A :: \<open>'a::{complex_normed_vector,not_singleton} \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_inner\<close>
   shows \<open>norm A = (SUP (\<psi>,\<phi>). cmod (cinner \<psi> (A *\<^sub>V \<phi>)) / (norm \<psi> * norm \<phi>))\<close>
   apply transfer
   apply (rule cinner_sup_onorm)
   by (simp add: bounded_clinear.bounded_linear)
 
 lemma cinner_adj_left:
   fixes G :: "'b::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'a::complex_inner"
   shows \<open>\<langle>G* *\<^sub>V x, y\<rangle> = \<langle>x, G *\<^sub>V y\<rangle>\<close>
   apply transfer using cadjoint_univ_prop by blast
 
 lemma cinner_adj_right:
   fixes G :: "'b::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'a::complex_inner"
-  shows \<open>\<langle>x, G* *\<^sub>V y\<rangle> = \<langle>G *\<^sub>V x, y\<rangle>\<close> 
+  shows \<open>\<langle>x, G* *\<^sub>V y\<rangle> = \<langle>G *\<^sub>V x, y\<rangle>\<close>
   apply transfer using cadjoint_univ_prop' by blast
 
 lemma adj_0[simp]: \<open>0* = 0\<close>
   by (metis add_cancel_right_left adj_plus)
 
-lemma norm_adj[simp]: \<open>norm (A*) = norm A\<close> 
+lemma norm_adj[simp]: \<open>norm (A*) = norm A\<close>
   for A :: \<open>'b::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'c::complex_inner\<close>
 proof (cases \<open>(\<exists>x y :: 'b. x \<noteq> y) \<and> (\<exists>x y :: 'c. x \<noteq> y)\<close>)
   case True
   then have c1: \<open>class.not_singleton TYPE('b)\<close>
     apply intro_classes by simp
   from True have c2: \<open>class.not_singleton TYPE('c)\<close>
     apply intro_classes by simp
   have normA: \<open>norm A = (SUP (\<psi>, \<phi>). cmod (\<psi> \<bullet>\<^sub>C (A *\<^sub>V \<phi>)) / (norm \<psi> * norm \<phi>))\<close>
     apply (rule cinner_sup_norm_cblinfun[internalize_sort \<open>'a::{complex_normed_vector,not_singleton}\<close>])
      apply (rule complex_normed_vector_axioms)
     by (rule c1)
   have normAadj: \<open>norm (A*) = (SUP (\<psi>, \<phi>). cmod (\<psi> \<bullet>\<^sub>C (A* *\<^sub>V \<phi>)) / (norm \<psi> * norm \<phi>))\<close>
     apply (rule cinner_sup_norm_cblinfun[internalize_sort \<open>'a::{complex_normed_vector,not_singleton}\<close>])
      apply (rule complex_normed_vector_axioms)
     by (rule c2)
 
   have \<open>norm (A*) = (SUP (\<psi>, \<phi>). cmod (\<phi> \<bullet>\<^sub>C (A *\<^sub>V \<psi>)) / (norm \<psi> * norm \<phi>))\<close>
     unfolding normAadj
     apply (subst cinner_adj_right)
     apply (subst cinner_commute)
     apply (subst complex_mod_cnj)
     by rule
   also have \<open>\<dots> = Sup ((\<lambda>(\<psi>, \<phi>). cmod (\<phi> \<bullet>\<^sub>C (A *\<^sub>V \<psi>)) / (norm \<psi> * norm \<phi>)) ` prod.swap ` UNIV)\<close>
     by auto
   also have \<open>\<dots> = (SUP (\<phi>, \<psi>). cmod (\<phi> \<bullet>\<^sub>C (A *\<^sub>V \<psi>)) / (norm \<psi> * norm \<phi>))\<close>
     apply (subst image_image)
     by auto
   also have \<open>\<dots> = norm A\<close>
     unfolding normA
     by (simp add: mult.commute)
   finally show ?thesis
     by -
 next
   case False
   then consider (b) \<open>\<And>x::'b. x = 0\<close> | (c) \<open>\<And>x::'c. x = 0\<close>
     by auto
   then have \<open>A = 0\<close>
     apply (cases; transfer)
-     apply (metis (full_types) bounded_clinear_def complex_vector.linear_0) 
+     apply (metis (full_types) bounded_clinear_def complex_vector.linear_0)
     by auto
   then show \<open>norm (A*) = norm A\<close>
     by simp
 qed
 
 
 lemma antilinear_adj[simp]: \<open>antilinear adj\<close>
   apply (rule antilinearI) by (auto simp add: adj_plus)
 
 lemma bounded_antilinear_adj[bounded_antilinear, simp]: \<open>bounded_antilinear adj\<close>
   by (auto intro!: antilinearI exI[of _ 1] simp: bounded_antilinear_def bounded_antilinear_axioms_def adj_plus)
 
 lemma adjoint_eqI:
   fixes G:: \<open>'b::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'a::chilbert_space\<close>
     and F:: \<open>'a \<Rightarrow>\<^sub>C\<^sub>L 'b\<close>
   assumes \<open>\<And>x y. \<langle>(cblinfun_apply F) x, y\<rangle> = \<langle>x, (cblinfun_apply G) y\<rangle>\<close>
   shows \<open>F = G*\<close>
   using assms apply transfer using cadjoint_eqI by auto
 
-lemma cinner_real_hermiteanI: 
+lemma cinner_real_hermiteanI:
   \<comment> \<open>Prop. II.2.12 in @{cite conway2013course}\<close>
   assumes \<open>\<And>\<psi>. cinner \<psi> (A *\<^sub>V \<psi>) \<in> \<real>\<close>
   shows \<open>A = A*\<close>
 proof -
   { fix g h :: 'a
     {
       fix \<alpha> :: complex
       have \<open>cinner h (A h) + cnj \<alpha> *\<^sub>C cinner g (A h) + \<alpha> *\<^sub>C cinner h (A g) + (abs \<alpha>)\<^sup>2 * cinner g (A g)
         = cinner (h + \<alpha> *\<^sub>C g) (A *\<^sub>V (h + \<alpha> *\<^sub>C g))\<close> (is \<open>?sum4 = _\<close>)
         apply (auto simp: cinner_add_right cinner_add_left cblinfun.add_right cblinfun.scaleC_right ring_class.ring_distribs)
         by (metis cnj_x_x mult.commute)
       also have \<open>\<dots> \<in> \<real>\<close>
         using assms by auto
       finally have \<open>?sum4 = cnj ?sum4\<close>
         using Reals_cnj_iff by fastforce
       then have \<open>cnj \<alpha> *\<^sub>C cinner g (A h) + \<alpha> *\<^sub>C cinner h (A g)
             = \<alpha> *\<^sub>C cinner (A h) g + cnj \<alpha> *\<^sub>C cinner (A g) h\<close>
         using Reals_cnj_iff abs_complex_real assms by force
       also have \<open>\<dots> = \<alpha> *\<^sub>C cinner h (A* *\<^sub>V g) + cnj \<alpha> *\<^sub>C cinner g (A* *\<^sub>V h)\<close>
         by (simp add: cinner_adj_right)
       finally have \<open>cnj \<alpha> *\<^sub>C cinner g (A h) + \<alpha> *\<^sub>C cinner h (A g) = \<alpha> *\<^sub>C cinner h (A* *\<^sub>V g) + cnj \<alpha> *\<^sub>C cinner g (A* *\<^sub>V h)\<close>
         by -
     }
     from this[where \<alpha>2=1] this[where \<alpha>2=\<i>]
     have 1: \<open>cinner g (A h) + cinner h (A g) = cinner h (A* *\<^sub>V g) + cinner g (A* *\<^sub>V h)\<close>
       and i: \<open>- \<i> * cinner g (A h) + \<i> *\<^sub>C cinner h (A g) =  \<i> *\<^sub>C cinner h (A* *\<^sub>V g) - \<i> *\<^sub>C cinner g (A* *\<^sub>V h)\<close>
       by auto
     from arg_cong2[OF 1 arg_cong[OF i, where f=\<open>(*) (-\<i>)\<close>], where f=plus]
     have \<open>cinner h (A g) = cinner h (A* *\<^sub>V g)\<close>
       by (auto simp: ring_class.ring_distribs)
   }
   then show "A = A*"
     by (simp add: adjoint_eqI cinner_adj_right)
 qed
 
 
 lemma norm_AAadj[simp]: \<open>norm (A o\<^sub>C\<^sub>L A*) = (norm A)\<^sup>2\<close> for A :: \<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b::{complex_inner}\<close>
 proof (cases \<open>class.not_singleton TYPE('b)\<close>)
   case True
   then have [simp]: \<open>class.not_singleton TYPE('b)\<close>
     by -
   have 1: \<open>(norm A)\<^sup>2 * \<epsilon> \<le> norm (A o\<^sub>C\<^sub>L A*)\<close> if \<open>\<epsilon> < 1\<close> and \<open>\<epsilon> \<ge> 0\<close> for \<epsilon>
   proof -
     obtain \<psi> where \<psi>: \<open>norm ((A*) *\<^sub>V \<psi>) \<ge> norm (A*) * sqrt \<epsilon>\<close> and [simp]: \<open>norm \<psi> = 1\<close>
       apply atomize_elim
       apply (rule cblinfun_norm_approx_witness_mult[internalize_sort' 'a])
       using \<open>\<epsilon> < 1\<close> by (auto intro: complex_normed_vector_class.complex_normed_vector_axioms)
     have \<open>complex_of_real ((norm A)\<^sup>2 * \<epsilon>) = (norm (A*) * sqrt \<epsilon>)\<^sup>2\<close>
       by (simp add: ordered_field_class.sign_simps(23) that(2))
     also have \<open>\<dots> \<le> (norm ((A* *\<^sub>V \<psi>)))\<^sup>2\<close>
       apply (rule complex_of_real_mono)
       using \<psi> apply (rule power_mono)
       using \<open>\<epsilon> \<ge> 0\<close> by auto
     also have \<open>\<dots> \<le> cinner (A* *\<^sub>V \<psi>) (A* *\<^sub>V \<psi>)\<close>
       by (auto simp flip: power2_norm_eq_cinner)
     also have \<open>\<dots> = cinner \<psi> (A *\<^sub>V A* *\<^sub>V \<psi>)\<close>
       by (simp add: cinner_adj_left)
     also have \<open>\<dots> = cinner \<psi> ((A o\<^sub>C\<^sub>L A*) *\<^sub>V \<psi>)\<close>
       by auto
     also have \<open>\<dots> \<le> norm (A o\<^sub>C\<^sub>L A*)\<close>
       using \<open>norm \<psi> = 1\<close>
-      by (smt (verit, best) Im_complex_of_real Re_complex_of_real \<open>(A* *\<^sub>V \<psi>) \<bullet>\<^sub>C (A* *\<^sub>V \<psi>) = \<psi> \<bullet>\<^sub>C (A *\<^sub>V A* *\<^sub>V \<psi>)\<close> \<open>\<psi> \<bullet>\<^sub>C (A *\<^sub>V A* *\<^sub>V \<psi>) = \<psi> \<bullet>\<^sub>C ((A o\<^sub>C\<^sub>L A*) *\<^sub>V \<psi>)\<close> cdot_square_norm cinner_ge_zero cmod_Re complex_inner_class.Cauchy_Schwarz_ineq2 less_eq_complex_def mult_cancel_left1 mult_cancel_right1 norm_cblinfun) 
+      by (smt (verit, best) Im_complex_of_real Re_complex_of_real \<open>(A* *\<^sub>V \<psi>) \<bullet>\<^sub>C (A* *\<^sub>V \<psi>) = \<psi> \<bullet>\<^sub>C (A *\<^sub>V A* *\<^sub>V \<psi>)\<close> \<open>\<psi> \<bullet>\<^sub>C (A *\<^sub>V A* *\<^sub>V \<psi>) = \<psi> \<bullet>\<^sub>C ((A o\<^sub>C\<^sub>L A*) *\<^sub>V \<psi>)\<close> cdot_square_norm cinner_ge_zero cmod_Re complex_inner_class.Cauchy_Schwarz_ineq2 less_eq_complex_def mult_cancel_left1 mult_cancel_right1 norm_cblinfun)
     finally show ?thesis
       by auto
   qed
   then have 1: \<open>(norm A)\<^sup>2 \<le> norm (A o\<^sub>C\<^sub>L A*)\<close>
     by (metis field_le_mult_one_interval less_eq_real_def ordered_field_class.sign_simps(5))
 
   have 2: \<open>norm (A o\<^sub>C\<^sub>L A*) \<le> (norm A)\<^sup>2\<close>
   proof (rule norm_cblinfun_bound)
     show \<open>0 \<le> (norm A)\<^sup>2\<close> by simp
     fix \<psi>
     have \<open>norm ((A o\<^sub>C\<^sub>L A*) *\<^sub>V \<psi>) = norm (A *\<^sub>V A* *\<^sub>V \<psi>)\<close>
       by auto
     also have \<open>\<dots> \<le> norm A * norm (A* *\<^sub>V \<psi>)\<close>
       by (simp add: norm_cblinfun)
     also have \<open>\<dots> \<le> norm A * norm (A*) * norm \<psi>\<close>
       by (metis mult.assoc norm_cblinfun norm_imp_pos_and_ge ordered_comm_semiring_class.comm_mult_left_mono)
     also have \<open>\<dots> = (norm A)\<^sup>2 * norm \<psi>\<close>
       by (simp add: power2_eq_square)
     finally show \<open>norm ((A o\<^sub>C\<^sub>L A*) *\<^sub>V \<psi>) \<le> (norm A)\<^sup>2 * norm \<psi>\<close>
       by -
   qed
 
   from 1 2 show ?thesis by simp
 next
   case False
   then have [simp]: \<open>class.CARD_1 TYPE('b)\<close>
     by (rule not_singleton_vs_CARD_1)
   have \<open>A = 0\<close>
     apply (rule cblinfun_to_CARD_1_0[internalize_sort' 'b])
     by (auto intro: complex_normed_vector_class.complex_normed_vector_axioms)
   then show ?thesis
     by auto
 qed
 
 subsection \<open>Unitaries / isometries\<close>
 
 
 definition isometry::\<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_inner \<Rightarrow> bool\<close> where
   \<open>isometry U \<longleftrightarrow> U* o\<^sub>C\<^sub>L U = id_cblinfun\<close>
 
 definition unitary::\<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_inner \<Rightarrow> bool\<close> where
   \<open>unitary U \<longleftrightarrow> (U* o\<^sub>C\<^sub>L U  = id_cblinfun) \<and> (U o\<^sub>C\<^sub>L U* = id_cblinfun)\<close>
 
 lemma unitary_twosided_isometry: "unitary U \<longleftrightarrow> isometry U \<and> isometry (U*)"
   unfolding unitary_def isometry_def by simp
 
-lemma isometryD[simp]: "isometry U \<Longrightarrow> U* o\<^sub>C\<^sub>L U = id_cblinfun" 
+lemma isometryD[simp]: "isometry U \<Longrightarrow> U* o\<^sub>C\<^sub>L U = id_cblinfun"
   unfolding isometry_def by simp
 
 (* Not [simp] because isometryD[simp] + unitary_isometry[simp] already have the same effect *)
-lemma unitaryD1: "unitary U \<Longrightarrow> U* o\<^sub>C\<^sub>L U = id_cblinfun" 
+lemma unitaryD1: "unitary U \<Longrightarrow> U* o\<^sub>C\<^sub>L U = id_cblinfun"
   unfolding unitary_def by simp
 
 lemma unitaryD2[simp]: "unitary U \<Longrightarrow> U o\<^sub>C\<^sub>L U* = id_cblinfun"
   unfolding unitary_def by simp
 
 lemma unitary_isometry[simp]: "unitary U \<Longrightarrow> isometry U"
   unfolding unitary_def isometry_def by simp
 
-lemma unitary_adj[simp]: "unitary (U*) = unitary U" 
+lemma unitary_adj[simp]: "unitary (U*) = unitary U"
   unfolding unitary_def by auto
 
-lemma isometry_cblinfun_compose[simp]: 
-  assumes "isometry A" and "isometry B"  
+lemma isometry_cblinfun_compose[simp]:
+  assumes "isometry A" and "isometry B"
   shows "isometry (A o\<^sub>C\<^sub>L B)"
 proof-
   have "B* o\<^sub>C\<^sub>L A* o\<^sub>C\<^sub>L (A o\<^sub>C\<^sub>L B) = id_cblinfun" if "A* o\<^sub>C\<^sub>L A = id_cblinfun" and "B* o\<^sub>C\<^sub>L B = id_cblinfun"
     using that
     by (smt (verit, del_insts) adjoint_eqI cblinfun_apply_cblinfun_compose cblinfun_id_cblinfun_apply)
-  thus ?thesis 
+  thus ?thesis
     using assms unfolding isometry_def by simp
 qed
 
 lemma unitary_cblinfun_compose[simp]: "unitary (A o\<^sub>C\<^sub>L B)"
   if "unitary A" and "unitary B"
   using that
-  by (smt (z3) adj_cblinfun_compose cblinfun_compose_assoc cblinfun_compose_id_right double_adj isometryD isometry_cblinfun_compose unitary_def unitary_isometry) 
-
-lemma unitary_surj: 
+  by (smt (z3) adj_cblinfun_compose cblinfun_compose_assoc cblinfun_compose_id_right double_adj isometryD isometry_cblinfun_compose unitary_def unitary_isometry)
+
+lemma unitary_surj:
   assumes "unitary U"
   shows "surj (cblinfun_apply U)"
   apply (rule surjI[where f=\<open>cblinfun_apply (U*)\<close>])
   using assms unfolding unitary_def apply transfer
   using comp_eq_dest_lhs by force
 
 lemma unitary_id[simp]: "unitary id_cblinfun"
-  by (simp add: unitary_def) 
+  by (simp add: unitary_def)
 
 lemma orthogonal_on_basis_is_isometry:
   assumes spanB: \<open>ccspan B = \<top>\<close>
   assumes orthoU: \<open>\<And>b c. b\<in>B \<Longrightarrow> c\<in>B \<Longrightarrow> cinner (U *\<^sub>V b) (U *\<^sub>V c) = cinner b c\<close>
   shows \<open>isometry U\<close>
 proof -
   have [simp]: \<open>b \<in> closure (cspan B)\<close> for b
     using spanB apply transfer by simp
   have *: \<open>cinner (U* *\<^sub>V U *\<^sub>V \<psi>) \<phi> = cinner \<psi> \<phi>\<close> if \<open>\<psi>\<in>B\<close> and \<open>\<phi>\<in>B\<close> for \<psi> \<phi>
     by (simp add: cinner_adj_left orthoU that(1) that(2))
   have *: \<open>cinner (U* *\<^sub>V U *\<^sub>V \<psi>) \<phi> = cinner \<psi> \<phi>\<close> if \<open>\<psi>\<in>B\<close> for \<psi> \<phi>
     apply (rule bounded_clinear_eq_on[where t=\<phi> and G=B])
     using bounded_clinear_cinner_right *[OF that]
     by auto
   have \<open>U* *\<^sub>V U *\<^sub>V \<phi> = \<phi>\<close> if \<open>\<phi>\<in>B\<close> for \<phi>
     apply (rule cinner_extensionality)
     apply (subst cinner_eq_flip)
     by (simp add: * that)
   then have \<open>U* o\<^sub>C\<^sub>L U = id_cblinfun\<close>
     by (metis cblinfun_apply_cblinfun_compose cblinfun_eq_gen_eqI cblinfun_id_cblinfun_apply spanB)
   then show \<open>isometry U\<close>
     using isometry_def by blast
 qed
 
 
 
 subsection \<open>Images\<close>
 
 
 (* Closure is necessary. See email 47a3bb3d-3cc3-0934-36eb-3ef0f7b70a85@ut.ee *)
 lift_definition cblinfun_image :: \<open>'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector
 \<Rightarrow> 'a ccsubspace \<Rightarrow> 'b ccsubspace\<close>  (infixr "*\<^sub>S" 70)
   is "\<lambda>A S. closure (A ` S)"
   using  bounded_clinear_def closed_closure  closed_csubspace.intro
-  by (simp add: bounded_clinear_def complex_vector.linear_subspace_image closure_is_closed_csubspace) 
+  by (simp add: bounded_clinear_def complex_vector.linear_subspace_image closure_is_closed_csubspace)
 
 lemma cblinfun_image_mono:
   assumes a1: "S \<le> T"
   shows "A *\<^sub>S S \<le> A *\<^sub>S T"
   using a1
   by (simp add: cblinfun_image.rep_eq closure_mono image_mono less_eq_ccsubspace.rep_eq)
 
-lemma cblinfun_image_0[simp]:  
+lemma cblinfun_image_0[simp]:
   shows "U *\<^sub>S 0 = 0"
   thm zero_ccsubspace_def
   apply transfer
   by (simp add: bounded_clinear_def complex_vector.linear_0)
 
 lemma cblinfun_image_bot[simp]: "U *\<^sub>S bot = bot"
   using cblinfun_image_0 by auto
 
-lemma cblinfun_image_sup[simp]:   
+lemma cblinfun_image_sup[simp]:
   fixes A B :: \<open>'a::chilbert_space ccsubspace\<close> and U :: "'a \<Rightarrow>\<^sub>C\<^sub>L'b::chilbert_space"
-  shows \<open>U *\<^sub>S (sup A B) = sup (U *\<^sub>S A) (U *\<^sub>S B)\<close>  
-  apply transfer using bounded_clinear.bounded_linear closure_image_closed_sum by blast 
+  shows \<open>U *\<^sub>S (sup A B) = sup (U *\<^sub>S A) (U *\<^sub>S B)\<close>
+  apply transfer using bounded_clinear.bounded_linear closure_image_closed_sum by blast
 
 lemma scaleC_cblinfun_image[simp]:
   fixes A :: \<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b :: chilbert_space\<close>
     and S :: \<open>'a ccsubspace\<close> and \<alpha> :: complex
   shows \<open>(\<alpha> *\<^sub>C A) *\<^sub>S S  = \<alpha> *\<^sub>C (A *\<^sub>S S)\<close>
 proof-
   have \<open>closure ( ( ((*\<^sub>C) \<alpha>) \<circ> (cblinfun_apply A) ) ` space_as_set S) =
    ((*\<^sub>C) \<alpha>) ` (closure (cblinfun_apply A ` space_as_set S))\<close>
-    by (metis closure_scaleC image_comp)    
+    by (metis closure_scaleC image_comp)
   hence \<open>(closure (cblinfun_apply (\<alpha> *\<^sub>C A) ` space_as_set S)) =
    ((*\<^sub>C) \<alpha>) ` (closure (cblinfun_apply A ` space_as_set S))\<close>
     by (metis (mono_tags, lifting) comp_apply image_cong scaleC_cblinfun.rep_eq)
   hence \<open>Abs_clinear_space (closure (cblinfun_apply (\<alpha> *\<^sub>C A) ` space_as_set S)) =
             \<alpha> *\<^sub>C Abs_clinear_space (closure (cblinfun_apply A ` space_as_set S))\<close>
-    by (metis space_as_set_inverse cblinfun_image.rep_eq scaleC_ccsubspace.rep_eq)    
+    by (metis space_as_set_inverse cblinfun_image.rep_eq scaleC_ccsubspace.rep_eq)
   have x1: "Abs_clinear_space (closure ((*\<^sub>V) (\<alpha> *\<^sub>C A) ` space_as_set S)) =
             \<alpha> *\<^sub>C Abs_clinear_space (closure ((*\<^sub>V) A ` space_as_set S))"
     using \<open>Abs_clinear_space (closure (cblinfun_apply (\<alpha> *\<^sub>C A) ` space_as_set S)) =
             \<alpha> *\<^sub>C Abs_clinear_space (closure (cblinfun_apply A ` space_as_set S))\<close>
     by blast
   show ?thesis
     unfolding cblinfun_image_def using x1 by force
 qed
 
-lemma cblinfun_image_id[simp]: 
+lemma cblinfun_image_id[simp]:
   "id_cblinfun *\<^sub>S \<psi> = \<psi>"
   apply transfer
-  by (simp add: closed_csubspace.closed) 
-
-lemma cblinfun_compose_image: 
+  by (simp add: closed_csubspace.closed)
+
+lemma cblinfun_compose_image:
   \<open>(A o\<^sub>C\<^sub>L B) *\<^sub>S S =  A *\<^sub>S (B *\<^sub>S S)\<close>
   apply transfer unfolding image_comp[symmetric]
   apply (rule closure_bounded_linear_image_subset_eq[symmetric])
   by (simp add: bounded_clinear.bounded_linear)
 
-lemmas cblinfun_assoc_left = cblinfun_compose_assoc[symmetric] cblinfun_compose_image[symmetric] 
+lemmas cblinfun_assoc_left = cblinfun_compose_assoc[symmetric] cblinfun_compose_image[symmetric]
   add.assoc[where ?'a="'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b::chilbert_space", symmetric]
 lemmas cblinfun_assoc_right = cblinfun_compose_assoc cblinfun_compose_image
   add.assoc[where ?'a="'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b::chilbert_space"]
 
 lemma cblinfun_image_INF_leq[simp]:
   fixes U :: "'b::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'c::cbanach"
-    and V :: "'a \<Rightarrow> 'b ccsubspace" 
+    and V :: "'a \<Rightarrow> 'b ccsubspace"
   shows \<open>U *\<^sub>S (INF i. V i) \<le> (INF i. U *\<^sub>S (V i))\<close>
   apply transfer
-  by (simp add: INT_greatest Inter_lower closure_mono image_mono) 
+  by (simp add: INT_greatest Inter_lower closure_mono image_mono)
 
 lemma isometry_cblinfun_image_inf_distrib':
   fixes U::\<open>'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b::cbanach\<close> and B C::"'a ccsubspace"
   shows "U *\<^sub>S (inf B C) \<le> inf (U *\<^sub>S B) (U *\<^sub>S C)"
 proof -
   define V where \<open>V b = (if b then B else C)\<close> for b
   have \<open>U *\<^sub>S (INF i. V i) \<le> (INF i. U *\<^sub>S (V i))\<close>
     by auto
   then show ?thesis
     unfolding V_def
     by (metis (mono_tags, lifting) INF_UNIV_bool_expand)
 qed
 
 lemma cblinfun_image_eq:
-  fixes S :: "'a::cbanach ccsubspace" 
+  fixes S :: "'a::cbanach ccsubspace"
     and A B :: "'a::cbanach \<Rightarrow>\<^sub>C\<^sub>L'b::cbanach"
   assumes "\<And>x. x \<in> G \<Longrightarrow> A *\<^sub>V x = B *\<^sub>V x" and "ccspan G \<ge> S"
   shows "A *\<^sub>S S = B *\<^sub>S S"
 proof (use assms in transfer)
   fix G :: "'a set" and A :: "'a \<Rightarrow> 'b" and B :: "'a \<Rightarrow> 'b" and S :: "'a set"
   assume a1: "bounded_clinear A"
   assume a2: "bounded_clinear B"
   assume a3: "\<And>x. x \<in> G \<Longrightarrow> A x = B x"
   assume a4: "S \<subseteq> closure (cspan G)"
 
   have "A ` closure S = B ` closure S"
     by (smt (verit, best) UnCI a1 a2 a3 a4 bounded_clinear_eq_on closure_Un closure_closure image_cong sup.absorb_iff1)
   then show "closure (A ` S) = closure (B ` S)"
     by (metis Complex_Vector_Spaces0.bounded_clinear.bounded_linear a1 a2 closure_bounded_linear_image_subset_eq)
 qed
 
 lemma cblinfun_fixes_range:
   assumes "A o\<^sub>C\<^sub>L B = B" and "\<psi> \<in> space_as_set (B *\<^sub>S top)"
-  shows "A *\<^sub>V \<psi> = \<psi>" 
+  shows "A *\<^sub>V \<psi> = \<psi>"
 proof-
-  define rangeB rangeB' where "rangeB = space_as_set (B *\<^sub>S top)" 
+  define rangeB rangeB' where "rangeB = space_as_set (B *\<^sub>S top)"
     and "rangeB' = range (cblinfun_apply B)"
   from assms have "\<psi> \<in> closure rangeB'"
     by (simp add: cblinfun_image.rep_eq rangeB'_def top_ccsubspace.rep_eq)
 
   then obtain \<psi>i where \<psi>i_lim: "\<psi>i \<longlonglongrightarrow> \<psi>" and \<psi>i_B: "\<psi>i i \<in> rangeB'" for i
     using closure_sequential by blast
-  have A_invariant: "A *\<^sub>V \<psi>i i = \<psi>i i" 
+  have A_invariant: "A *\<^sub>V \<psi>i i = \<psi>i i"
     for i
   proof-
     from \<psi>i_B obtain \<phi> where \<phi>: "\<psi>i i = B *\<^sub>V \<phi>"
-      using rangeB'_def by blast      
+      using rangeB'_def by blast
     hence "A *\<^sub>V \<psi>i i = (A o\<^sub>C\<^sub>L B) *\<^sub>V \<phi>"
       by (simp add: cblinfun_compose.rep_eq)
     also have "\<dots> = B *\<^sub>V \<phi>"
       by (simp add: assms)
     also have "\<dots> = \<psi>i i"
       by (simp add: \<phi>)
     finally show ?thesis.
   qed
   from \<psi>i_lim have "(\<lambda>i. A *\<^sub>V (\<psi>i i)) \<longlonglongrightarrow> A *\<^sub>V \<psi>"
     by (rule isCont_tendsto_compose[rotated], simp)
   with A_invariant have "(\<lambda>i. \<psi>i i) \<longlonglongrightarrow> A *\<^sub>V \<psi>"
     by auto
   with \<psi>i_lim show "A *\<^sub>V \<psi> = \<psi>"
     using LIMSEQ_unique by blast
 qed
 
 lemma zero_cblinfun_image[simp]: "0 *\<^sub>S S = (0::_ ccsubspace)"
   apply transfer by (simp add: complex_vector.subspace_0 image_constant[where x=0])
 
 lemma cblinfun_image_INF_eq_general:
   fixes V :: "'a \<Rightarrow> 'b::chilbert_space ccsubspace"
     and U :: "'b \<Rightarrow>\<^sub>C\<^sub>L'c::chilbert_space"
-    and Uinv :: "'c \<Rightarrow>\<^sub>C\<^sub>L'b" 
+    and Uinv :: "'c \<Rightarrow>\<^sub>C\<^sub>L'b"
   assumes UinvUUinv: "Uinv o\<^sub>C\<^sub>L U o\<^sub>C\<^sub>L Uinv = Uinv" and UUinvU: "U o\<^sub>C\<^sub>L Uinv o\<^sub>C\<^sub>L U = U"
     \<comment> \<open>Meaning: \<^term>\<open>Uinv\<close> is a Pseudoinverse of \<^term>\<open>U\<close>\<close>
     and V: "\<And>i. V i \<le> Uinv *\<^sub>S top"
   shows "U *\<^sub>S (INF i. V i) = (INF i. U *\<^sub>S V i)"
 proof (rule antisym)
   show "U *\<^sub>S (INF i. V i) \<le> (INF i. U *\<^sub>S V i)"
     by (rule cblinfun_image_INF_leq)
 next
   define rangeU rangeUinv where "rangeU = U *\<^sub>S top" and "rangeUinv = Uinv *\<^sub>S top"
   define INFUV INFV where INFUV_def: "INFUV = (INF i. U *\<^sub>S V i)" and INFV_def: "INFV = (INF i. V i)"
-  from assms have "V i \<le> rangeUinv" 
+  from assms have "V i \<le> rangeUinv"
     for i
     unfolding rangeUinv_def by simp
-  moreover have "(Uinv o\<^sub>C\<^sub>L U) *\<^sub>V \<psi> = \<psi>" if "\<psi> \<in> space_as_set rangeUinv" 
+  moreover have "(Uinv o\<^sub>C\<^sub>L U) *\<^sub>V \<psi> = \<psi>" if "\<psi> \<in> space_as_set rangeUinv"
     for \<psi>
     using UinvUUinv cblinfun_fixes_range rangeUinv_def that by fastforce
-  ultimately have "(Uinv o\<^sub>C\<^sub>L U) *\<^sub>V \<psi> = \<psi>" if "\<psi> \<in> space_as_set (V i)" 
+  ultimately have "(Uinv o\<^sub>C\<^sub>L U) *\<^sub>V \<psi> = \<psi>" if "\<psi> \<in> space_as_set (V i)"
     for \<psi> i
     using less_eq_ccsubspace.rep_eq that by blast
   hence d1: "(Uinv o\<^sub>C\<^sub>L U) *\<^sub>S (V i) = (V i)" for i
   proof transfer
     show "closure ((Uinv \<circ> U) ` V i) = V i"
       if "pred_fun \<top> closed_csubspace V"
         and "bounded_clinear Uinv"
         and "bounded_clinear U"
         and "\<And>\<psi> i. \<psi> \<in> V i \<Longrightarrow> (Uinv \<circ> U) \<psi> = \<psi>"
       for V :: "'a \<Rightarrow> 'b set"
         and Uinv :: "'c \<Rightarrow> 'b"
         and U :: "'b \<Rightarrow> 'c"
         and i :: 'a
       using that proof auto
       show "x \<in> V i"
         if "\<forall>x. closed_csubspace (V x)"
           and "bounded_clinear Uinv"
           and "bounded_clinear U"
           and "\<And>\<psi> i. \<psi> \<in> V i \<Longrightarrow> Uinv (U \<psi>) = \<psi>"
           and "x \<in> closure (V i)"
         for x :: 'b
         using that
-        by (metis orthogonal_complement_of_closure closed_csubspace.subspace double_orthogonal_complement_id closure_is_closed_csubspace) 
+        by (metis orthogonal_complement_of_closure closed_csubspace.subspace double_orthogonal_complement_id closure_is_closed_csubspace)
       show "x \<in> closure (V i)"
         if "\<forall>x. closed_csubspace (V x)"
           and "bounded_clinear Uinv"
           and "bounded_clinear U"
           and "\<And>\<psi> i. \<psi> \<in> V i \<Longrightarrow> Uinv (U \<psi>) = \<psi>"
           and "x \<in> V i"
         for x :: 'b
         using that
         using setdist_eq_0_sing_1 setdist_sing_in_set
-        by blast  
+        by blast
     qed
-  qed     
+  qed
   have "U *\<^sub>S V i \<le> rangeU" for i
     by (simp add: cblinfun_image_mono rangeU_def)
   hence "INFUV \<le> rangeU"
     unfolding INFUV_def by (meson INF_lower UNIV_I order_trans)
   moreover have "(U o\<^sub>C\<^sub>L Uinv) *\<^sub>V \<psi> = \<psi>" if "\<psi> \<in> space_as_set rangeU" for \<psi>
     using UUinvU cblinfun_fixes_range rangeU_def that by fastforce
   ultimately have x: "(U o\<^sub>C\<^sub>L Uinv) *\<^sub>V \<psi> = \<psi>" if "\<psi> \<in> space_as_set INFUV" for \<psi>
     by (simp add: in_mono less_eq_ccsubspace.rep_eq that)
 
   have "closure ((U \<circ> Uinv) ` INFUV) = INFUV"
     if "closed_csubspace INFUV"
       and "bounded_clinear U"
       and "bounded_clinear Uinv"
       and "\<And>\<psi>. \<psi> \<in> INFUV \<Longrightarrow> (U \<circ> Uinv) \<psi> = \<psi>"
     for INFUV :: "'c set"
       and U :: "'b \<Rightarrow> 'c"
       and Uinv :: "'c \<Rightarrow> 'b"
     using that proof auto
     show "x \<in> INFUV"
       if "closed_csubspace INFUV"
         and "bounded_clinear U"
         and "bounded_clinear Uinv"
         and "\<And>\<psi>. \<psi> \<in> INFUV \<Longrightarrow> U (Uinv \<psi>) = \<psi>"
         and "x \<in> closure INFUV"
       for x :: 'c
       using that
-      by (metis orthogonal_complement_of_closure closed_csubspace.subspace double_orthogonal_complement_id closure_is_closed_csubspace) 
+      by (metis orthogonal_complement_of_closure closed_csubspace.subspace double_orthogonal_complement_id closure_is_closed_csubspace)
     show "x \<in> closure INFUV"
       if "closed_csubspace INFUV"
         and "bounded_clinear U"
         and "bounded_clinear Uinv"
         and "\<And>\<psi>. \<psi> \<in> INFUV \<Longrightarrow> U (Uinv \<psi>) = \<psi>"
         and "x \<in> INFUV"
       for x :: 'c
       using that
       using setdist_eq_0_sing_1 setdist_sing_in_set
-      by (simp add: closed_csubspace.closed)  
+      by (simp add: closed_csubspace.closed)
   qed
   hence "(U o\<^sub>C\<^sub>L Uinv) *\<^sub>S INFUV = INFUV"
-    by (metis (mono_tags, hide_lams) x cblinfun_image.rep_eq cblinfun_image_id id_cblinfun_apply image_cong 
+    by (metis (mono_tags, opaque_lifting) x cblinfun_image.rep_eq cblinfun_image_id id_cblinfun_apply image_cong
         space_as_set_inject)
   hence "INFUV = U *\<^sub>S Uinv *\<^sub>S INFUV"
     by (simp add: cblinfun_compose_image)
   also have "\<dots> \<le> U *\<^sub>S (INF i. Uinv *\<^sub>S U *\<^sub>S V i)"
     unfolding INFUV_def
-    by (metis cblinfun_image_mono cblinfun_image_INF_leq)    
+    by (metis cblinfun_image_mono cblinfun_image_INF_leq)
   also have "\<dots> = U *\<^sub>S INFV"
     using d1
     by (metis (no_types, lifting) INFV_def cblinfun_assoc_left(2) image_cong)
   finally show "INFUV \<le> U *\<^sub>S INFV".
 qed
 
-lemma unitary_range[simp]: 
+lemma unitary_range[simp]:
   assumes "unitary U"
   shows "U *\<^sub>S top = top"
   using assms unfolding unitary_def apply transfer
-  by (metis closure_UNIV comp_apply surj_def) 
+  by (metis closure_UNIV comp_apply surj_def)
 
 lemma range_adjoint_isometry:
   assumes "isometry U"
   shows "U* *\<^sub>S top = top"
 proof-
   from assms have "top = U* *\<^sub>S U *\<^sub>S top"
     by (simp add: cblinfun_assoc_left(2))
   also have "\<dots> \<le> U* *\<^sub>S top"
     by (simp add: cblinfun_image_mono)
   finally show ?thesis
     using top.extremum_unique by blast
 qed
 
-lemma cblinfun_image_INF_eq[simp]: 
-  fixes V :: "'a \<Rightarrow> 'b::chilbert_space ccsubspace" 
+lemma cblinfun_image_INF_eq[simp]:
+  fixes V :: "'a \<Rightarrow> 'b::chilbert_space ccsubspace"
     and U :: "'b \<Rightarrow>\<^sub>C\<^sub>L 'c::chilbert_space"
   assumes \<open>isometry U\<close>
   shows "U *\<^sub>S (INF i. V i) = (INF i. U *\<^sub>S V i)"
 proof -
   from \<open>isometry U\<close> have "U* o\<^sub>C\<^sub>L U o\<^sub>C\<^sub>L U* = U*"
     unfolding isometry_def by simp
   moreover from \<open>isometry U\<close> have "U o\<^sub>C\<^sub>L U* o\<^sub>C\<^sub>L U = U"
     unfolding isometry_def
     by (simp add: cblinfun_compose_assoc)
   moreover have "V i \<le> U* *\<^sub>S top" for i
     by (simp add: range_adjoint_isometry assms)
   ultimately show ?thesis
     by (rule cblinfun_image_INF_eq_general)
 qed
 
 lemma isometry_cblinfun_image_inf_distrib[simp]:
   fixes U::\<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b::chilbert_space\<close>
     and X Y::"'a ccsubspace"
   assumes "isometry U"
   shows "U *\<^sub>S (inf X Y) = inf (U *\<^sub>S X) (U *\<^sub>S Y)"
   using cblinfun_image_INF_eq[where V="\<lambda>b. if b then X else Y" and U=U]
   unfolding INF_UNIV_bool_expand
   using assms by auto
 
-lemma cblinfun_image_ccspan: 
+lemma cblinfun_image_ccspan:
   shows "A *\<^sub>S ccspan G = ccspan ((*\<^sub>V) A ` G)"
   apply transfer
   by (simp add: bounded_clinear.bounded_linear bounded_clinear_def closure_bounded_linear_image_subset_eq complex_vector.linear_span_image)
 
 
 lemma cblinfun_apply_in_image[simp]: "A *\<^sub>V \<psi> \<in> space_as_set (A *\<^sub>S \<top>)"
   by (metis cblinfun_image.rep_eq closure_subset in_mono range_eqI top_ccsubspace.rep_eq)
 
 
 lemma cblinfun_plus_image_distr:
   \<open>(A + B) *\<^sub>S S \<le> A *\<^sub>S S \<squnion> B *\<^sub>S S\<close>
   apply transfer
   by (smt (verit, ccfv_threshold) closed_closure closed_sum_def closure_minimal closure_subset image_subset_iff set_plus_intro subset_eq)
 
 lemma cblinfun_sum_image_distr:
   \<open>(\<Sum>i\<in>I. A i) *\<^sub>S S \<le> (SUP i\<in>I. A i *\<^sub>S S)\<close>
 proof (cases \<open>finite I\<close>)
   case True
   then show ?thesis
   proof induction
     case empty
     then show ?case
       by auto
   next
     case (insert x F)
     then show ?case
       apply auto by (smt (z3) cblinfun_plus_image_distr inf_sup_aci(6) le_iff_sup)
   qed
 next
   case False
-  then show ?thesis 
+  then show ?thesis
     by auto
 qed
 
 
 
 subsection \<open>Sandwiches\<close>
 
 
 lift_definition sandwich :: \<open>('a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_inner) \<Rightarrow> (('a \<Rightarrow>\<^sub>C\<^sub>L 'a) \<Rightarrow>\<^sub>C\<^sub>L ('b \<Rightarrow>\<^sub>C\<^sub>L 'b))\<close> is
   \<open>\<lambda>(A::'a\<Rightarrow>\<^sub>C\<^sub>L'b) B. A o\<^sub>C\<^sub>L B o\<^sub>C\<^sub>L A*\<close>
-proof 
+proof
   fix A :: \<open>'a \<Rightarrow>\<^sub>C\<^sub>L 'b\<close> and B B1 B2 :: \<open>'a \<Rightarrow>\<^sub>C\<^sub>L 'a\<close> and c :: complex
   show \<open>A o\<^sub>C\<^sub>L (B1 + B2) o\<^sub>C\<^sub>L A* = (A o\<^sub>C\<^sub>L B1 o\<^sub>C\<^sub>L A*) + (A o\<^sub>C\<^sub>L B2 o\<^sub>C\<^sub>L A*)\<close>
     by (simp add: cblinfun_compose_add_left cblinfun_compose_add_right)
   show \<open>A o\<^sub>C\<^sub>L (c *\<^sub>C B) o\<^sub>C\<^sub>L A* = c *\<^sub>C (A o\<^sub>C\<^sub>L B o\<^sub>C\<^sub>L A*)\<close>
     by auto
   show \<open>\<exists>K. \<forall>B. norm (A o\<^sub>C\<^sub>L B o\<^sub>C\<^sub>L A*) \<le> norm B * K\<close>
   proof (rule exI[of _ \<open>norm A * norm (A*)\<close>], rule allI)
     fix B
     have \<open>norm (A o\<^sub>C\<^sub>L B o\<^sub>C\<^sub>L A*) \<le> norm (A o\<^sub>C\<^sub>L B) * norm (A*)\<close>
       using norm_cblinfun_compose by blast
     also have \<open>\<dots> \<le> (norm A * norm B) * norm (A*)\<close>
       by (simp add: mult_right_mono norm_cblinfun_compose)
     finally show \<open>norm (A o\<^sub>C\<^sub>L B o\<^sub>C\<^sub>L A*) \<le> norm B * (norm A * norm (A*))\<close>
       by (simp add: mult.assoc vector_space_over_itself.scale_left_commute)
   qed
 qed
 
 lemma sandwich_0[simp]: \<open>sandwich 0 = 0\<close>
   by (simp add: cblinfun_eqI sandwich.rep_eq)
 
 lemma sandwich_apply: \<open>sandwich A *\<^sub>V B = A o\<^sub>C\<^sub>L B o\<^sub>C\<^sub>L A*\<close>
   apply (transfer fixing: A B) by auto
 
 
 lemma norm_sandwich: \<open>norm (sandwich A) = (norm A)\<^sup>2\<close> for A :: \<open>'a::{chilbert_space} \<Rightarrow>\<^sub>C\<^sub>L 'b::{complex_inner}\<close>
 proof -
   have main: \<open>norm (sandwich A) = (norm A)\<^sup>2\<close> for A :: \<open>'c::{chilbert_space,not_singleton} \<Rightarrow>\<^sub>C\<^sub>L 'd::{complex_inner}\<close>
   proof (rule norm_cblinfun_eqI)
     show \<open>(norm A)\<^sup>2 \<le> norm (sandwich A *\<^sub>V id_cblinfun) / norm (id_cblinfun :: 'c \<Rightarrow>\<^sub>C\<^sub>L _)\<close>
       apply (auto simp: sandwich_apply)
       by -
     fix B
     have \<open>norm (sandwich A *\<^sub>V B) \<le> norm (A o\<^sub>C\<^sub>L B) * norm (A*)\<close>
       using norm_cblinfun_compose by (auto simp: sandwich_apply simp del: norm_adj)
     also have \<open>\<dots> \<le> (norm A * norm B) * norm (A*)\<close>
       by (simp add: mult_right_mono norm_cblinfun_compose)
     also have \<open>\<dots> \<le> (norm A)\<^sup>2 * norm B\<close>
       by (simp add: power2_eq_square mult.assoc vector_space_over_itself.scale_left_commute)
     finally show \<open>norm (sandwich A *\<^sub>V B) \<le> (norm A)\<^sup>2 * norm B\<close>
       by -
     show \<open>0 \<le> (norm A)\<^sup>2\<close>
       by auto
   qed
 
   show ?thesis
   proof (cases \<open>class.not_singleton TYPE('a)\<close>)
     case True
     show ?thesis
       apply (rule main[internalize_sort' 'c2])
        apply standard[1]
       using True by simp
   next
     case False
     have \<open>A = 0\<close>
       apply (rule cblinfun_from_CARD_1_0[internalize_sort' 'a])
        apply (rule not_singleton_vs_CARD_1)
        apply (rule False)
       by standard
     then show ?thesis
       by simp
   qed
 qed
 
 lemma sandwich_apply_adj: \<open>sandwich A (B*) = (sandwich A B)*\<close>
   by (simp add: cblinfun_assoc_left(1) sandwich_apply)
 
 lemma sandwich_id[simp]: "sandwich id_cblinfun = id_cblinfun"
   apply (rule cblinfun_eqI)
   by (auto simp: sandwich_apply)
 
 
 subsection \<open>Projectors\<close>
 
 lift_definition Proj :: "('a::chilbert_space) ccsubspace \<Rightarrow> 'a \<Rightarrow>\<^sub>C\<^sub>L'a"
   is \<open>projection\<close>
   by (rule projection_bounded_clinear)
 
-lemma Proj_range[simp]: "Proj S *\<^sub>S top = S"  
+lemma Proj_range[simp]: "Proj S *\<^sub>S top = S"
 proof transfer
   fix S :: \<open>'a set\<close> assume \<open>closed_csubspace S\<close>
   then have "closure (range (projection S)) \<subseteq> S"
     by (metis closed_csubspace.closed closed_csubspace.subspace closure_closed complex_vector.subspace_0 csubspace_is_convex dual_order.eq_iff insert_absorb insert_not_empty projection_image)
   moreover have "S \<subseteq> closure (range (projection S))"
     using \<open>closed_csubspace S\<close>
     by (metis closed_csubspace_def closure_subset csubspace_is_convex equals0D projection_image subset_iff)
-  ultimately show \<open>closure (range (projection S)) = S\<close> 
+  ultimately show \<open>closure (range (projection S)) = S\<close>
     by auto
 qed
 
 lemma adj_Proj: \<open>(Proj M)* = Proj M\<close>
   apply transfer by (simp add: projection_cadjoint)
 
 lemma Proj_idempotent[simp]: \<open>Proj M o\<^sub>C\<^sub>L Proj M = Proj M\<close>
 proof -
   have u1: \<open>(cblinfun_apply (Proj M)) = projection (space_as_set M)\<close>
     apply transfer
     by blast
   have \<open>closed_csubspace (space_as_set M)\<close>
     using space_as_set by auto
   hence u2: \<open>(projection (space_as_set M))\<circ>(projection (space_as_set M))
-                = (projection (space_as_set M))\<close>    
+                = (projection (space_as_set M))\<close>
     using projection_idem by fastforce
   have \<open>(cblinfun_apply (Proj M)) \<circ> (cblinfun_apply (Proj M)) = cblinfun_apply (Proj M)\<close>
     using u1 u2
-    by simp    
+    by simp
   hence \<open>cblinfun_apply ((Proj M) o\<^sub>C\<^sub>L (Proj M)) = cblinfun_apply (Proj M)\<close>
     by (simp add: cblinfun_compose.rep_eq)
   thus ?thesis using cblinfun_apply_inject
-    by auto 
+    by auto
 qed
 
 lift_definition is_Proj::\<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'a \<Rightarrow> bool\<close> is
   \<open>\<lambda>P. \<exists>M. closed_csubspace M \<and> is_projection_on P M\<close> .
 
 lemma Proj_on_own_range':
   fixes P :: \<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L'a\<close>
   assumes \<open>P o\<^sub>C\<^sub>L P = P\<close> and \<open>P = P*\<close>
   shows \<open>Proj (P *\<^sub>S top) = P\<close>
 proof-
   define M where "M = P *\<^sub>S top"
   have v3: "x \<in> (\<lambda>x. x - P *\<^sub>V x) -` {0}"
     if "x \<in> range (cblinfun_apply P)"
     for x :: 'a
   proof-
     have v3_1: \<open>cblinfun_apply P \<circ> cblinfun_apply P = cblinfun_apply P\<close>
       by (metis \<open>P o\<^sub>C\<^sub>L P = P\<close> cblinfun_compose.rep_eq)
     have \<open>\<exists>t. P *\<^sub>V t = x\<close>
       using that by blast
     then obtain t where t_def: \<open>P *\<^sub>V t = x\<close>
-      by blast 
+      by blast
     hence \<open>x - P *\<^sub>V x = x - P *\<^sub>V (P *\<^sub>V t)\<close>
       by simp
     also have \<open>\<dots> = x - (P *\<^sub>V t)\<close>
-      using v3_1      
-      by (metis comp_apply) 
+      using v3_1
+      by (metis comp_apply)
     also have \<open>\<dots> = 0\<close>
       by (simp add: t_def)
     finally have \<open>x - P *\<^sub>V x = 0\<close>
       by blast
     thus ?thesis
-      by simp 
+      by simp
   qed
 
   have v1: "range (cblinfun_apply P) \<subseteq> (\<lambda>x. x - cblinfun_apply P x) -` {0}"
     using v3
     by blast
 
   have "x \<in> range (cblinfun_apply P)"
     if "x \<in> (\<lambda>x. x - P *\<^sub>V x) -` {0}"
     for x :: 'a
   proof-
     have x1:\<open>x - P *\<^sub>V x = 0\<close>
       using that by blast
     have \<open>x = P *\<^sub>V x\<close>
       by (simp add: x1 eq_iff_diff_eq_0)
     thus ?thesis
-      by blast 
+      by blast
   qed
   hence v2: "(\<lambda>x. x - cblinfun_apply P x) -` {0} \<subseteq> range (cblinfun_apply P)"
     by blast
   have i1: \<open>range (cblinfun_apply P) = (\<lambda> x. x - cblinfun_apply P x) -` {0}\<close>
     using v1 v2
-    by (simp add: v1 dual_order.antisym) 
+    by (simp add: v1 dual_order.antisym)
   have p1: \<open>closed {(0::'a)}\<close>
-    by simp        
+    by simp
   have p2: \<open>continuous (at x) (\<lambda> x. x - P *\<^sub>V x)\<close>
     for x
   proof-
     have \<open>cblinfun_apply (id_cblinfun - P) = (\<lambda> x. x - P *\<^sub>V x)\<close>
-      by (simp add: id_cblinfun.rep_eq minus_cblinfun.rep_eq)                 
+      by (simp add: id_cblinfun.rep_eq minus_cblinfun.rep_eq)
     hence \<open>bounded_clinear (cblinfun_apply (id_cblinfun - P))\<close>
       using cblinfun_apply
-      by blast 
+      by blast
     hence \<open>continuous (at x) (cblinfun_apply (id_cblinfun - P))\<close>
       by (simp add: clinear_continuous_at)
     thus ?thesis
       using \<open>cblinfun_apply (id_cblinfun - P) = (\<lambda> x. x - P *\<^sub>V x)\<close>
       by simp
   qed
 
   have i2: \<open>closed ( (\<lambda> x. x - P *\<^sub>V x) -` {0} )\<close>
     using p1 p2
     by (rule Abstract_Topology.continuous_closed_vimage)
 
   have \<open>closed (range (cblinfun_apply P))\<close>
     using i1 i2
     by simp
   have u2: \<open>cblinfun_apply P x \<in> space_as_set M\<close>
     for x
     by (simp add: M_def \<open>closed (range ((*\<^sub>V) P))\<close> cblinfun_image.rep_eq top_ccsubspace.rep_eq)
 
   have xy: \<open>\<langle> x - P *\<^sub>V x, y \<rangle> = 0\<close>
     if y1: \<open>y \<in> space_as_set M\<close>
     for x y
   proof-
     have \<open>\<exists>t. y = P *\<^sub>V t\<close>
       using y1
-      by (simp add:  M_def \<open>closed (range ((*\<^sub>V) P))\<close> cblinfun_image.rep_eq image_iff 
+      by (simp add:  M_def \<open>closed (range ((*\<^sub>V) P))\<close> cblinfun_image.rep_eq image_iff
           top_ccsubspace.rep_eq)
     then obtain t where t_def: \<open>y = P *\<^sub>V t\<close>
       by blast
     have \<open>\<langle> x - P *\<^sub>V x, y \<rangle> = \<langle> x - P *\<^sub>V x, P *\<^sub>V t \<rangle>\<close>
       by (simp add: t_def)
     also have \<open>\<dots> = \<langle> P *\<^sub>V (x - P *\<^sub>V x), t \<rangle>\<close>
       by (metis \<open>P = P*\<close> cinner_adj_left)
     also have \<open>\<dots> = \<langle> P *\<^sub>V x - P *\<^sub>V (P *\<^sub>V x), t \<rangle>\<close>
       by (simp add: cblinfun.diff_right)
     also have \<open>\<dots> = \<langle> P *\<^sub>V x - P *\<^sub>V x, t \<rangle>\<close>
-      by (metis assms(1) comp_apply cblinfun_compose.rep_eq)    
+      by (metis assms(1) comp_apply cblinfun_compose.rep_eq)
     also have \<open>\<dots> = \<langle> 0, t \<rangle>\<close>
       by simp
     also have \<open>\<dots> = 0\<close>
       by simp
     finally show ?thesis by blast
   qed
-  hence u1: \<open>x - P *\<^sub>V x \<in> orthogonal_complement (space_as_set M)\<close> 
+  hence u1: \<open>x - P *\<^sub>V x \<in> orthogonal_complement (space_as_set M)\<close>
     for x
-    by (simp add: orthogonal_complementI) 
+    by (simp add: orthogonal_complementI)
   have "closed_csubspace (space_as_set M)"
     using space_as_set by auto
   hence f1: "(Proj M) *\<^sub>V a = P *\<^sub>V a" for a
     by (simp add: Proj.rep_eq projection_eqI u1 u2)
   have "(+) ((P - Proj M) *\<^sub>V a) = id" for a
     using f1
-    by (auto intro!: ext simp add: minus_cblinfun.rep_eq) 
+    by (auto intro!: ext simp add: minus_cblinfun.rep_eq)
   hence "b - b = cblinfun_apply (P - Proj M) a"
     for a b
     by (metis (no_types) add_diff_cancel_right' id_apply)
   hence "cblinfun_apply (id_cblinfun - (P - Proj M)) a = a"
     for a
-    by (simp add: id_cblinfun.rep_eq minus_cblinfun.rep_eq)      
+    by (simp add: minus_cblinfun.rep_eq)
   thus ?thesis
     using u1 u2 cblinfun_apply_inject diff_diff_eq2 diff_eq_diff_eq eq_id_iff id_cblinfun.rep_eq
-    by (metis (no_types, hide_lams) M_def)
+    by (metis (no_types, opaque_lifting) M_def)
 qed
 
 lemma Proj_range_closed:
   assumes "is_Proj P"
   shows "closed (range (cblinfun_apply P))"
-  using assms apply transfer      
+  using assms apply transfer
   using closed_csubspace.closed is_projection_on_image by blast
 
 lemma Proj_is_Proj[simp]:
   fixes M::\<open>'a::chilbert_space ccsubspace\<close>
   shows \<open>is_Proj (Proj M)\<close>
 proof-
   have u1: "closed_csubspace (space_as_set M)"
     using space_as_set by blast
   have v1: "h - Proj M *\<^sub>V h
          \<in> orthogonal_complement (space_as_set M)" for h
     by (simp add: Proj.rep_eq orthogonal_complementI projection_orthogonal u1)
   have v2: "Proj M *\<^sub>V h \<in> space_as_set M" for h
     by (metis Proj.rep_eq mem_Collect_eq orthog_proj_exists projection_eqI space_as_set)
   have u2: "is_projection_on ((*\<^sub>V) (Proj M)) (space_as_set M)"
     unfolding is_projection_on_def
     by (simp add: smallest_dist_is_ortho u1 v1 v2)
   show ?thesis
-    using u1 u2 is_Proj.rep_eq by blast 
+    using u1 u2 is_Proj.rep_eq by blast
 qed
 
-lemma is_Proj_algebraic: 
+lemma is_Proj_algebraic:
   fixes P::\<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'a\<close>
   shows \<open>is_Proj P \<longleftrightarrow> P o\<^sub>C\<^sub>L P = P \<and> P = P*\<close>
 proof
   have "P o\<^sub>C\<^sub>L P = P"
     if "is_Proj P"
     using that apply transfer
     using is_projection_on_idem
     by fastforce
   moreover have "P = P*"
     if "is_Proj P"
     using that apply transfer
     by (metis is_projection_on_cadjoint)
   ultimately show "P o\<^sub>C\<^sub>L P = P \<and> P = P*"
     if "is_Proj P"
     using that
     by blast
   show "is_Proj P"
     if "P o\<^sub>C\<^sub>L P = P \<and> P = P*"
     using that Proj_on_own_range' Proj_is_Proj by metis
 qed
 
 lemma Proj_on_own_range:
   fixes P :: \<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L'a\<close>
   assumes \<open>is_Proj P\<close>
   shows \<open>Proj (P *\<^sub>S top) = P\<close>
   using Proj_on_own_range' assms is_Proj_algebraic by blast
 
 lemma Proj_image_leq: "(Proj S) *\<^sub>S A \<le> S"
   by (metis Proj_range inf_top_left le_inf_iff isometry_cblinfun_image_inf_distrib')
 
 lemma Proj_sandwich:
   fixes A::"'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b::chilbert_space"
   assumes "isometry A"
-  shows "sandwich A *\<^sub>V Proj S = Proj (A *\<^sub>S S)" 
+  shows "sandwich A *\<^sub>V Proj S = Proj (A *\<^sub>S S)"
 proof-
   define P where \<open>P = A o\<^sub>C\<^sub>L Proj S o\<^sub>C\<^sub>L (A*)\<close>
   have \<open>P o\<^sub>C\<^sub>L P = P\<close>
     using assms
     unfolding P_def isometry_def
     by (metis (no_types, lifting) Proj_idempotent cblinfun_assoc_left(1) cblinfun_compose_id_left)
   moreover have \<open>P = P*\<close>
-    unfolding P_def  
+    unfolding P_def
     by (metis adj_Proj adj_cblinfun_compose cblinfun_assoc_left(1) double_adj)
-  ultimately have 
+  ultimately have
     \<open>\<exists>M. P = Proj M \<and> space_as_set M = range (cblinfun_apply (A o\<^sub>C\<^sub>L (Proj S) o\<^sub>C\<^sub>L (A*)))\<close>
     using P_def Proj_on_own_range'
     by (metis Proj_is_Proj Proj_range_closed cblinfun_image.rep_eq closure_closed top_ccsubspace.rep_eq)
   then obtain M where \<open>P = Proj M\<close>
     and \<open>space_as_set M = range (cblinfun_apply (A o\<^sub>C\<^sub>L (Proj S) o\<^sub>C\<^sub>L (A*)))\<close>
     by blast
 
-  have f1: "A o\<^sub>C\<^sub>L Proj S = P o\<^sub>C\<^sub>L A"  
+  have f1: "A o\<^sub>C\<^sub>L Proj S = P o\<^sub>C\<^sub>L A"
     by (simp add: P_def assms cblinfun_compose_assoc)
   hence "P o\<^sub>C\<^sub>L A o\<^sub>C\<^sub>L A* = P"
     using P_def by presburger
   hence "(P o\<^sub>C\<^sub>L A) *\<^sub>S (c \<squnion> A* *\<^sub>S d) = P *\<^sub>S (A *\<^sub>S c \<squnion> d)"
     for c d
 
     by (simp add: cblinfun_assoc_left(2))
   hence "P *\<^sub>S (A *\<^sub>S \<top> \<squnion> c) = (P o\<^sub>C\<^sub>L A) *\<^sub>S \<top>"
     for c
     by (metis sup_top_left)
   hence \<open>M = A *\<^sub>S S\<close>
     using f1
     by (metis \<open>P = Proj M\<close> cblinfun_assoc_left(2) Proj_range sup_top_right)
   thus ?thesis
     using \<open>P = Proj M\<close>
     unfolding P_def sandwich_apply by blast
 qed
 
 lemma Proj_orthog_ccspan_union:
   assumes "\<And>x y. x \<in> X \<Longrightarrow> y \<in> Y \<Longrightarrow> is_orthogonal x y"
   shows \<open>Proj (ccspan (X \<union> Y)) = Proj (ccspan X) + Proj (ccspan Y)\<close>
 proof -
   have \<open>x \<in> cspan X \<Longrightarrow> y \<in> cspan Y \<Longrightarrow> is_orthogonal x y\<close> for x y
     apply (rule is_orthogonal_closure_cspan[where X=X and Y=Y])
     using closure_subset assms by auto
   then have \<open>x \<in> closure (cspan X) \<Longrightarrow> y \<in> closure (cspan Y) \<Longrightarrow> is_orthogonal x y\<close> for x y
     by (metis orthogonal_complementI orthogonal_complement_of_closure orthogonal_complement_orthoI')
   then show ?thesis
     apply (transfer fixing: X Y)
     apply (subst projection_plus[symmetric])
     by auto
 qed
 
 abbreviation proj :: "'a::chilbert_space \<Rightarrow> 'a \<Rightarrow>\<^sub>C\<^sub>L 'a" where "proj \<psi> \<equiv> Proj (ccspan {\<psi>})"
 
 lemma proj_0[simp]: \<open>proj 0 = 0\<close>
   apply transfer by auto
 
 lemma surj_isometry_is_unitary:
   fixes U :: \<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L 'b::chilbert_space\<close>
   assumes \<open>isometry U\<close>
   assumes \<open>U *\<^sub>S \<top> = \<top>\<close>
   shows \<open>unitary U\<close>
   by (metis Proj_sandwich sandwich_apply Proj_on_own_range' assms(1) assms(2) cblinfun_compose_id_right isometry_def unitary_def unitary_id unitary_range)
 
 lemma ccsubspace_supI_via_Proj:
   fixes A B C::"'a::chilbert_space ccsubspace"
   assumes a1: \<open>Proj (- C) *\<^sub>S A \<le> B\<close>
   shows  "A \<le> sup B C"
 proof-
   have x2: \<open>x \<in> space_as_set B\<close>
     if "x \<in>  closure ( (projection (orthogonal_complement (space_as_set C))) ` space_as_set A)" for x
     using that
-    by (metis Proj.rep_eq cblinfun_image.rep_eq assms less_eq_ccsubspace.rep_eq subsetD 
+    by (metis Proj.rep_eq cblinfun_image.rep_eq assms less_eq_ccsubspace.rep_eq subsetD
         uminus_ccsubspace.rep_eq)
   have q1: \<open>x \<in> closure {\<psi> + \<phi> |\<psi> \<phi>. \<psi> \<in> space_as_set B \<and> \<phi> \<in> space_as_set C}\<close>
     if \<open>x \<in> space_as_set A\<close>
     for x
   proof-
     have p1: \<open>closed_csubspace (space_as_set C)\<close>
       using space_as_set by auto
     hence \<open>x = (projection (space_as_set C)) x
        + (projection (orthogonal_complement (space_as_set C))) x\<close>
       by simp
     hence \<open>x = (projection (orthogonal_complement (space_as_set C))) x
               + (projection (space_as_set C)) x\<close>
       by (metis ordered_field_class.sign_simps(2))
     moreover have \<open>(projection (orthogonal_complement (space_as_set C))) x \<in> space_as_set B\<close>
       using x2
       by (meson closure_subset image_subset_iff that)
     moreover have \<open>(projection (space_as_set C)) x \<in> space_as_set C\<close>
       by (metis mem_Collect_eq orthog_proj_exists projection_eqI space_as_set)
     ultimately show ?thesis
-      using closure_subset by fastforce 
+      using closure_subset by fastforce
   qed
   have x1: \<open>x \<in> (space_as_set B +\<^sub>M space_as_set C)\<close>
     if "x \<in> space_as_set A" for x
   proof -
     have f1: "x \<in> closure {a + b |a b. a \<in> space_as_set B \<and> b \<in> space_as_set C}"
       by (simp add: q1 that)
-    have "{a + b |a b. a \<in> space_as_set B \<and> b \<in> space_as_set C} = {a. \<exists>p. p \<in> space_as_set B 
+    have "{a + b |a b. a \<in> space_as_set B \<and> b \<in> space_as_set C} = {a. \<exists>p. p \<in> space_as_set B
       \<and> (\<exists>q. q \<in> space_as_set C \<and> a = p + q)}"
       by blast
     hence "x \<in> closure {a. \<exists>b\<in>space_as_set B. \<exists>c\<in>space_as_set C. a = b + c}"
       using f1 by (simp add: Bex_def_raw)
     thus ?thesis
       using that
       unfolding closed_sum_def set_plus_def
       by blast
   qed
 
   hence \<open>x \<in> space_as_set (Abs_clinear_space (space_as_set B +\<^sub>M space_as_set C))\<close>
     if "x \<in> space_as_set A" for x
     using that
     by (metis space_as_set_inverse sup_ccsubspace.rep_eq)
-  thus ?thesis 
+  thus ?thesis
     by (simp add: x1 less_eq_ccsubspace.rep_eq subset_eq sup_ccsubspace.rep_eq)
 qed
 
 lemma is_Proj_idempotent:
   assumes "is_Proj P"
   shows "P o\<^sub>C\<^sub>L P = P"
   using assms
   unfolding is_Proj_def
   using assms is_Proj_algebraic by auto
 
 lemma is_proj_selfadj:
   assumes "is_Proj P"
   shows "P* = P"
   using assms
   unfolding is_Proj_def
-  by (metis is_Proj_algebraic is_Proj_def) 
-
-lemma is_Proj_I: 
+  by (metis is_Proj_algebraic is_Proj_def)
+
+lemma is_Proj_I:
   assumes "P o\<^sub>C\<^sub>L P = P" and "P* = P"
   shows "is_Proj P"
   using assms is_Proj_algebraic by metis
 
 lemma is_Proj_0[simp]: "is_Proj 0"
   by (metis add_left_cancel adj_plus bounded_cbilinear.zero_left bounded_cbilinear_cblinfun_compose group_cancel.rule0 is_Proj_I)
 
-lemma is_Proj_complement[simp]: 
+lemma is_Proj_complement[simp]:
   assumes a1: "is_Proj P"
   shows "is_Proj (id_cblinfun-P)"
   by (smt (z3) add_diff_cancel_left add_diff_cancel_left' adj_cblinfun_compose adj_plus assms bounded_cbilinear.add_left bounded_cbilinear_cblinfun_compose diff_add_cancel id_cblinfun_adjoint is_Proj_algebraic cblinfun_compose_id_left)
 
 lemma Proj_bot[simp]: "Proj bot = 0"
-  by (metis zero_cblinfun_image Proj_on_own_range' is_Proj_0 is_Proj_algebraic 
+  by (metis zero_cblinfun_image Proj_on_own_range' is_Proj_0 is_Proj_algebraic
       zero_ccsubspace_def)
 
 lemma Proj_ortho_compl:
   "Proj (- X) = id_cblinfun - Proj X"
   by (transfer , auto)
 
-lemma Proj_inj: 
+lemma Proj_inj:
   assumes "Proj X = Proj Y"
   shows "X = Y"
   by (metis assms Proj_range)
 
 subsection \<open>Kernel\<close>
 
 lift_definition kernel :: "'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L'b::complex_normed_vector
-   \<Rightarrow> 'a ccsubspace" 
+   \<Rightarrow> 'a ccsubspace"
   is "\<lambda> f. f -` {0}"
   by (metis kernel_is_closed_csubspace)
 
 definition eigenspace :: "complex \<Rightarrow> 'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L'a \<Rightarrow> 'a ccsubspace" where
-  "eigenspace a A = kernel (A - a *\<^sub>C id_cblinfun)" 
+  "eigenspace a A = kernel (A - a *\<^sub>C id_cblinfun)"
 
 lemma kernel_scaleC[simp]: "a\<noteq>0 \<Longrightarrow> kernel (a *\<^sub>C A) = kernel A"
   for a :: complex and A :: "(_,_) cblinfun"
   apply transfer
   using complex_vector.scale_eq_0_iff by blast
 
 lemma kernel_0[simp]: "kernel 0 = top"
   apply transfer by auto
 
 lemma kernel_id[simp]: "kernel id_cblinfun = 0"
   apply transfer by simp
 
-lemma eigenspace_scaleC[simp]: 
+lemma eigenspace_scaleC[simp]:
   assumes a1: "a \<noteq> 0"
   shows "eigenspace b (a *\<^sub>C A) = eigenspace (b/a) A"
 proof -
   have "b *\<^sub>C (id_cblinfun::('a, _) cblinfun) = a *\<^sub>C (b / a) *\<^sub>C id_cblinfun"
     using a1
     by (metis ceq_vector_fraction_iff)
   hence "kernel (a *\<^sub>C A - b *\<^sub>C id_cblinfun) = kernel (A - (b / a) *\<^sub>C id_cblinfun)"
     using a1 by (metis (no_types) complex_vector.scale_right_diff_distrib kernel_scaleC)
-  thus ?thesis 
-    unfolding eigenspace_def 
+  thus ?thesis
+    unfolding eigenspace_def
     by blast
 qed
 
 lemma eigenspace_memberD:
   assumes "x \<in> space_as_set (eigenspace e A)"
   shows "A *\<^sub>V x = e *\<^sub>C x"
   using assms unfolding eigenspace_def apply transfer by auto
 
 lemma kernel_memberD:
   assumes "x \<in> space_as_set (kernel A)"
   shows "A *\<^sub>V x = 0"
   using assms apply transfer by auto
 
 lemma eigenspace_memberI:
   assumes "A *\<^sub>V x = e *\<^sub>C x"
   shows "x \<in> space_as_set (eigenspace e A)"
   using assms unfolding eigenspace_def apply transfer by auto
 
 lemma kernel_memberI:
   assumes "A *\<^sub>V x = 0"
   shows "x \<in> space_as_set (kernel A)"
   using assms apply transfer by auto
 
 subsection \<open>Isomorphisms and inverses\<close>
 
 definition iso_cblinfun :: \<open>('a::complex_normed_vector, 'b::complex_normed_vector) cblinfun \<Rightarrow> bool\<close> where
   \<open>iso_cblinfun A = (\<exists> B. A o\<^sub>C\<^sub>L B = id_cblinfun \<and> B o\<^sub>C\<^sub>L A = id_cblinfun)\<close>
 
 definition cblinfun_inv :: \<open>('a::complex_normed_vector, 'b::complex_normed_vector) cblinfun \<Rightarrow> ('b,'a) cblinfun\<close> where
   \<open>cblinfun_inv A = (SOME B. B o\<^sub>C\<^sub>L A = id_cblinfun)\<close>
 
-lemma 
+lemma
   assumes \<open>iso_cblinfun A\<close>
   shows cblinfun_inv_left: \<open>cblinfun_inv A o\<^sub>C\<^sub>L A = id_cblinfun\<close>
     and cblinfun_inv_right: \<open>A o\<^sub>C\<^sub>L cblinfun_inv A = id_cblinfun\<close>
 proof -
   from assms
   obtain B where AB: \<open>A o\<^sub>C\<^sub>L B = id_cblinfun\<close> and BA: \<open>B o\<^sub>C\<^sub>L A = id_cblinfun\<close>
     using iso_cblinfun_def by blast
   from BA have \<open>cblinfun_inv A o\<^sub>C\<^sub>L A = id_cblinfun\<close>
     by (metis (mono_tags, lifting) cblinfun_inv_def someI_ex)
   with AB BA have \<open>cblinfun_inv A = B\<close>
     by (metis cblinfun_assoc_left(1) cblinfun_compose_id_right)
   with AB BA show \<open>cblinfun_inv A o\<^sub>C\<^sub>L A = id_cblinfun\<close>
     and \<open>A o\<^sub>C\<^sub>L cblinfun_inv A = id_cblinfun\<close>
     by auto
 qed
 
 
 lemma cblinfun_inv_uniq:
   assumes "A o\<^sub>C\<^sub>L B = id_cblinfun" and "B o\<^sub>C\<^sub>L A = id_cblinfun"
   shows "cblinfun_inv A = B"
   using assms by (metis cblinfun_compose_assoc cblinfun_compose_id_right cblinfun_inv_left iso_cblinfun_def)
 
 subsection \<open>One-dimensional spaces\<close>
 
 
 instantiation cblinfun :: (one_dim, one_dim) complex_inner begin
 text \<open>Once we have a theory for the trace, we could instead define the Hilbert-Schmidt inner product
   and relax the \<^class>\<open>one_dim\<close>-sort constraint to (\<^class>\<open>cfinite_dim\<close>,\<^class>\<open>complex_normed_vector\<close>) or similar\<close>
 definition "cinner_cblinfun (A::'a \<Rightarrow>\<^sub>C\<^sub>L 'b) (B::'a \<Rightarrow>\<^sub>C\<^sub>L 'b)
              = cnj (one_dim_iso (A *\<^sub>V 1)) * one_dim_iso (B *\<^sub>V 1)"
 instance
 proof intro_classes
   fix A B C :: "'a \<Rightarrow>\<^sub>C\<^sub>L 'b"
     and c c' :: complex
   show "\<langle>A, B\<rangle> = cnj \<langle>B, A\<rangle>"
     unfolding cinner_cblinfun_def by auto
   show "\<langle>A + B, C\<rangle> = \<langle>A, C\<rangle> + \<langle>B, C\<rangle>"
-    by (simp add: cinner_cblinfun_def algebra_simps plus_cblinfun.rep_eq) 
+    by (simp add: cinner_cblinfun_def algebra_simps plus_cblinfun.rep_eq)
   show "\<langle>c *\<^sub>C A, B\<rangle> = cnj c * \<langle>A, B\<rangle>"
     by (simp add: cblinfun.scaleC_left cinner_cblinfun_def)
   show "0 \<le> \<langle>A, A\<rangle>"
     unfolding cinner_cblinfun_def by auto
   have "bounded_clinear A \<Longrightarrow> A 1 = 0 \<Longrightarrow> A = (\<lambda>_. 0)"
     for A::"'a \<Rightarrow> 'b"
   proof (rule one_dim_clinear_eqI [where x = 1] , auto)
     show "clinear A"
       if "bounded_clinear A"
         and "A 1 = 0"
       for A :: "'a \<Rightarrow> 'b"
       using that
       by (simp add: bounded_clinear.clinear)
     show "clinear ((\<lambda>_. 0)::'a \<Rightarrow> 'b)"
       if "bounded_clinear A"
         and "A 1 = 0"
       for A :: "'a \<Rightarrow> 'b"
       using that
-      by (simp add: complex_vector.module_hom_zero) 
+      by (simp add: complex_vector.module_hom_zero)
   qed
   hence "A *\<^sub>V 1 = 0 \<Longrightarrow> A = 0"
     by transfer
   hence "one_dim_iso (A *\<^sub>V 1) = 0 \<Longrightarrow> A = 0"
-    by (metis one_dim_iso_of_zero one_dim_iso_inj)    
+    by (metis one_dim_iso_of_zero one_dim_iso_inj)
   thus "(\<langle>A, A\<rangle> = 0) = (A = 0)"
     by (auto simp: cinner_cblinfun_def)
 
   show "norm A = sqrt (cmod \<langle>A, A\<rangle>)"
-    unfolding cinner_cblinfun_def 
-    apply transfer 
+    unfolding cinner_cblinfun_def
+    apply transfer
     by (simp add: norm_mult abs_complex_def one_dim_onorm' cnj_x_x power2_eq_square bounded_clinear.clinear)
 qed
 end
 
 instantiation cblinfun :: (one_dim, one_dim) one_dim begin
 lift_definition one_cblinfun :: "'a \<Rightarrow>\<^sub>C\<^sub>L 'b" is "one_dim_iso"
   by (rule bounded_clinear_one_dim_iso)
 lift_definition times_cblinfun :: "'a \<Rightarrow>\<^sub>C\<^sub>L 'b \<Rightarrow> 'a \<Rightarrow>\<^sub>C\<^sub>L 'b \<Rightarrow> 'a \<Rightarrow>\<^sub>C\<^sub>L 'b"
   is "\<lambda>f g. f o one_dim_iso o g"
   by (simp add: comp_bounded_clinear)
 lift_definition inverse_cblinfun :: "'a \<Rightarrow>\<^sub>C\<^sub>L 'b \<Rightarrow> 'a \<Rightarrow>\<^sub>C\<^sub>L 'b" is
   "\<lambda>f. ((*) (one_dim_iso (inverse (f 1)))) o one_dim_iso"
   by (auto intro!: comp_bounded_clinear bounded_clinear_mult_right)
 definition divide_cblinfun :: "'a \<Rightarrow>\<^sub>C\<^sub>L 'b \<Rightarrow> 'a \<Rightarrow>\<^sub>C\<^sub>L 'b \<Rightarrow> 'a \<Rightarrow>\<^sub>C\<^sub>L 'b" where
   "divide_cblinfun A B = A * inverse B"
 definition "canonical_basis_cblinfun = [1 :: 'a \<Rightarrow>\<^sub>C\<^sub>L 'b]"
 instance
 proof intro_classes
   let ?basis = "canonical_basis :: ('a \<Rightarrow>\<^sub>C\<^sub>L 'b) list"
   fix A B C :: "'a \<Rightarrow>\<^sub>C\<^sub>L 'b"
     and c c' :: complex
   show "distinct ?basis"
     unfolding canonical_basis_cblinfun_def by simp
   have "(1::'a \<Rightarrow>\<^sub>C\<^sub>L 'b) \<noteq> (0::'a \<Rightarrow>\<^sub>C\<^sub>L 'b)"
     by (metis cblinfun.zero_left one_cblinfun.rep_eq one_dim_iso_of_one zero_neq_one)
   thus "cindependent (set ?basis)"
     unfolding canonical_basis_cblinfun_def by simp
 
   have "A \<in> cspan (set ?basis)" for A
   proof -
     define c :: complex where "c = one_dim_iso (A *\<^sub>V 1)"
     have "A x = one_dim_iso (A 1) *\<^sub>C one_dim_iso x" for x
       by (smt (z3) cblinfun.scaleC_right complex_vector.scale_left_commute one_dim_iso_idem one_dim_scaleC_1)
     hence "A = one_dim_iso (A *\<^sub>V 1) *\<^sub>C 1"
       apply transfer by metis
     thus "A \<in> cspan (set ?basis)"
       unfolding canonical_basis_cblinfun_def
       by (smt complex_vector.span_base complex_vector.span_scale list.set_intros(1))
   qed
   thus "cspan (set ?basis) = UNIV" by auto
 
   have "A = (1::'a \<Rightarrow>\<^sub>C\<^sub>L 'b) \<Longrightarrow>
     norm (1::'a \<Rightarrow>\<^sub>C\<^sub>L 'b) = (1::real)"
     apply transfer by simp
   thus "A \<in> set ?basis \<Longrightarrow> norm A = 1"
-    unfolding canonical_basis_cblinfun_def 
+    unfolding canonical_basis_cblinfun_def
     by simp
 
   show "?basis = [1]"
     unfolding canonical_basis_cblinfun_def by simp
   show "c *\<^sub>C 1 * c' *\<^sub>C 1 = (c * c') *\<^sub>C (1::'a\<Rightarrow>\<^sub>C\<^sub>L'b)"
     apply transfer by auto
   have "(1::'a \<Rightarrow>\<^sub>C\<^sub>L 'b) = (0::'a \<Rightarrow>\<^sub>C\<^sub>L 'b) \<Longrightarrow> False"
     by (metis cblinfun.zero_left one_cblinfun.rep_eq one_dim_iso_of_zero' zero_neq_neg_one)
   thus "is_ortho_set (set ?basis)"
     unfolding is_ortho_set_def canonical_basis_cblinfun_def by auto
   show "A div B = A * inverse B"
     by (simp add: divide_cblinfun_def)
   show "inverse (c *\<^sub>C 1) = (1::'a\<Rightarrow>\<^sub>C\<^sub>L'b) /\<^sub>C c"
     apply transfer by (simp add: o_def one_dim_inverse)
 qed
 end
 
 lemma id_cblinfun_eq_1[simp]: \<open>id_cblinfun = 1\<close>
   apply transfer by auto
 
-lemma one_dim_apply_is_times[simp]: 
+lemma one_dim_apply_is_times[simp]:
   fixes A :: "'a::one_dim \<Rightarrow>\<^sub>C\<^sub>L 'a" and B :: "'a \<Rightarrow>\<^sub>C\<^sub>L 'a"
   shows "A o\<^sub>C\<^sub>L B = A * B"
   apply transfer by simp
 
 lemma one_comp_one_cblinfun[simp]: "1 o\<^sub>C\<^sub>L 1 = 1"
   apply transfer unfolding o_def by simp
 
 lemma one_cblinfun_adj[simp]: "1* = 1"
-  apply transfer by simp 
+  apply transfer by simp
 
 
 lemma scaleC_1_right[simp]: \<open>scaleC x (1::'a::one_dim) = of_complex x\<close>
   unfolding of_complex_def by simp
 
 lemma scaleC_of_complex[simp]: \<open>scaleC x (of_complex y) = of_complex (x * y)\<close>
   unfolding of_complex_def using scaleC_scaleC by blast
 
 lemma scaleC_1_apply[simp]: \<open>(x *\<^sub>C 1) *\<^sub>V y = x *\<^sub>C y\<close>
   by (metis cblinfun.scaleC_left cblinfun_id_cblinfun_apply id_cblinfun_eq_1)
 
 lemma cblinfun_apply_1_left[simp]: \<open>1 *\<^sub>V y = y\<close>
   by (metis cblinfun_id_cblinfun_apply id_cblinfun_eq_1)
 
 lemma of_complex_cblinfun_apply[simp]: \<open>of_complex x *\<^sub>V y = x *\<^sub>C y\<close>
   unfolding of_complex_def
   by (metis cblinfun.scaleC_left cblinfun_id_cblinfun_apply id_cblinfun_eq_1)
 
 lemma cblinfun_compose_1_left[simp]: \<open>1 o\<^sub>C\<^sub>L x = x\<close>
   apply transfer by auto
 
 lemma cblinfun_compose_1_right[simp]: \<open>x o\<^sub>C\<^sub>L 1 = x\<close>
   apply transfer by auto
 
 lemma one_dim_iso_id_cblinfun: \<open>one_dim_iso id_cblinfun = id_cblinfun\<close>
   by simp
 
 lemma one_dim_iso_id_cblinfun_eq_1: \<open>one_dim_iso id_cblinfun = 1\<close>
   by simp
 
 lemma one_dim_iso_comp_distr[simp]: \<open>one_dim_iso (a o\<^sub>C\<^sub>L b) = one_dim_iso a o\<^sub>C\<^sub>L one_dim_iso b\<close>
   by (smt (z3) cblinfun_compose_scaleC_left cblinfun_compose_scaleC_right one_cinner_a_scaleC_one one_comp_one_cblinfun one_dim_iso_of_one one_dim_iso_scaleC)
 
 lemma one_dim_iso_comp_distr_times[simp]: \<open>one_dim_iso (a o\<^sub>C\<^sub>L b) = one_dim_iso a * one_dim_iso b\<close>
   by (smt (verit, del_insts) mult.left_neutral mult_scaleC_left one_cinner_a_scaleC_one one_comp_one_cblinfun one_dim_iso_of_one one_dim_iso_scaleC cblinfun_compose_scaleC_right cblinfun_compose_scaleC_left)
 
 lemma one_dim_iso_adjoint[simp]: \<open>one_dim_iso (A*) = (one_dim_iso A)*\<close>
   by (smt (z3) one_cblinfun_adj one_cinner_a_scaleC_one one_dim_iso_of_one one_dim_iso_scaleC scaleC_adj)
 
 lemma one_dim_iso_adjoint_complex[simp]: \<open>one_dim_iso (A*) = cnj (one_dim_iso A)\<close>
   by (metis (mono_tags, lifting) one_cblinfun_adj one_dim_iso_idem one_dim_scaleC_1 scaleC_adj)
 
 lemma one_dim_cblinfun_compose_commute: \<open>a o\<^sub>C\<^sub>L b = b o\<^sub>C\<^sub>L a\<close> for a b :: \<open>('a::one_dim,'a) cblinfun\<close>
   by (simp add: one_dim_iso_inj)
 
 
 lemma one_cblinfun_apply_one[simp]: \<open>1 *\<^sub>V 1 = 1\<close>
   by (simp add: one_cblinfun.rep_eq)
 
 subsection \<open>Loewner order\<close>
 
 lift_definition heterogenous_cblinfun_id :: \<open>'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector\<close>
   is \<open>if bounded_clinear (heterogenous_identity :: 'a::complex_normed_vector \<Rightarrow> 'b::complex_normed_vector) then heterogenous_identity else (\<lambda>_. 0)\<close>
   by auto
 
 lemma heterogenous_cblinfun_id_def'[simp]: "heterogenous_cblinfun_id = id_cblinfun"
   apply transfer by auto
 
 definition "heterogenous_same_type_cblinfun (x::'a::chilbert_space itself) (y::'b::chilbert_space itself) \<longleftrightarrow>
   unitary (heterogenous_cblinfun_id :: 'a \<Rightarrow>\<^sub>C\<^sub>L 'b) \<and> unitary (heterogenous_cblinfun_id :: 'b \<Rightarrow>\<^sub>C\<^sub>L 'a)"
 
 lemma heterogenous_same_type_cblinfun[simp]: \<open>heterogenous_same_type_cblinfun (x::'a::chilbert_space itself) (y::'a::chilbert_space itself)\<close>
   unfolding heterogenous_same_type_cblinfun_def by auto
 
 instantiation cblinfun :: (chilbert_space, chilbert_space) ord begin
 definition less_eq_cblinfun :: \<open>('a \<Rightarrow>\<^sub>C\<^sub>L 'b) \<Rightarrow> ('a \<Rightarrow>\<^sub>C\<^sub>L 'b) \<Rightarrow> bool\<close>
-  where less_eq_cblinfun_def_heterogenous: \<open>less_eq_cblinfun A B = 
+  where less_eq_cblinfun_def_heterogenous: \<open>less_eq_cblinfun A B =
   (if heterogenous_same_type_cblinfun TYPE('a) TYPE('b) then
     \<forall>\<psi>::'b. cinner \<psi> ((B-A) *\<^sub>V heterogenous_cblinfun_id *\<^sub>V \<psi>) \<ge> 0 else (A=B))\<close>
 definition \<open>less_cblinfun (A :: 'a \<Rightarrow>\<^sub>C\<^sub>L 'b) B \<longleftrightarrow> A \<le> B \<and> \<not> B \<le> A\<close>
 instance..
 end
 
 lemma less_eq_cblinfun_def: \<open>A \<le> B \<longleftrightarrow>
     (\<forall>\<psi>. cinner \<psi> (A *\<^sub>V \<psi>) \<le> cinner \<psi> (B *\<^sub>V \<psi>))\<close>
-  unfolding less_eq_cblinfun_def_heterogenous 
+  unfolding less_eq_cblinfun_def_heterogenous
   by (auto simp del: less_eq_complex_def simp: cblinfun.diff_left cinner_diff_right)
 
 instantiation cblinfun :: (chilbert_space, chilbert_space) ordered_complex_vector begin
 instance
 proof intro_classes
   note less_eq_complex_def[simp del]
 
   fix x y z :: \<open>'a \<Rightarrow>\<^sub>C\<^sub>L 'b\<close>
   fix a b :: complex
 
   define pos where \<open>pos X \<longleftrightarrow> (\<forall>\<psi>. cinner \<psi> (X *\<^sub>V \<psi>) \<ge> 0)\<close> for X :: \<open>'b \<Rightarrow>\<^sub>C\<^sub>L 'b\<close>
   consider (unitary) \<open>heterogenous_same_type_cblinfun TYPE('a) TYPE('b)\<close>
       \<open>\<And>A B :: 'a \<Rightarrow>\<^sub>C\<^sub>L 'b. A \<le> B = pos ((B-A) o\<^sub>C\<^sub>L (heterogenous_cblinfun_id :: 'b\<Rightarrow>\<^sub>C\<^sub>L'a))\<close>
     | (trivial) \<open>\<And>A B :: 'a \<Rightarrow>\<^sub>C\<^sub>L 'b. A \<le> B \<longleftrightarrow> A = B\<close>
     apply atomize_elim by (auto simp: pos_def less_eq_cblinfun_def_heterogenous)
   note cases = this
 
   have [simp]: \<open>pos 0\<close>
     unfolding pos_def by auto
 
   have pos_nondeg: \<open>X = 0\<close> if \<open>pos X\<close> and \<open>pos (-X)\<close> for X
     apply (rule cblinfun_cinner_eqI, simp)
     using that by (metis (no_types, lifting) cblinfun.minus_left cinner_minus_right dual_order.antisym equation_minus_iff neg_le_0_iff_le pos_def)
 
   have pos_add: \<open>pos (X+Y)\<close> if \<open>pos X\<close> and \<open>pos Y\<close> for X Y
     by (smt (z3) pos_def cblinfun.diff_left cinner_minus_right cinner_simps(3) diff_ge_0_iff_ge diff_minus_eq_add neg_le_0_iff_le order_trans that(1) that(2) uminus_cblinfun.rep_eq)
 
   have pos_scaleC: \<open>pos (a *\<^sub>C X)\<close> if \<open>a\<ge>0\<close> and \<open>pos X\<close> for X a
     using that unfolding pos_def by (auto simp: cblinfun.scaleC_left)
 
   let ?id = \<open>heterogenous_cblinfun_id :: 'b \<Rightarrow>\<^sub>C\<^sub>L 'a\<close>
 
   show \<open>x \<le> x\<close>
     apply (cases rule:cases) by auto
   show \<open>(x < y) \<longleftrightarrow> (x \<le> y \<and> \<not> y \<le> x)\<close>
     unfolding less_cblinfun_def by simp
   show \<open>x \<le> z\<close> if \<open>x \<le> y\<close> and \<open>y \<le> z\<close>
   proof (cases rule:cases)
     case unitary
     define a b :: \<open>'b \<Rightarrow>\<^sub>C\<^sub>L 'b\<close> where \<open>a = (y-x) o\<^sub>C\<^sub>L heterogenous_cblinfun_id\<close>
       and \<open>b = (z-y) o\<^sub>C\<^sub>L heterogenous_cblinfun_id\<close>
     with unitary that have \<open>pos a\<close> and \<open>pos b\<close>
       by auto
     then have \<open>pos (a + b)\<close>
       by (rule pos_add)
     moreover have \<open>a + b = (z - x) o\<^sub>C\<^sub>L heterogenous_cblinfun_id\<close>
       unfolding a_def b_def
       by (metis (no_types, lifting) bounded_cbilinear.add_left bounded_cbilinear_cblinfun_compose diff_add_cancel ordered_field_class.sign_simps(2) ordered_field_class.sign_simps(8))
-    ultimately show ?thesis 
+    ultimately show ?thesis
       using unitary by auto
   next
     case trivial
     with that show ?thesis by auto
   qed
   show \<open>x = y\<close> if \<open>x \<le> y\<close> and \<open>y \<le> x\<close>
   proof (cases rule:cases)
     case unitary
     then have \<open>unitary ?id\<close>
       by (auto simp: heterogenous_same_type_cblinfun_def)
     define a b :: \<open>'b \<Rightarrow>\<^sub>C\<^sub>L 'b\<close> where \<open>a = (y-x) o\<^sub>C\<^sub>L ?id\<close>
       and \<open>b = (x-y) o\<^sub>C\<^sub>L ?id\<close>
     with unitary that have \<open>pos a\<close> and \<open>pos b\<close>
       by auto
     then have \<open>a = 0\<close>
       apply (rule_tac pos_nondeg)
        apply (auto simp: a_def b_def)
       by (smt (verit, best) add.commute bounded_cbilinear.add_left bounded_cbilinear_cblinfun_compose cblinfun_compose_zero_left diff_0 diff_add_cancel group_cancel.rule0 group_cancel.sub1)
     then show ?thesis
       unfolding a_def using \<open>unitary ?id\<close>
       by (metis cblinfun_compose_assoc cblinfun_compose_id_right cblinfun_compose_zero_left eq_iff_diff_eq_0 unitaryD2)
   next
     case trivial
     with that show ?thesis by simp
   qed
   show \<open>x + y \<le> x + z\<close> if \<open>y \<le> z\<close>
   proof (cases rule:cases)
     case unitary
-    with that show ?thesis 
+    with that show ?thesis
       by auto
   next
     case trivial
-    with that show ?thesis 
+    with that show ?thesis
       by auto
   qed
 
   show \<open>a *\<^sub>C x \<le> a *\<^sub>C y\<close> if \<open>x \<le> y\<close> and \<open>0 \<le> a\<close>
   proof (cases rule:cases)
     case unitary
     with that pos_scaleC show ?thesis
-      by (metis cblinfun_compose_scaleC_left complex_vector.scale_right_diff_distrib) 
+      by (metis cblinfun_compose_scaleC_left complex_vector.scale_right_diff_distrib)
   next
     case trivial
-    with that show ?thesis 
+    with that show ?thesis
       by auto
   qed
 
   show \<open>a *\<^sub>C x \<le> b *\<^sub>C x\<close> if \<open>a \<le> b\<close> and \<open>0 \<le> x\<close>
   proof (cases rule:cases)
     case unitary
     with that show ?thesis
       by (auto intro!: pos_scaleC simp flip: scaleC_diff_left)
   next
     case trivial
-    with that show ?thesis 
+    with that show ?thesis
       by auto
   qed
 qed
 end
 
 lemma positive_id_cblinfun[simp]: "id_cblinfun \<ge> 0"
   unfolding less_eq_cblinfun_def using cinner_ge_zero by auto
 
 lemma positive_hermitianI: \<open>A = A*\<close> if \<open>A \<ge> 0\<close>
   apply (rule cinner_real_hermiteanI)
   using that by (auto simp del: less_eq_complex_def simp: reals_zero_comparable_iff less_eq_cblinfun_def)
 
 lemma positive_cblinfunI: \<open>A \<ge> 0\<close> if \<open>\<And>x. cinner x (A *\<^sub>V x) \<ge> 0\<close>
   unfolding less_eq_cblinfun_def using that by auto
 
 (* Note: this does not require B to be a square operator *)
 lemma positive_cblinfun_squareI: \<open>A = B* o\<^sub>C\<^sub>L B \<Longrightarrow> A \<ge> 0\<close>
   apply (rule positive_cblinfunI)
   by (metis cblinfun_apply_cblinfun_compose cinner_adj_right cinner_ge_zero)
 
 
 lemma one_dim_loewner_order: \<open>A \<ge> B \<longleftrightarrow> one_dim_iso A \<ge> (one_dim_iso B :: complex)\<close> for A B :: \<open>'a \<Rightarrow>\<^sub>C\<^sub>L 'a::{chilbert_space, one_dim}\<close>
 proof -
   note less_eq_complex_def[simp del]
   have A: \<open>A = one_dim_iso A *\<^sub>C id_cblinfun\<close>
     by simp
   have B: \<open>B = one_dim_iso B *\<^sub>C id_cblinfun\<close>
     by simp
   have \<open>A \<ge> B \<longleftrightarrow> (\<forall>\<psi>. cinner \<psi> (A \<psi>) \<ge> cinner \<psi> (B \<psi>))\<close>
     by (simp add: less_eq_cblinfun_def)
   also have \<open>\<dots> \<longleftrightarrow> (\<forall>\<psi>::'a. one_dim_iso B * (\<psi> \<bullet>\<^sub>C \<psi>) \<le> one_dim_iso A * (\<psi> \<bullet>\<^sub>C \<psi>))\<close>
     apply (subst A, subst B)
-    by (metis (no_types, hide_lams) cinner_scaleC_right id_cblinfun_apply scaleC_cblinfun.rep_eq)
+    by (metis (no_types, opaque_lifting) cinner_scaleC_right id_cblinfun_apply scaleC_cblinfun.rep_eq)
   also have \<open>\<dots> \<longleftrightarrow> one_dim_iso A \<ge> (one_dim_iso B :: complex)\<close>
     by (auto intro!: mult_right_mono elim!: allE[where x=1])
   finally show ?thesis
     by -
 qed
 
 lemma one_dim_positive: \<open>A \<ge> 0 \<longleftrightarrow> one_dim_iso A \<ge> (0::complex)\<close> for A :: \<open>'a \<Rightarrow>\<^sub>C\<^sub>L 'a::{chilbert_space, one_dim}\<close>
   using one_dim_loewner_order[where B=0] by auto
 
 subsection \<open>Embedding vectors to operators\<close>
 
 lift_definition vector_to_cblinfun :: \<open>'a::complex_normed_vector \<Rightarrow> 'b::one_dim \<Rightarrow>\<^sub>C\<^sub>L 'a\<close> is
   \<open>\<lambda>\<psi> \<phi>. one_dim_iso \<phi> *\<^sub>C \<psi>\<close>
   by (simp add: bounded_clinear_scaleC_const)
 
-lemma vector_to_cblinfun_cblinfun_apply: 
-  "vector_to_cblinfun (A *\<^sub>V \<psi>) = A  o\<^sub>C\<^sub>L (vector_to_cblinfun \<psi>)" 
-  apply transfer 
+lemma vector_to_cblinfun_cblinfun_apply:
+  "vector_to_cblinfun (A *\<^sub>V \<psi>) = A  o\<^sub>C\<^sub>L (vector_to_cblinfun \<psi>)"
+  apply transfer
   unfolding comp_def bounded_clinear_def clinear_def Vector_Spaces.linear_def
     module_hom_def module_hom_axioms_def
   by simp
 
 lemma vector_to_cblinfun_add: \<open>vector_to_cblinfun (x + y) = vector_to_cblinfun x + vector_to_cblinfun y\<close>
   apply transfer
   by (simp add: scaleC_add_right)
 
 lemma norm_vector_to_cblinfun[simp]: "norm (vector_to_cblinfun x) = norm x"
 proof transfer
   have "bounded_clinear (one_dim_iso::'a \<Rightarrow> complex)"
-    by simp    
+    by simp
   moreover have "onorm (one_dim_iso::'a \<Rightarrow> complex) * norm x = norm x"
     for x :: 'b
     by simp
   ultimately show "onorm (\<lambda>\<phi>. one_dim_iso (\<phi>::'a) *\<^sub>C x) = norm x"
     for x :: 'b
     by (subst onorm_scaleC_left)
 qed
 
 lemma bounded_clinear_vector_to_cblinfun[bounded_clinear]: "bounded_clinear vector_to_cblinfun"
   apply (rule bounded_clinearI[where K=1])
     apply (transfer, simp add: scaleC_add_right)
    apply (transfer, simp add: mult.commute)
   by simp
 
 lemma vector_to_cblinfun_scaleC[simp]:
   "vector_to_cblinfun (a *\<^sub>C \<psi>) = a *\<^sub>C vector_to_cblinfun \<psi>" for a::complex
 proof (subst asm_rl [of "a *\<^sub>C \<psi> = (a *\<^sub>C id_cblinfun) *\<^sub>V \<psi>"])
   show "a *\<^sub>C \<psi> = a *\<^sub>C id_cblinfun *\<^sub>V \<psi>"
     by (simp add: scaleC_cblinfun.rep_eq)
   show "vector_to_cblinfun (a *\<^sub>C id_cblinfun *\<^sub>V \<psi>) = a *\<^sub>C (vector_to_cblinfun \<psi>::'a \<Rightarrow>\<^sub>C\<^sub>L 'b)"
     by (metis cblinfun_id_cblinfun_apply cblinfun_compose_scaleC_left vector_to_cblinfun_cblinfun_apply)
 qed
 
 lemma vector_to_cblinfun_apply_one_dim[simp]:
   shows "vector_to_cblinfun \<phi> *\<^sub>V \<gamma> = one_dim_iso \<gamma> *\<^sub>C \<phi>"
   apply transfer by (rule refl)
 
 lemma vector_to_cblinfun_adj_apply[simp]:
   shows "vector_to_cblinfun \<psi>* *\<^sub>V \<phi> = of_complex (cinner \<psi> \<phi>)"
-  by (simp add: cinner_adj_right one_dim_iso_def one_dim_iso_inj) 
-
-lemma vector_to_cblinfun_comp_one[simp]: 
-  "(vector_to_cblinfun s :: 'a::one_dim \<Rightarrow>\<^sub>C\<^sub>L _) o\<^sub>C\<^sub>L 1 
+  by (simp add: cinner_adj_right one_dim_iso_def one_dim_iso_inj)
+
+lemma vector_to_cblinfun_comp_one[simp]:
+  "(vector_to_cblinfun s :: 'a::one_dim \<Rightarrow>\<^sub>C\<^sub>L _) o\<^sub>C\<^sub>L 1
      = (vector_to_cblinfun s :: 'b::one_dim \<Rightarrow>\<^sub>C\<^sub>L _)"
   apply (transfer fixing: s)
   by fastforce
 
 lemma vector_to_cblinfun_0[simp]: "vector_to_cblinfun 0 = 0"
   by (metis cblinfun.zero_left cblinfun_compose_zero_left vector_to_cblinfun_cblinfun_apply)
 
 lemma image_vector_to_cblinfun[simp]: "vector_to_cblinfun x *\<^sub>S top = ccspan {x}"
 proof transfer
   show "closure (range (\<lambda>\<phi>::'b. one_dim_iso \<phi> *\<^sub>C x)) = closure (cspan {x})"
     for x :: 'a
   proof (rule arg_cong [where f = closure])
     have "k *\<^sub>C x \<in> range (\<lambda>\<phi>. one_dim_iso \<phi> *\<^sub>C x)" for k
       by (smt (z3) id_apply one_dim_iso_id one_dim_iso_idem range_eqI)
     thus "range (\<lambda>\<phi>. one_dim_iso (\<phi>::'b) *\<^sub>C x) = cspan {x}"
       unfolding complex_vector.span_singleton
       by auto
   qed
 qed
 
 lemma vector_to_cblinfun_adj_comp_vector_to_cblinfun[simp]:
   shows "vector_to_cblinfun \<psi>* o\<^sub>C\<^sub>L vector_to_cblinfun \<phi> = cinner \<psi> \<phi> *\<^sub>C id_cblinfun"
 proof -
   have "one_dim_iso \<gamma> *\<^sub>C one_dim_iso (of_complex \<langle>\<psi>, \<phi>\<rangle>) =
     \<langle>\<psi>, \<phi>\<rangle> *\<^sub>C one_dim_iso \<gamma>"
-    for \<gamma> :: "'c::one_dim"      
+    for \<gamma> :: "'c::one_dim"
     by (metis complex_vector.scale_left_commute of_complex_def one_dim_iso_of_one one_dim_iso_scaleC one_dim_scaleC_1)
   hence "one_dim_iso ((vector_to_cblinfun \<psi>* o\<^sub>C\<^sub>L vector_to_cblinfun \<phi>) *\<^sub>V \<gamma>)
-      = one_dim_iso ((cinner \<psi> \<phi> *\<^sub>C id_cblinfun) *\<^sub>V \<gamma>)" 
+      = one_dim_iso ((cinner \<psi> \<phi> *\<^sub>C id_cblinfun) *\<^sub>V \<gamma>)"
     for \<gamma> :: "'c::one_dim"
     by simp
-  hence "((vector_to_cblinfun \<psi>* o\<^sub>C\<^sub>L vector_to_cblinfun \<phi>) *\<^sub>V \<gamma>) = ((cinner \<psi> \<phi> *\<^sub>C id_cblinfun) *\<^sub>V \<gamma>)" 
+  hence "((vector_to_cblinfun \<psi>* o\<^sub>C\<^sub>L vector_to_cblinfun \<phi>) *\<^sub>V \<gamma>) = ((cinner \<psi> \<phi> *\<^sub>C id_cblinfun) *\<^sub>V \<gamma>)"
     for \<gamma> :: "'c::one_dim"
     by (rule one_dim_iso_inj)
   thus ?thesis
     using cblinfun_eqI[where x = "vector_to_cblinfun \<psi>* o\<^sub>C\<^sub>L vector_to_cblinfun \<phi>"
         and y = "\<langle>\<psi>, \<phi>\<rangle> *\<^sub>C id_cblinfun"]
     by auto
 qed
 
 lemma isometry_vector_to_cblinfun[simp]:
   assumes "norm x = 1"
   shows "isometry (vector_to_cblinfun x)"
   using assms cnorm_eq_1 isometry_def by force
 
 subsection \<open>Butterflies (rank-1 projectors)\<close>
 
 definition butterfly_def: "butterfly (s::'a::complex_normed_vector) (t::'b::chilbert_space)
    = vector_to_cblinfun s o\<^sub>C\<^sub>L (vector_to_cblinfun t :: complex \<Rightarrow>\<^sub>C\<^sub>L _)*"
 
 abbreviation "selfbutter s \<equiv> butterfly s s"
 
 lemma butterfly_add_left: \<open>butterfly (a + a') b = butterfly a b + butterfly a' b\<close>
   by (simp add: butterfly_def vector_to_cblinfun_add cbilinear_add_left bounded_cbilinear.add_left bounded_cbilinear_cblinfun_compose)
 
 lemma butterfly_add_right: \<open>butterfly a (b + b') = butterfly a b + butterfly a b'\<close>
   by (simp add: butterfly_def adj_plus vector_to_cblinfun_add cblinfun_compose_add_right)
 
 lemma butterfly_def_one_dim: "butterfly s t = (vector_to_cblinfun s :: 'c::one_dim \<Rightarrow>\<^sub>C\<^sub>L _)
                                           o\<^sub>C\<^sub>L (vector_to_cblinfun t :: 'c \<Rightarrow>\<^sub>C\<^sub>L _)*"
   (is "_ = ?rhs") for s :: "'a::complex_normed_vector" and t :: "'b::chilbert_space"
 proof -
   let ?isoAC = "1 :: 'c \<Rightarrow>\<^sub>C\<^sub>L complex"
   let ?isoCA = "1 :: complex \<Rightarrow>\<^sub>C\<^sub>L 'c"
   let ?vector = "vector_to_cblinfun :: _ \<Rightarrow> ('c \<Rightarrow>\<^sub>C\<^sub>L _)"
 
   have "butterfly s t =
     (?vector s o\<^sub>C\<^sub>L ?isoCA) o\<^sub>C\<^sub>L (?vector t o\<^sub>C\<^sub>L ?isoCA)*"
     unfolding butterfly_def vector_to_cblinfun_comp_one by simp
   also have "\<dots> = ?vector s o\<^sub>C\<^sub>L (?isoCA o\<^sub>C\<^sub>L ?isoCA*) o\<^sub>C\<^sub>L (?vector t)*"
     by (metis (no_types, lifting) cblinfun_compose_assoc adj_cblinfun_compose)
   also have "\<dots> = ?rhs"
     by simp
   finally show ?thesis
     by simp
 qed
 
 lemma butterfly_comp_cblinfun: "butterfly \<psi> \<phi> o\<^sub>C\<^sub>L a = butterfly \<psi> (a* *\<^sub>V \<phi>)"
   unfolding butterfly_def
-  by (simp add: cblinfun_compose_assoc vector_to_cblinfun_cblinfun_apply)  
+  by (simp add: cblinfun_compose_assoc vector_to_cblinfun_cblinfun_apply)
 
 lemma cblinfun_comp_butterfly: "a o\<^sub>C\<^sub>L butterfly \<psi> \<phi> = butterfly (a *\<^sub>V \<psi>) \<phi>"
   unfolding butterfly_def
-  by (simp add: cblinfun_compose_assoc vector_to_cblinfun_cblinfun_apply)  
+  by (simp add: cblinfun_compose_assoc vector_to_cblinfun_cblinfun_apply)
 
 lemma butterfly_apply[simp]: "butterfly \<psi> \<psi>' *\<^sub>V \<phi> = \<langle>\<psi>', \<phi>\<rangle> *\<^sub>C \<psi>"
   by (simp add: butterfly_def scaleC_cblinfun.rep_eq)
 
 lemma butterfly_scaleC_left[simp]: "butterfly (c *\<^sub>C \<psi>) \<phi> = c *\<^sub>C butterfly \<psi> \<phi>"
   unfolding butterfly_def vector_to_cblinfun_scaleC scaleC_adj
   by (simp add: cnj_x_x)
 
 lemma butterfly_scaleC_right[simp]: "butterfly \<psi> (c *\<^sub>C \<phi>) = cnj c *\<^sub>C butterfly \<psi> \<phi>"
   unfolding butterfly_def vector_to_cblinfun_scaleC scaleC_adj
   by (simp add: cnj_x_x)
 
 lemma butterfly_scaleR_left[simp]: "butterfly (r *\<^sub>R \<psi>) \<phi> = r *\<^sub>C butterfly \<psi> \<phi>"
   by (simp add: scaleR_scaleC)
 
 lemma butterfly_scaleR_right[simp]: "butterfly \<psi> (r *\<^sub>R \<phi>) = r *\<^sub>C butterfly \<psi> \<phi>"
   by (simp add: butterfly_scaleC_right scaleR_scaleC)
 
 lemma butterfly_adjoint[simp]: "(butterfly \<psi> \<phi>)* = butterfly \<phi> \<psi>"
   unfolding butterfly_def by auto
 
 lemma butterfly_comp_butterfly[simp]: "butterfly \<psi>1 \<psi>2 o\<^sub>C\<^sub>L butterfly \<psi>3 \<psi>4 = \<langle>\<psi>2, \<psi>3\<rangle> *\<^sub>C butterfly \<psi>1 \<psi>4"
   by (simp add: butterfly_comp_cblinfun)
 
 lemma butterfly_0_left[simp]: "butterfly 0 a = 0"
   by (simp add: butterfly_def)
 
 lemma butterfly_0_right[simp]: "butterfly a 0 = 0"
   by (simp add: butterfly_def)
 
 lemma norm_butterfly: "norm (butterfly \<psi> \<phi>) = norm \<psi> * norm \<phi>"
 proof (cases "\<phi>=0")
   case True
   then show ?thesis by simp
 next
   case False
-  show ?thesis 
+  show ?thesis
     unfolding norm_cblinfun.rep_eq
     thm onormI[OF _ False]
   proof (rule onormI[OF _ False])
-    fix x 
+    fix x
 
     have "cmod \<langle>\<phi>, x\<rangle> * norm \<psi> \<le> norm \<psi> * norm \<phi> * norm x"
       by (metis ab_semigroup_mult_class.mult_ac(1) complex_inner_class.Cauchy_Schwarz_ineq2 mult.commute mult_left_mono norm_ge_zero)
     thus "norm (butterfly \<psi> \<phi> *\<^sub>V x) \<le> norm \<psi> * norm \<phi> * norm x"
       by (simp add: power2_eq_square)
 
     show "norm (butterfly \<psi> \<phi> *\<^sub>V \<phi>) = norm \<psi> * norm \<phi> * norm \<phi>"
       by (smt (z3) ab_semigroup_mult_class.mult_ac(1) butterfly_apply mult.commute norm_eq_sqrt_cinner norm_ge_zero norm_scaleC power2_eq_square real_sqrt_abs real_sqrt_eq_iff)
   qed
 qed
 
 lemma bounded_sesquilinear_butterfly[bounded_sesquilinear]: \<open>bounded_sesquilinear (\<lambda>(b::'b::chilbert_space) (a::'a::chilbert_space). butterfly a b)\<close>
 proof standard
   fix a a' :: 'a and b b' :: 'b and r :: complex
   show \<open>butterfly (a + a') b = butterfly a b + butterfly a' b\<close>
     by (rule butterfly_add_left)
-  show \<open>butterfly a (b + b') = butterfly a b + butterfly a b'\<close>  
+  show \<open>butterfly a (b + b') = butterfly a b + butterfly a b'\<close>
     by (rule butterfly_add_right)
   show \<open>butterfly (r *\<^sub>C a) b = r *\<^sub>C butterfly a b\<close>
     by simp
   show \<open>butterfly a (r *\<^sub>C b) = cnj r *\<^sub>C butterfly a b\<close>
     by simp
   show \<open>\<exists>K. \<forall>b a. norm (butterfly a b) \<le> norm b * norm a * K \<close>
     apply (rule exI[of _ 1])
     by (simp add: norm_butterfly)
 qed
 
-lemma inj_selfbutter_upto_phase: 
+lemma inj_selfbutter_upto_phase:
   assumes "selfbutter x = selfbutter y"
   shows "\<exists>c. cmod c = 1 \<and> x = c *\<^sub>C y"
 proof (cases "x = 0")
   case True
   from assms have "y = 0"
     using norm_butterfly
     by (metis True butterfly_0_left divisors_zero norm_eq_zero)
   with True show ?thesis
     using norm_one by fastforce
 next
   case False
   define c where "c = \<langle>y, x\<rangle> / \<langle>x, x\<rangle>"
   have "\<langle>x, x\<rangle> *\<^sub>C x = selfbutter x *\<^sub>V x"
     by (simp add: butterfly_apply)
   also have "\<dots> = selfbutter y *\<^sub>V x"
     using assms by simp
   also have "\<dots> = \<langle>y, x\<rangle> *\<^sub>C y"
     by (simp add: butterfly_apply)
   finally have xcy: "x = c *\<^sub>C y"
     by (simp add: c_def ceq_vector_fraction_iff)
   have "cmod c * norm x = cmod c * norm y"
     using assms norm_butterfly
     by (smt (verit, ccfv_SIG) \<open>\<langle>x, x\<rangle> *\<^sub>C x = selfbutter x *\<^sub>V x\<close> \<open>selfbutter y *\<^sub>V x = \<langle>y, x\<rangle> *\<^sub>C y\<close> cinner_scaleC_right complex_vector.scale_left_commute complex_vector.scale_right_imp_eq mult_cancel_left norm_eq_sqrt_cinner norm_eq_zero scaleC_scaleC xcy)
   also have "cmod c * norm y = norm (c *\<^sub>C y)"
     by simp
   also have "\<dots> = norm x"
     unfolding xcy[symmetric] by simp
   finally have c: "cmod c = 1"
     by (simp add: False)
   from c xcy show ?thesis
     by auto
 qed
 
 lemma butterfly_eq_proj:
   assumes "norm x = 1"
   shows "selfbutter x = proj x"
 proof -
   define B and \<phi> :: "complex \<Rightarrow>\<^sub>C\<^sub>L 'a"
     where "B = selfbutter x" and "\<phi> = vector_to_cblinfun x"
   then have B: "B = \<phi> o\<^sub>C\<^sub>L \<phi>*"
     unfolding butterfly_def by simp
-  have \<phi>adj\<phi>: "\<phi>* o\<^sub>C\<^sub>L \<phi> = id_cblinfun"    
+  have \<phi>adj\<phi>: "\<phi>* o\<^sub>C\<^sub>L \<phi> = id_cblinfun"
     using \<phi>_def assms isometry_def isometry_vector_to_cblinfun by blast
   have "B o\<^sub>C\<^sub>L B = \<phi> o\<^sub>C\<^sub>L (\<phi>* o\<^sub>C\<^sub>L \<phi>) o\<^sub>C\<^sub>L \<phi>*"
     by (simp add: B cblinfun_assoc_left(1))
   also have "\<dots> = B"
     unfolding \<phi>adj\<phi> by (simp add: B)
   finally have idem: "B o\<^sub>C\<^sub>L B = B".
   have herm: "B = B*"
     unfolding B by simp
   from idem herm have BProj: "B = Proj (B *\<^sub>S top)"
     by (rule Proj_on_own_range'[symmetric])
   have "B *\<^sub>S top = ccspan {x}"
     by (simp add: B \<phi>_def assms cblinfun_compose_image range_adjoint_isometry)
   with BProj show "B = proj x"
     by simp
 qed
 
 lemma butterfly_is_Proj:
   \<open>norm x = 1 \<Longrightarrow> is_Proj (selfbutter x)\<close>
   by (subst butterfly_eq_proj, simp_all)
 
 lemma cspan_butterfly_UNIV:
   assumes \<open>cspan basisA = UNIV\<close>
   assumes \<open>cspan basisB = UNIV\<close>
   assumes \<open>is_ortho_set basisB\<close>
   assumes \<open>\<And>b. b \<in> basisB \<Longrightarrow> norm b = 1\<close>
   shows \<open>cspan {butterfly a b| (a::'a::{complex_normed_vector}) (b::'b::{chilbert_space,cfinite_dim}). a \<in> basisA \<and> b \<in> basisB} = UNIV\<close>
 proof -
   have F: \<open>\<exists>F\<in>{butterfly a b |a b. a \<in> basisA \<and> b \<in> basisB}. \<forall>b'\<in>basisB. F *\<^sub>V b' = (if b' = b then a else 0)\<close>
     if \<open>a \<in> basisA\<close> and \<open>b \<in> basisB\<close> for a b
     apply (rule bexI[where x=\<open>butterfly a b\<close>])
     using assms that by (auto simp: is_ortho_set_def cnorm_eq_1)
   show ?thesis
     apply (rule cblinfun_cspan_UNIV[where basisA=basisB and basisB=basisA])
     using assms apply auto[2]
     using F by (smt (verit, ccfv_SIG) image_iff)
 qed
 
-lemma cindependent_butterfly: 
+lemma cindependent_butterfly:
   fixes basisA :: \<open>'a::chilbert_space set\<close> and basisB :: \<open>'b::chilbert_space set\<close>
   assumes \<open>is_ortho_set basisA\<close> \<open>is_ortho_set basisB\<close>
   assumes normA: \<open>\<And>a. a\<in>basisA \<Longrightarrow> norm a = 1\<close> and normB: \<open>\<And>b. b\<in>basisB \<Longrightarrow> norm b = 1\<close>
   shows \<open>cindependent {butterfly a b| a b. a\<in>basisA \<and> b\<in>basisB}\<close>
 proof (unfold complex_vector.independent_explicit_module, intro allI impI, rename_tac T f g)
   fix T :: \<open>('b \<Rightarrow>\<^sub>C\<^sub>L 'a) set\<close> and f :: \<open>'b \<Rightarrow>\<^sub>C\<^sub>L 'a \<Rightarrow> complex\<close> and g :: \<open>'b \<Rightarrow>\<^sub>C\<^sub>L 'a\<close>
   assume \<open>finite T\<close>
   assume T_subset: \<open>T \<subseteq> {butterfly a b |a b. a \<in> basisA \<and> b \<in> basisB}\<close>
   define lin where \<open>lin = (\<Sum>g\<in>T. f g *\<^sub>C g)\<close>
   assume \<open>lin = 0\<close>
   assume \<open>g \<in> T\<close>
   (* To show: f g = 0 *)
   then obtain a b where g: \<open>g = butterfly a b\<close> and [simp]: \<open>a \<in> basisA\<close> \<open>b \<in> basisB\<close>
     using T_subset by auto
 
   have *: "(vector_to_cblinfun a)* *\<^sub>V f g *\<^sub>C g *\<^sub>V b = 0"
-    if \<open>g \<in> T - {butterfly a b}\<close> for g 
+    if \<open>g \<in> T - {butterfly a b}\<close> for g
   proof -
     from that
     obtain a' b' where g: \<open>g = butterfly a' b'\<close> and [simp]: \<open>a' \<in> basisA\<close> \<open>b' \<in> basisB\<close>
       using T_subset by auto
     from that have \<open>g \<noteq> butterfly a b\<close> by auto
     with g consider (a) \<open>a\<noteq>a'\<close> | (b) \<open>b\<noteq>b'\<close>
       by auto
     then show \<open>(vector_to_cblinfun a)* *\<^sub>V f g *\<^sub>C g *\<^sub>V b = 0\<close>
     proof cases
       case a
-      then show ?thesis 
-        using  \<open>is_ortho_set basisA\<close> unfolding g 
+      then show ?thesis
+        using  \<open>is_ortho_set basisA\<close> unfolding g
         by (auto simp: is_ortho_set_def butterfly_def scaleC_cblinfun.rep_eq)
     next
       case b
       then show ?thesis
-        using  \<open>is_ortho_set basisB\<close> unfolding g 
+        using  \<open>is_ortho_set basisB\<close> unfolding g
         by (auto simp: is_ortho_set_def butterfly_def scaleC_cblinfun.rep_eq)
     qed
   qed
 
   have \<open>0 = (vector_to_cblinfun a)* *\<^sub>V lin *\<^sub>V b\<close>
     using \<open>lin = 0\<close> by auto
   also have \<open>\<dots> = (\<Sum>g\<in>T. (vector_to_cblinfun a)* *\<^sub>V (f g *\<^sub>C g) *\<^sub>V b)\<close>
     unfolding lin_def
     apply (rule complex_vector.linear_sum)
     by (smt (z3) cblinfun.scaleC_left cblinfun.scaleC_right cblinfun.add_right clinearI plus_cblinfun.rep_eq)
   also have \<open>\<dots> = (\<Sum>g\<in>{butterfly a b}. (vector_to_cblinfun a)* *\<^sub>V (f g *\<^sub>C g) *\<^sub>V b)\<close>
     apply (rule sum.mono_neutral_right)
     using \<open>finite T\<close> * \<open>g \<in> T\<close> g by auto
   also have \<open>\<dots> = (vector_to_cblinfun a)* *\<^sub>V (f g *\<^sub>C g) *\<^sub>V b\<close>
     by (simp add: g)
   also have \<open>\<dots> = f g\<close>
-    unfolding g 
+    unfolding g
     using normA normB by (auto simp: butterfly_def scaleC_cblinfun.rep_eq cnorm_eq_1)
   finally show \<open>f g = 0\<close>
     by simp
 qed
 
 lemma clinear_eq_butterflyI:
   fixes F G :: \<open>('a::{chilbert_space,cfinite_dim} \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_inner) \<Rightarrow> 'c::complex_vector\<close>
   assumes "clinear F" and "clinear G"
   assumes \<open>cspan basisA = UNIV\<close> \<open>cspan basisB = UNIV\<close>
   assumes \<open>is_ortho_set basisA\<close> \<open>is_ortho_set basisB\<close>
   assumes "\<And>a b. a\<in>basisA \<Longrightarrow> b\<in>basisB \<Longrightarrow> F (butterfly a b) = G (butterfly a b)"
   assumes \<open>\<And>b. b\<in>basisB \<Longrightarrow> norm b = 1\<close>
   shows "F = G"
   apply (rule complex_vector.linear_eq_on_span[where f=F, THEN ext, rotated 3])
      apply (subst cspan_butterfly_UNIV)
   using assms by auto
 
 subsection \<open>Bifunctionals\<close>
 
 lift_definition bifunctional :: \<open>'a::complex_normed_vector \<Rightarrow>\<^sub>C\<^sub>L (('a \<Rightarrow>\<^sub>C\<^sub>L complex) \<Rightarrow>\<^sub>C\<^sub>L complex)\<close>
   is \<open>\<lambda>x f. f *\<^sub>V x\<close>
   by (simp add: cblinfun.flip)
 
 lemma bifunctional_apply[simp]: \<open>(bifunctional *\<^sub>V x) *\<^sub>V f = f *\<^sub>V x\<close>
   by (transfer fixing: x f, simp)
 
 lemma bifunctional_isometric[simp]: \<open>norm (bifunctional *\<^sub>V x) = norm x\<close> for x :: \<open>'a::complex_inner\<close>
 proof -
   define f :: \<open>'a \<Rightarrow>\<^sub>C\<^sub>L complex\<close> where \<open>f = CBlinfun (\<lambda>y. cinner x y)\<close>
   then have [simp]: \<open>f *\<^sub>V y = cinner x y\<close> for y
     by (simp add: bounded_clinear_CBlinfun_apply bounded_clinear_cinner_right)
   then have [simp]: \<open>norm f = norm x\<close>
     apply (auto intro!: norm_cblinfun_eqI[where x=x] simp: power2_norm_eq_cinner[symmetric])
      apply (smt (verit, best) norm_eq_sqrt_cinner norm_ge_zero power2_norm_eq_cinner real_div_sqrt)
     using Cauchy_Schwarz_ineq2 by blast
   show ?thesis
     apply (auto intro!: norm_cblinfun_eqI[where x=f])
      apply (metis norm_eq_sqrt_cinner norm_imp_pos_and_ge real_div_sqrt)
     by (metis norm_cblinfun ordered_field_class.sign_simps(33))
 qed
 
 lemma norm_bifunctional[simp]: \<open>norm (bifunctional :: 'a::{complex_inner, not_singleton} \<Rightarrow>\<^sub>C\<^sub>L _) = 1\<close>
 proof -
   obtain x :: 'a where [simp]: \<open>norm x = 1\<close>
     by (meson UNIV_not_singleton ex_norm1)
   show ?thesis
     by (auto intro!: norm_cblinfun_eqI[where x=x])
 qed
 
 subsection \<open>Banach-Steinhaus\<close>
 
 theorem cbanach_steinhaus:
   fixes F :: \<open>'c \<Rightarrow> 'a::cbanach \<Rightarrow>\<^sub>C\<^sub>L 'b::complex_normed_vector\<close>
   assumes \<open>\<And>x. \<exists>M. \<forall>n.  norm ((F n) *\<^sub>V x) \<le> M\<close>
-  shows  \<open>\<exists>M. \<forall> n. norm (F n) \<le> M\<close>  
+  shows  \<open>\<exists>M. \<forall> n. norm (F n) \<le> M\<close>
   using cblinfun_blinfun_transfer[transfer_rule] apply (rule TrueI)? (* Deletes current facts *)
 proof (use assms in transfer)
   fix F :: \<open>'c \<Rightarrow> 'a \<Rightarrow>\<^sub>L 'b\<close> assume \<open>(\<And>x. \<exists>M. \<forall>n. norm (F n *\<^sub>v x) \<le> M)\<close>
   hence \<open>\<And>x. bounded (range (\<lambda>n. blinfun_apply (F n) x))\<close>
     by (metis (no_types, lifting) boundedI rangeE)
   hence \<open>bounded (range F)\<close>
     by (simp add: banach_steinhaus)
   thus  \<open>\<exists>M. \<forall>n. norm (F n) \<le> M\<close>
     by (simp add: bounded_iff)
 qed
 
 subsection \<open>Riesz-representation theorem\<close>
 
 theorem riesz_frechet_representation_cblinfun_existence:
   \<comment> \<open>Theorem 3.4 in @{cite conway2013course}\<close>
   fixes f::\<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L complex\<close>
   shows \<open>\<exists>t. \<forall>x.  f *\<^sub>V x = \<langle>t, x\<rangle>\<close>
   apply transfer by (rule riesz_frechet_representation_existence)
 
 lemma riesz_frechet_representation_cblinfun_unique:
   \<comment> \<open>Theorem 3.4 in @{cite conway2013course}\<close>
   fixes f::\<open>'a::complex_inner \<Rightarrow>\<^sub>C\<^sub>L complex\<close>
   assumes \<open>\<And>x. f *\<^sub>V x = \<langle>t, x\<rangle>\<close>
   assumes \<open>\<And>x. f *\<^sub>V x = \<langle>u, x\<rangle>\<close>
   shows \<open>t = u\<close>
   using assms by (rule riesz_frechet_representation_unique)
 
 theorem riesz_frechet_representation_cblinfun_norm:
   includes notation_norm
   fixes f::\<open>'a::chilbert_space \<Rightarrow>\<^sub>C\<^sub>L complex\<close>
   assumes \<open>\<And>x.  f *\<^sub>V x = \<langle>t, x\<rangle>\<close>
   shows \<open>\<parallel>f\<parallel> = \<parallel>t\<parallel>\<close>
-  using assms 
+  using assms
 proof transfer
   fix f::\<open>'a \<Rightarrow> complex\<close> and t
-  assume \<open>bounded_clinear f\<close> and \<open>\<And>x. f x = \<langle>t, x\<rangle>\<close> 
-  from  \<open>\<And>x. f x = \<langle>t, x\<rangle>\<close> 
+  assume \<open>bounded_clinear f\<close> and \<open>\<And>x. f x = \<langle>t, x\<rangle>\<close>
+  from  \<open>\<And>x. f x = \<langle>t, x\<rangle>\<close>
   have \<open>(norm (f x)) / (norm x) \<le> norm t\<close>
     for x
   proof(cases \<open>norm x = 0\<close>)
     case True
     thus ?thesis by simp
   next
     case False
     have \<open>norm (f x) = norm (\<langle>t, x\<rangle>)\<close>
       using \<open>\<And>x. f x = \<langle>t, x\<rangle>\<close> by simp
     also have \<open>norm \<langle>t, x\<rangle> \<le> norm t * norm x\<close>
       by (simp add: complex_inner_class.Cauchy_Schwarz_ineq2)
     finally have \<open>norm (f x) \<le> norm t * norm x\<close>
       by blast
     thus ?thesis
-      by (metis False linordered_field_class.divide_right_mono nonzero_mult_div_cancel_right norm_ge_zero) 
+      by (metis False linordered_field_class.divide_right_mono nonzero_mult_div_cancel_right norm_ge_zero)
   qed
   moreover have \<open>(norm (f t)) / (norm t) = norm t\<close>
   proof(cases \<open>norm t = 0\<close>)
     case True
     thus ?thesis
-      by simp 
+      by simp
   next
     case False
     have \<open>f t = \<langle>t, t\<rangle>\<close>
       using \<open>\<And>x. f x = \<langle>t, x\<rangle>\<close> by blast
     also have \<open>\<dots> = (norm t)^2\<close>
       by (meson cnorm_eq_square)
     also have \<open>\<dots> = (norm t)*(norm t)\<close>
       by (simp add: power2_eq_square)
     finally have \<open>f t = (norm t)*(norm t)\<close>
       by blast
     thus ?thesis
       by (metis False Re_complex_of_real \<open>\<And>x. f x = cinner t x\<close> cinner_ge_zero complex_of_real_cmod nonzero_divide_eq_eq)
   qed
   ultimately have \<open>Sup {(norm (f x)) / (norm x)| x. True} = norm t\<close>
-    by (smt cSup_eq_maximum mem_Collect_eq)    
+    by (smt cSup_eq_maximum mem_Collect_eq)
   moreover have \<open>Sup {(norm (f x)) / (norm x)| x. True} = (SUP x. (norm (f x)) / (norm x))\<close>
-    by (simp add: full_SetCompr_eq)    
+    by (simp add: full_SetCompr_eq)
   ultimately show \<open>onorm f = norm t\<close>
-    by (simp add: onorm_def) 
+    by (simp add: onorm_def)
 qed
 
 subsection \<open>Extension of complex bounded operators\<close>
 
-definition cblinfun_extension where 
+definition cblinfun_extension where
   "cblinfun_extension S \<phi> = (SOME B. \<forall>x\<in>S. B *\<^sub>V x = \<phi> x)"
 
-definition cblinfun_extension_exists where 
+definition cblinfun_extension_exists where
   "cblinfun_extension_exists S \<phi> = (\<exists>B. \<forall>x\<in>S. B *\<^sub>V x = \<phi> x)"
 
 lemma cblinfun_extension_existsI:
   assumes "\<And>x. x\<in>S \<Longrightarrow> B *\<^sub>V x = \<phi> x"
   shows "cblinfun_extension_exists S \<phi>"
   using assms cblinfun_extension_exists_def by blast
 
 lemma cblinfun_extension_exists_finite_dim:
-  fixes \<phi>::"'a::{complex_normed_vector,cfinite_dim} \<Rightarrow> 'b::complex_normed_vector" 
+  fixes \<phi>::"'a::{complex_normed_vector,cfinite_dim} \<Rightarrow> 'b::complex_normed_vector"
   assumes "cindependent S"
     and "cspan S = UNIV"
   shows "cblinfun_extension_exists S \<phi>"
 proof-
   define f::"'a \<Rightarrow> 'b"
     where "f = complex_vector.construct S \<phi>"
   have "clinear f"
-    by (simp add: complex_vector.linear_construct assms linear_construct f_def) 
+    by (simp add: complex_vector.linear_construct assms linear_construct f_def)
   have "bounded_clinear f"
-    using \<open>clinear f\<close> assms by auto    
-  then obtain B::"'a \<Rightarrow>\<^sub>C\<^sub>L 'b" 
+    using \<open>clinear f\<close> assms by auto
+  then obtain B::"'a \<Rightarrow>\<^sub>C\<^sub>L 'b"
     where "B *\<^sub>V x = f x" for x
     using cblinfun_apply_cases by blast
   have "B *\<^sub>V x = \<phi> x"
     if c1: "x\<in>S"
     for x
   proof-
     have "B *\<^sub>V x = f x"
       by (simp add: \<open>\<And>x. B *\<^sub>V x = f x\<close>)
     also have "\<dots> = \<phi> x"
       using assms complex_vector.construct_basis f_def that
-      by (simp add: complex_vector.construct_basis) 
+      by (simp add: complex_vector.construct_basis)
     finally show?thesis by blast
   qed
-  thus ?thesis 
+  thus ?thesis
     unfolding cblinfun_extension_exists_def
     by blast
 qed
 
 lemma cblinfun_extension_exists_bounded_dense:
   fixes f :: \<open>'a::complex_normed_vector \<Rightarrow> 'b::cbanach\<close>
   assumes \<open>csubspace S\<close>
   assumes \<open>closure S = UNIV\<close>
   assumes f_add: \<open>\<And>x y. x \<in> S \<Longrightarrow> y \<in> S \<Longrightarrow> f (x + y) = f x + f y\<close>
   assumes f_scale: \<open>\<And>c x y. x \<in> S \<Longrightarrow> f (c *\<^sub>C x) = c *\<^sub>C f x\<close>
   assumes bounded: \<open>\<And>x. x \<in> S \<Longrightarrow> norm (f x) \<le> B * norm x\<close>
   shows \<open>cblinfun_extension_exists S f\<close>
 proof -
   obtain B where bounded: \<open>\<And>x. x \<in> S \<Longrightarrow> norm (f x) \<le> B * norm x\<close> and \<open>B > 0\<close>
-    using bounded by (smt (z3) mult_mono norm_ge_zero)  
+    using bounded by (smt (z3) mult_mono norm_ge_zero)
   have \<open>\<exists>xi. (xi \<longlonglongrightarrow> x) \<and> (\<forall>i. xi i \<in> S)\<close> for x
     using assms(2) closure_sequential by blast
   then obtain seq :: \<open>'a \<Rightarrow> nat \<Rightarrow> 'a\<close> where seq_lim: \<open>seq x \<longlonglongrightarrow> x\<close> and seq_S: \<open>seq x i \<in> S\<close> for x i
     apply (atomize_elim, subst all_conj_distrib[symmetric])
     apply (rule choice)
     by auto
   define g where \<open>g x = lim (\<lambda>i. f (seq x i))\<close> for x
   have \<open>Cauchy (\<lambda>i. f (seq x i))\<close> for x
   proof (rule CauchyI)
     fix e :: real assume \<open>e > 0\<close>
     have \<open>Cauchy (seq x)\<close>
       using LIMSEQ_imp_Cauchy seq_lim by blast
     then obtain M where less_eB: \<open>norm (seq x m - seq x n) < e/B\<close> if \<open>n \<ge> M\<close> and \<open>m \<ge> M\<close> for n m
       apply atomize_elim by (meson CauchyD \<open>0 < B\<close> \<open>0 < e\<close> linordered_field_class.divide_pos_pos)
     have \<open>norm (f (seq x m) - f (seq x n)) < e\<close> if \<open>n \<ge> M\<close> and \<open>m \<ge> M\<close> for n m
     proof -
       have \<open>norm (f (seq x m) - f (seq x n)) = norm (f (seq x m - seq x n))\<close>
         using f_add f_scale seq_S
-        by (metis add_diff_cancel assms(1) complex_vector.subspace_diff diff_add_cancel) 
+        by (metis add_diff_cancel assms(1) complex_vector.subspace_diff diff_add_cancel)
       also have \<open>\<dots> \<le> B * norm (seq x m - seq x n)\<close>
         apply (rule bounded)
         by (simp add: assms(1) complex_vector.subspace_diff seq_S)
       also from less_eB have \<open>\<dots> < B * (e/B)\<close>
         by (meson \<open>0 < B\<close> linordered_semiring_strict_class.mult_strict_left_mono that)
       also have \<open>\<dots> \<le> e\<close>
         using \<open>0 < B\<close> by auto
       finally show ?thesis
         by -
     qed
     then show \<open>\<exists>M. \<forall>m\<ge>M. \<forall>n\<ge>M. norm (f (seq x m) - f (seq x n)) < e\<close>
       by auto
   qed
   then have f_seq_lim: \<open>(\<lambda>i. f (seq x i)) \<longlonglongrightarrow> g x\<close> for x
     by (simp add: Cauchy_convergent_iff convergent_LIMSEQ_iff g_def)
   have f_xi_lim: \<open>(\<lambda>i. f (xi i)) \<longlonglongrightarrow> g x\<close> if \<open>xi \<longlonglongrightarrow> x\<close> and \<open>\<And>i. xi i \<in> S\<close> for xi x
   proof -
     from seq_lim that
     have \<open>(\<lambda>i. B * norm (xi i - seq x i)) \<longlonglongrightarrow> 0\<close>
       by (metis (no_types) \<open>0 < B\<close> cancel_comm_monoid_add_class.diff_cancel norm_not_less_zero norm_zero tendsto_diff tendsto_norm_zero_iff tendsto_zero_mult_left_iff)
     then have \<open>(\<lambda>i. f (xi i + (-1) *\<^sub>C seq x i)) \<longlonglongrightarrow> 0\<close>
       apply (rule Lim_null_comparison[rotated])
       using bounded by (simp add: assms(1) complex_vector.subspace_diff seq_S that(2))
     then have \<open>(\<lambda>i. f (xi i) - f (seq x i)) \<longlonglongrightarrow> 0\<close>
       apply (subst (asm) f_add)
         apply (auto simp: that \<open>csubspace S\<close> complex_vector.subspace_neg seq_S)[2]
       apply (subst (asm) f_scale)
       by (auto simp: that \<open>csubspace S\<close> complex_vector.subspace_neg seq_S)
     then show \<open>(\<lambda>i. f (xi i)) \<longlonglongrightarrow> g x\<close>
       using Lim_transform f_seq_lim by fastforce
   qed
   have g_add: \<open>g (x + y) = g x + g y\<close> for x y
   proof -
     obtain xi :: \<open>nat \<Rightarrow> 'a\<close> where \<open>xi \<longlonglongrightarrow> x\<close> and \<open>xi i \<in> S\<close> for i
       using seq_S seq_lim by auto
     obtain yi :: \<open>nat \<Rightarrow> 'a\<close> where \<open>yi \<longlonglongrightarrow> y\<close> and \<open>yi i \<in> S\<close> for i
       using seq_S seq_lim by auto
     have \<open>(\<lambda>i. xi i + yi i) \<longlonglongrightarrow> x + y\<close>
       using \<open>xi \<longlonglongrightarrow> x\<close> \<open>yi \<longlonglongrightarrow> y\<close> tendsto_add by blast
     then have lim1: \<open>(\<lambda>i. f (xi i + yi i)) \<longlonglongrightarrow> g (x + y)\<close>
       by (simp add: \<open>\<And>i. xi i \<in> S\<close> \<open>\<And>i. yi i \<in> S\<close> assms(1) complex_vector.subspace_add f_xi_lim)
     have \<open>(\<lambda>i. f (xi i + yi i)) = (\<lambda>i. f (xi i) + f (yi i))\<close>
       by (simp add: \<open>\<And>i. xi i \<in> S\<close> \<open>\<And>i. yi i \<in> S\<close> f_add)
     also have \<open>\<dots> \<longlonglongrightarrow> g x + g y\<close>
       by (simp add: \<open>\<And>i. xi i \<in> S\<close> \<open>\<And>i. yi i \<in> S\<close> \<open>xi \<longlonglongrightarrow> x\<close> \<open>yi \<longlonglongrightarrow> y\<close> f_xi_lim tendsto_add)
     finally show ?thesis
       using lim1 LIMSEQ_unique by blast
   qed
   have g_scale: \<open>g (c *\<^sub>C x) = c *\<^sub>C g x\<close> for c x
   proof -
     obtain xi :: \<open>nat \<Rightarrow> 'a\<close> where \<open>xi \<longlonglongrightarrow> x\<close> and \<open>xi i \<in> S\<close> for i
       using seq_S seq_lim by auto
     have \<open>(\<lambda>i. c *\<^sub>C xi i) \<longlonglongrightarrow> c *\<^sub>C x\<close>
       using \<open>xi \<longlonglongrightarrow> x\<close> bounded_clinear_scaleC_right clinear_continuous_at isCont_tendsto_compose by blast
     then have lim1: \<open>(\<lambda>i. f (c *\<^sub>C xi i)) \<longlonglongrightarrow> g (c *\<^sub>C x)\<close>
       by (simp add: \<open>\<And>i. xi i \<in> S\<close> assms(1) complex_vector.subspace_scale f_xi_lim)
     have \<open>(\<lambda>i. f (c *\<^sub>C xi i)) = (\<lambda>i. c *\<^sub>C f (xi i))\<close>
       by (simp add: \<open>\<And>i. xi i \<in> S\<close> f_scale)
     also have \<open>\<dots> \<longlonglongrightarrow> c *\<^sub>C g x\<close>
       using \<open>\<And>i. xi i \<in> S\<close> \<open>xi \<longlonglongrightarrow> x\<close> bounded_clinear_scaleC_right clinear_continuous_at f_xi_lim isCont_tendsto_compose by blast
     finally show ?thesis
       using lim1 LIMSEQ_unique by blast
   qed
 
   have [simp]: \<open>f x = g x\<close> if \<open>x \<in> S\<close> for x
   proof -
     have \<open>(\<lambda>_. x) \<longlonglongrightarrow> x\<close>
       by auto
     then have \<open>(\<lambda>_. f x) \<longlonglongrightarrow> g x\<close>
       using that by (rule f_xi_lim)
     then show \<open>f x = g x\<close>
       by (simp add: LIMSEQ_const_iff)
   qed
 
   have g_bounded: \<open>norm (g x) \<le> B * norm x\<close> for x
   proof -
     obtain xi :: \<open>nat \<Rightarrow> 'a\<close> where \<open>xi \<longlonglongrightarrow> x\<close> and \<open>xi i \<in> S\<close> for i
       using seq_S seq_lim by auto
     then have \<open>(\<lambda>i. f (xi i)) \<longlonglongrightarrow> g x\<close>
       using f_xi_lim by presburger
     then have \<open>(\<lambda>i. norm (f (xi i))) \<longlonglongrightarrow> norm (g x)\<close>
       by (metis tendsto_norm)
     moreover have \<open>(\<lambda>i. B * norm (xi i)) \<longlonglongrightarrow> B * norm x\<close>
       by (simp add: \<open>xi \<longlonglongrightarrow> x\<close> tendsto_mult_left tendsto_norm)
     ultimately show \<open>norm (g x) \<le> B * norm x\<close>
       apply (rule lim_mono[rotated])
-      using bounded using \<open>xi _ \<in> S\<close> by blast 
+      using bounded using \<open>xi _ \<in> S\<close> by blast
   qed
 
   have \<open>bounded_clinear g\<close>
     using g_add g_scale apply (rule bounded_clinearI[where K=B])
     using g_bounded by (simp add: ordered_field_class.sign_simps(5))
   then have [simp]: \<open>CBlinfun g *\<^sub>V x = g x\<close> for x
     by (subst CBlinfun_inverse, auto)
 
   show \<open>cblinfun_extension_exists S f\<close>
     apply (rule cblinfun_extension_existsI[where B=\<open>CBlinfun g\<close>])
     by auto
 qed
 
 lemma cblinfun_extension_apply:
   assumes "cblinfun_extension_exists S f"
     and "v \<in> S"
   shows "(cblinfun_extension S f) *\<^sub>V v = f v"
   by (smt assms cblinfun_extension_def cblinfun_extension_exists_def tfl_some)
 
 subsection \<open>Notation\<close>
 
 bundle cblinfun_notation begin
 notation cblinfun_compose (infixl "o\<^sub>C\<^sub>L" 55)
 notation cblinfun_apply (infixr "*\<^sub>V" 70)
 notation cblinfun_image (infixr "*\<^sub>S" 70)
 notation adj ("_*" [99] 100)
 end
 
 bundle no_cblinfun_notation begin
 no_notation cblinfun_compose (infixl "o\<^sub>C\<^sub>L" 55)
 no_notation cblinfun_apply (infixr "*\<^sub>V" 70)
 no_notation cblinfun_image (infixr "*\<^sub>S" 70)
 no_notation adj ("_*" [99] 100)
 end
 
 bundle blinfun_notation begin
 notation blinfun_apply (infixr "*\<^sub>V" 70)
 end
 
 bundle no_blinfun_notation begin
 no_notation blinfun_apply (infixr "*\<^sub>V" 70)
 end
 
 unbundle no_cblinfun_notation
 
 end
diff --git a/thys/Complex_Bounded_Operators/Complex_Inner_Product.thy b/thys/Complex_Bounded_Operators/Complex_Inner_Product.thy
--- a/thys/Complex_Bounded_Operators/Complex_Inner_Product.thy
+++ b/thys/Complex_Bounded_Operators/Complex_Inner_Product.thy
@@ -1,2230 +1,2230 @@
 (*
 Authors:
 
   Dominique Unruh, University of Tartu, unruh@ut.ee
   Jose Manuel Rodriguez Caballero, University of Tartu, jose.manuel.rodriguez.caballero@ut.ee
 
 *)
 
 section \<open>\<open>Complex_Inner_Product\<close> -- Complex Inner Product Spaces\<close>
 
 theory Complex_Inner_Product
-  imports 
+  imports
     Complex_Vector_Spaces
-    "HOL-Analysis.Infinite_Set_Sum" 
+    "HOL-Analysis.Infinite_Set_Sum"
 
     Complex_Inner_Product0
 begin
 
 subsection \<open>Complex inner product spaces\<close>
 
 bundle cinner_bracket_notation begin
 notation cinner ("\<langle>_, _\<rangle>")
 end
 unbundle cinner_bracket_notation
 
 bundle no_cinner_bracket_notation begin
 no_notation cinner ("\<langle>_, _\<rangle>")
 end
 
 lemma cinner_real: "cinner x x \<in> \<real>"
   by (meson cinner_ge_zero reals_zero_comparable_iff)
 
 lemmas cinner_commute' [simp] = cinner_commute[symmetric]
 
 lemma (in complex_inner) cinner_eq_flip: \<open>(cinner x y = cinner z w) \<longleftrightarrow> (cinner y x = cinner w z)\<close>
   by (metis cinner_commute)
 
 lemma Im_cinner_x_x[simp]: "Im \<langle>x , x\<rangle> = 0"
   using comp_Im_same[OF cinner_ge_zero] by simp
 
 
 lemma of_complex_inner_1' [simp]:
   "cinner (1 :: 'a :: {complex_inner, complex_normed_algebra_1}) (of_complex x) = x"
   by (metis cinner_commute complex_cnj_cnj of_complex_inner_1)
 
 
 class chilbert_space =  complex_inner + complete_space
 begin
 subclass cbanach by standard
 end
 
 instantiation complex :: "chilbert_space" begin
 instance ..
 end
 
 subsection \<open>Misc facts\<close>
 
 text \<open>This is a useful rule for establishing the equality of vectors\<close>
 lemma cinner_extensionality:
   assumes \<open>\<And>\<gamma>. \<langle>\<gamma>, \<psi>\<rangle> = \<langle>\<gamma>, \<phi>\<rangle>\<close>
   shows \<open>\<psi> = \<phi>\<close>
   by (metis assms cinner_eq_zero_iff cinner_simps(3) right_minus_eq)
 
 lemma polar_identity:
   includes notation_norm
   shows \<open>\<parallel>x + y\<parallel>^2 = \<parallel>x\<parallel>^2 + \<parallel>y\<parallel>^2 + 2*Re \<langle>x, y\<rangle>\<close>
     \<comment> \<open>Shown in the proof of Corollary 1.5 in @{cite conway2013course}\<close>
 proof -
   have \<open>\<langle>x , y\<rangle> + \<langle>y , x\<rangle> = \<langle>x , y\<rangle> + cnj \<langle>x , y\<rangle>\<close>
     by simp
   hence \<open>\<langle>x , y\<rangle> + \<langle>y , x\<rangle> = 2 * Re \<langle>x , y\<rangle> \<close>
     using complex_add_cnj by presburger
   have \<open>\<parallel>x + y\<parallel>^2 = \<langle>x+y, x+y\<rangle>\<close>
-    by (simp add: cdot_square_norm) 
+    by (simp add: cdot_square_norm)
   hence \<open>\<parallel>x + y\<parallel>^2 = \<langle>x , x\<rangle> + \<langle>x , y\<rangle> + \<langle>y , x\<rangle> + \<langle>y , y\<rangle>\<close>
     by (simp add: cinner_add_left cinner_add_right)
   thus ?thesis using  \<open>\<langle>x , y\<rangle> + \<langle>y , x\<rangle> = 2 * Re \<langle>x , y\<rangle>\<close>
     by (smt (verit, ccfv_SIG) Re_complex_of_real plus_complex.simps(1) power2_norm_eq_cinner')
 qed
 
 lemma polar_identity_minus:
-  includes notation_norm 
+  includes notation_norm
   shows \<open>\<parallel>x - y\<parallel>^2 = \<parallel>x\<parallel>^2 + \<parallel>y\<parallel>^2 - 2 * Re \<langle>x, y\<rangle>\<close>
 proof-
   have \<open>\<parallel>x + (-y)\<parallel>^2 = \<parallel>x\<parallel>^2 + \<parallel>-y\<parallel>^2 + 2 * Re \<langle>x , (-y)\<rangle>\<close>
     using polar_identity by blast
   hence \<open>\<parallel>x - y\<parallel>^2 = \<parallel>x\<parallel>^2 + \<parallel>y\<parallel>^2 - 2*Re \<langle>x , y\<rangle>\<close>
     by simp
-  thus ?thesis 
+  thus ?thesis
     by blast
 qed
 
 proposition parallelogram_law:
   includes notation_norm
   fixes x y :: "'a::complex_inner"
   shows \<open>\<parallel>x+y\<parallel>^2 + \<parallel>x-y\<parallel>^2 = 2*( \<parallel>x\<parallel>^2 + \<parallel>y\<parallel>^2 )\<close>
-    \<comment> \<open>Shown in the proof of Theorem 2.3 in @{cite conway2013course}\<close> 
+    \<comment> \<open>Shown in the proof of Theorem 2.3 in @{cite conway2013course}\<close>
   by (simp add: polar_identity_minus polar_identity)
 
 
 theorem pythagorean_theorem:
   includes notation_norm
-  shows \<open>\<langle>x , y\<rangle> = 0 \<Longrightarrow> \<parallel> x + y \<parallel>^2 = \<parallel> x \<parallel>^2 + \<parallel> y \<parallel>^2\<close> 
-    \<comment> \<open>Shown in the proof of Theorem 2.2 in @{cite conway2013course}\<close> 
+  shows \<open>\<langle>x , y\<rangle> = 0 \<Longrightarrow> \<parallel> x + y \<parallel>^2 = \<parallel> x \<parallel>^2 + \<parallel> y \<parallel>^2\<close>
+    \<comment> \<open>Shown in the proof of Theorem 2.2 in @{cite conway2013course}\<close>
   by (simp add: polar_identity)
 
 lemma pythagorean_theorem_sum:
   assumes q1: "\<And>a a'. a \<in> t \<Longrightarrow> a' \<in> t \<Longrightarrow> a \<noteq> a' \<Longrightarrow> \<langle>f a, f a'\<rangle> = 0"
     and q2: "finite t"
   shows "(norm  (\<Sum>a\<in>t. f a))^2 = (\<Sum>a\<in>t.(norm (f a))^2)"
 proof (insert q1, use q2 in induction)
   case empty
   show ?case
-    by auto 
+    by auto
 next
   case (insert x F)
   have r1: "\<langle>f x, f a\<rangle> = 0"
     if "a \<in> F"
     for a
-    using that insert.hyps(2) insert.prems by auto 
+    using that insert.hyps(2) insert.prems by auto
   have "sum f F = (\<Sum>a\<in>F. f a)"
     by simp
   hence s4: "\<langle>f x, sum f F\<rangle> = \<langle>f x, (\<Sum>a\<in>F. f a)\<rangle>"
     by simp
   also have s3: "\<dots> = (\<Sum>a\<in>F. \<langle>f x, f a\<rangle>)"
     using cinner_sum_right by auto
   also have s2: "\<dots> = (\<Sum>a\<in>F. 0)"
     using r1
     by simp
   also have s1: "\<dots> = 0"
     by simp
   finally have xF_ortho: "\<langle>f x, sum f F\<rangle> = 0"
-    using s2 s3 by auto       
+    using s2 s3 by auto
   have "(norm (sum f (insert x F)))\<^sup>2 = (norm (f x + sum f F))\<^sup>2"
     by (simp add: insert.hyps(1) insert.hyps(2))
   also have "\<dots> = (norm (f x))\<^sup>2 + (norm (sum f F))\<^sup>2"
     using xF_ortho by (rule pythagorean_theorem)
   also have "\<dots> = (norm (f x))\<^sup>2 + (\<Sum>a\<in>F.(norm (f a))^2)"
     apply (subst insert.IH) using insert.prems by auto
   also have "\<dots> = (\<Sum>a\<in>insert x F.(norm (f a))^2)"
     by (simp add: insert.hyps(1) insert.hyps(2))
   finally show ?case
     by simp
 qed
 
 
 lemma Cauchy_cinner_Cauchy:
   fixes x y :: \<open>nat \<Rightarrow> 'a::complex_inner\<close>
   assumes a1: \<open>Cauchy x\<close> and a2: \<open>Cauchy y\<close>
   shows \<open>Cauchy (\<lambda> n. \<langle> x n, y n \<rangle>)\<close>
 proof-
   have \<open>bounded (range x)\<close>
     using a1
     by (simp add: Elementary_Metric_Spaces.cauchy_imp_bounded)
   hence b1: \<open>\<exists>M. \<forall>n. norm (x n) < M\<close>
-    by (meson bounded_pos_less rangeI)  
+    by (meson bounded_pos_less rangeI)
   have \<open>bounded (range y)\<close>
     using a2
     by (simp add: Elementary_Metric_Spaces.cauchy_imp_bounded)
   hence b2: \<open>\<exists> M. \<forall> n. norm (y n) < M\<close>
-    by (meson bounded_pos_less rangeI)  
+    by (meson bounded_pos_less rangeI)
   have \<open>\<exists>M. \<forall>n. norm (x n) < M \<and> norm (y n) < M\<close>
     using b1 b2
-    by (metis dual_order.strict_trans linorder_neqE_linordered_idom)  
+    by (metis dual_order.strict_trans linorder_neqE_linordered_idom)
   then obtain M where M1: \<open>\<And>n. norm (x n) < M\<close> and M2: \<open>\<And>n. norm (y n) < M\<close>
     by blast
   have M3: \<open>M > 0\<close>
-    by (smt M2 norm_not_less_zero)     
+    by (smt M2 norm_not_less_zero)
   have \<open>\<exists>N. \<forall>n \<ge> N. \<forall>m \<ge> N. norm ( (\<lambda> i. \<langle> x i, y i \<rangle>) n -  (\<lambda> i. \<langle> x i, y i \<rangle>) m ) < e\<close>
     if "e > 0" for e
   proof-
     have \<open>e / (2*M) > 0\<close>
       using M3
       by (simp add: that)
     hence \<open>\<exists>N. \<forall>n\<ge>N. \<forall>m\<ge>N. norm (x n - x m) < e / (2*M)\<close>
       using a1
-      by (simp add: Cauchy_iff) 
+      by (simp add: Cauchy_iff)
     then obtain N1 where N1_def: \<open>\<And>n m. n\<ge>N1 \<Longrightarrow> m\<ge>N1 \<Longrightarrow> norm (x n - x m) < e / (2*M)\<close>
       by blast
     have x1: \<open>\<exists>N. \<forall> n\<ge>N. \<forall> m\<ge>N. norm (y n - y m) < e / (2*M)\<close>
       using a2 \<open>e / (2*M) > 0\<close>
-      by (simp add: Cauchy_iff) 
+      by (simp add: Cauchy_iff)
     obtain N2 where N2_def: \<open>\<And>n m.  n\<ge>N2 \<Longrightarrow> m\<ge>N2 \<Longrightarrow> norm (y n - y m) < e / (2*M)\<close>
       using x1
       by blast
     define N where N_def: \<open>N = N1 + N2\<close>
     hence \<open>N \<ge> N1\<close>
       by auto
     have \<open>N \<ge> N2\<close>
       using N_def
       by auto
     have \<open>norm ( \<langle> x n, y n \<rangle> - \<langle> x m, y m \<rangle> ) < e\<close>
       if \<open>n \<ge> N\<close> and \<open>m \<ge> N\<close>
       for n m
     proof -
       have \<open>\<langle> x n, y n \<rangle> - \<langle> x m, y m \<rangle> = (\<langle> x n, y n \<rangle> - \<langle> x m, y n \<rangle>) + (\<langle> x m, y n \<rangle> - \<langle> x m, y m \<rangle>)\<close>
         by simp
       hence y1: \<open>norm (\<langle> x n, y n \<rangle> - \<langle> x m, y m \<rangle>) \<le> norm (\<langle> x n, y n \<rangle> - \<langle> x m, y n \<rangle>)
            + norm (\<langle> x m, y n \<rangle> - \<langle> x m, y m \<rangle>)\<close>
         by (metis norm_triangle_ineq)
 
       have \<open>\<langle> x n, y n \<rangle> - \<langle> x m, y n \<rangle> = \<langle> x n - x m, y n \<rangle>\<close>
         by (simp add: cinner_diff_left)
       hence \<open>norm (\<langle> x n, y n \<rangle> - \<langle> x m, y n \<rangle>) = norm \<langle> x n - x m, y n \<rangle>\<close>
         by simp
       moreover have \<open>norm \<langle> x n - x m, y n \<rangle> \<le> norm (x n - x m) * norm (y n)\<close>
         using complex_inner_class.Cauchy_Schwarz_ineq2 by blast
       moreover have \<open>norm (y n) < M\<close>
-        by (simp add: M2)        
+        by (simp add: M2)
       moreover have \<open>norm (x n - x m) < e/(2*M)\<close>
         using \<open>N \<le> m\<close> \<open>N \<le> n\<close> \<open>N1 \<le> N\<close> N1_def by auto
       ultimately have \<open>norm (\<langle> x n, y n \<rangle> - \<langle> x m, y n \<rangle>) < (e/(2*M)) * M\<close>
         by (smt linordered_semiring_strict_class.mult_strict_mono norm_ge_zero)
       moreover have \<open> (e/(2*M)) * M = e/2\<close>
         using \<open>M > 0\<close> by simp
       ultimately have  \<open>norm (\<langle> x n, y n \<rangle> - \<langle> x m, y n \<rangle>) < e/2\<close>
-        by simp      
+        by simp
       hence y2: \<open>norm (\<langle> x n, y n \<rangle> - \<langle> x m, y n \<rangle>) < e/2\<close>
-        by blast        
+        by blast
       have \<open>\<langle> x m, y n \<rangle> - \<langle> x m, y m \<rangle> = \<langle> x m, y n - y m \<rangle>\<close>
         by (simp add: cinner_diff_right)
       hence \<open>norm (\<langle> x m, y n \<rangle> - \<langle> x m, y m \<rangle>) = norm \<langle> x m, y n - y m \<rangle>\<close>
         by simp
       moreover have \<open>norm \<langle> x m, y n - y m \<rangle> \<le> norm (x m) * norm (y n - y m)\<close>
         by (meson complex_inner_class.Cauchy_Schwarz_ineq2)
       moreover have \<open>norm (x m) < M\<close>
         by (simp add: M1)
       moreover have \<open>norm (y n - y m) < e/(2*M)\<close>
-        using \<open>N \<le> m\<close> \<open>N \<le> n\<close> \<open>N2 \<le> N\<close> N2_def by auto 
+        using \<open>N \<le> m\<close> \<open>N \<le> n\<close> \<open>N2 \<le> N\<close> N2_def by auto
       ultimately have \<open>norm (\<langle> x m, y n \<rangle> - \<langle> x m, y m \<rangle>) < M * (e/(2*M))\<close>
         by (smt linordered_semiring_strict_class.mult_strict_mono norm_ge_zero)
       moreover have \<open>M * (e/(2*M)) = e/2\<close>
         using \<open>M > 0\<close> by simp
       ultimately have  \<open>norm (\<langle> x m, y n \<rangle> - \<langle> x m, y m \<rangle>) < e/2\<close>
         by simp
       hence y3: \<open>norm (\<langle> x m, y n \<rangle> - \<langle> x m, y m \<rangle>) < e/2\<close>
         by blast
       show \<open>norm ( \<langle> x n, y n \<rangle> - \<langle> x m, y m \<rangle> ) < e\<close>
         using y1 y2 y3 by simp
     qed
     thus ?thesis by blast
   qed
   thus ?thesis
     by (simp add: CauchyI)
 qed
 
 
 lemma cinner_sup_norm: \<open>norm \<psi> = (SUP \<phi>. cmod (cinner \<phi> \<psi>) / norm \<phi>)\<close>
 proof (rule sym, rule cSup_eq_maximum)
   have \<open>norm \<psi> = cmod (cinner \<psi> \<psi>) / norm \<psi>\<close>
     by (metis norm_eq_sqrt_cinner norm_ge_zero real_div_sqrt)
   then show \<open>norm \<psi> \<in> range (\<lambda>\<phi>. cmod (cinner \<phi> \<psi>) / norm \<phi>)\<close>
     by blast
 next
   fix n assume \<open>n \<in> range (\<lambda>\<phi>. cmod (cinner \<phi> \<psi>) / norm \<phi>)\<close>
   then obtain \<phi> where n\<phi>: \<open>n = cmod (cinner \<phi> \<psi>) / norm \<phi>\<close>
     by auto
   show \<open>n \<le> norm \<psi>\<close>
     unfolding n\<phi>
     by (simp add: complex_inner_class.Cauchy_Schwarz_ineq2 divide_le_eq ordered_field_class.sign_simps(33))
 qed
 
-lemma cinner_sup_onorm: 
+lemma cinner_sup_onorm:
   fixes A :: \<open>'a::{real_normed_vector,not_singleton} \<Rightarrow> 'b::complex_inner\<close>
   assumes \<open>bounded_linear A\<close>
   shows \<open>onorm A = (SUP (\<psi>,\<phi>). cmod (cinner \<psi> (A \<phi>)) / (norm \<psi> * norm \<phi>))\<close>
 proof (unfold onorm_def, rule cSup_eq_cSup)
   show \<open>bdd_above (range (\<lambda>x. norm (A x) / norm x))\<close>
     by (meson assms bdd_aboveI2 le_onorm)
 next
   fix a
   assume \<open>a \<in> range (\<lambda>\<phi>. norm (A \<phi>) / norm \<phi>)\<close>
   then obtain \<phi> where \<open>a = norm (A \<phi>) / norm \<phi>\<close>
     by auto
   then have \<open>a \<le> cmod (cinner (A \<phi>) (A \<phi>)) / (norm (A \<phi>) * norm \<phi>)\<close>
     apply auto
     by (smt (verit) divide_divide_eq_left norm_eq_sqrt_cinner norm_imp_pos_and_ge real_div_sqrt)
   then show \<open>\<exists>b\<in>range (\<lambda>(\<psi>, \<phi>). cmod (cinner \<psi> (A \<phi>)) / (norm \<psi> * norm \<phi>)). a \<le> b\<close>
     by force
 next
   fix b
   assume \<open>b \<in> range (\<lambda>(\<psi>, \<phi>). cmod (cinner \<psi> (A \<phi>)) / (norm \<psi> * norm \<phi>))\<close>
   then obtain \<psi> \<phi> where b: \<open>b = cmod (cinner \<psi> (A \<phi>)) / (norm \<psi> * norm \<phi>)\<close>
     by auto
   then have \<open>b \<le> norm (A \<phi>) / norm \<phi>\<close>
     apply auto
     by (smt (verit, ccfv_threshold) complex_inner_class.Cauchy_Schwarz_ineq2 division_ring_divide_zero linordered_field_class.divide_right_mono mult_cancel_left1 nonzero_mult_divide_mult_cancel_left2 norm_imp_pos_and_ge ordered_field_class.sign_simps(33) zero_le_divide_iff)
   then show \<open>\<exists>a\<in>range (\<lambda>x. norm (A x) / norm x). b \<le> a\<close>
     by auto
 qed
 
 
 subsection \<open>Orthogonality\<close>
 
 
-definition "orthogonal_complement S = {x| x. \<forall>y\<in>S. cinner x y = 0}" 
+definition "orthogonal_complement S = {x| x. \<forall>y\<in>S. cinner x y = 0}"
 
 lemma orthogonal_complement_orthoI:
   \<open>x \<in> orthogonal_complement M \<Longrightarrow> y \<in> M \<Longrightarrow> \<langle> x, y \<rangle> = 0\<close>
   unfolding orthogonal_complement_def by auto
 
 lemma orthogonal_complement_orthoI':
   \<open>x \<in> M \<Longrightarrow> y \<in> orthogonal_complement M \<Longrightarrow> \<langle> x, y \<rangle> = 0\<close>
   by (metis cinner_commute' complex_cnj_zero orthogonal_complement_orthoI)
 
 lemma orthogonal_complementI:
   \<open>(\<And>x. x \<in> M \<Longrightarrow> \<langle> y, x \<rangle> = 0) \<Longrightarrow> y \<in> orthogonal_complement M\<close>
   unfolding orthogonal_complement_def
   by simp
 
 abbreviation is_orthogonal::\<open>'a::complex_inner \<Rightarrow> 'a \<Rightarrow> bool\<close>  where
   \<open>is_orthogonal x y \<equiv> \<langle> x, y \<rangle> = 0\<close>
 
 bundle orthogonal_notation begin
 notation is_orthogonal (infixl "\<bottom>" 69)
 end
 
 bundle no_orthogonal_notation begin
 no_notation is_orthogonal (infixl "\<bottom>" 69)
 end
 
 
 lemma is_orthogonal_sym: "is_orthogonal \<psi> \<phi> = is_orthogonal \<phi> \<psi>"
   by (metis cinner_commute' complex_cnj_zero)
 
-lemma orthogonal_complement_closed_subspace[simp]: 
+lemma orthogonal_complement_closed_subspace[simp]:
   "closed_csubspace (orthogonal_complement A)"
   for A :: \<open>('a::complex_inner) set\<close>
 proof (intro closed_csubspace.intro complex_vector.subspaceI)
   fix x y and c
   show \<open>0 \<in> orthogonal_complement A\<close>
     by (rule orthogonal_complementI, simp)
   show \<open>x + y \<in> orthogonal_complement A\<close>
     if \<open>x \<in> orthogonal_complement A\<close> and \<open>y \<in> orthogonal_complement A\<close>
     using that by (auto intro!: orthogonal_complementI dest!: orthogonal_complement_orthoI
         simp add: cinner_add_left)
-  show \<open>c *\<^sub>C x \<in> orthogonal_complement A\<close> if \<open>x \<in> orthogonal_complement A\<close> 
+  show \<open>c *\<^sub>C x \<in> orthogonal_complement A\<close> if \<open>x \<in> orthogonal_complement A\<close>
     using that by (auto intro!: orthogonal_complementI dest!: orthogonal_complement_orthoI)
 
   show "closed (orthogonal_complement A)"
   proof (auto simp add: closed_sequential_limits, rename_tac an a)
     fix an a
     assume ortho: \<open>\<forall>n::nat. an n \<in> orthogonal_complement A\<close>
     assume lim: \<open>an \<longlonglongrightarrow> a\<close>
 
     have \<open>\<forall> y \<in> A. \<forall> n. \<langle> y , an n \<rangle> = 0\<close>
       using orthogonal_complement_orthoI'
       by (simp add: orthogonal_complement_orthoI' ortho)
     moreover have \<open>isCont (\<lambda> x. \<langle> y , x \<rangle>) a\<close> for y
       using bounded_clinear_cinner_right clinear_continuous_at
       by (simp add: clinear_continuous_at bounded_clinear_cinner_right)
     ultimately have \<open>(\<lambda> n. (\<lambda> v. \<langle> y , v \<rangle>) (an n)) \<longlonglongrightarrow> (\<lambda> v. \<langle> y , v \<rangle>) a\<close> for y
       using isCont_tendsto_compose
       by (simp add: isCont_tendsto_compose lim)
     hence  \<open>\<forall> y\<in>A. (\<lambda> n. \<langle> y , an n \<rangle>  ) \<longlonglongrightarrow>  \<langle> y , a \<rangle>\<close>
       by simp
-    hence  \<open>\<forall> y\<in>A. (\<lambda> n. 0  ) \<longlonglongrightarrow>  \<langle> y , a \<rangle>\<close> 
-      using \<open>\<forall> y \<in> A. \<forall> n. \<langle> y , an n \<rangle> = 0\<close> 
+    hence  \<open>\<forall> y\<in>A. (\<lambda> n. 0  ) \<longlonglongrightarrow>  \<langle> y , a \<rangle>\<close>
+      using \<open>\<forall> y \<in> A. \<forall> n. \<langle> y , an n \<rangle> = 0\<close>
       by fastforce
-    hence  \<open>\<forall> y \<in> A. \<langle> y , a \<rangle> = 0\<close> 
+    hence  \<open>\<forall> y \<in> A. \<langle> y , a \<rangle> = 0\<close>
       using limI by fastforce
     then show \<open>a \<in> orthogonal_complement A\<close>
       by (simp add: orthogonal_complementI is_orthogonal_sym)
   qed
 qed
 
 lemma orthogonal_complement_zero_intersection:
   assumes "0\<in>M"
   shows \<open>M \<inter> (orthogonal_complement M) = {0}\<close>
 proof -
   have "x=0" if "x\<in>M" and "x\<in>orthogonal_complement M" for x
   proof -
     from that have "\<langle> x, x \<rangle> = 0"
       unfolding orthogonal_complement_def by auto
     thus "x=0"
       by auto
   qed
   with assms show ?thesis
     unfolding orthogonal_complement_def by auto
 qed
 
 lemma is_orthogonal_closure_cspan:
   assumes "\<And>x y. x \<in> X \<Longrightarrow> y \<in> Y \<Longrightarrow> is_orthogonal x y"
   assumes \<open>x \<in> closure (cspan X)\<close> \<open>y \<in> closure (cspan Y)\<close>
   shows "is_orthogonal x y"
 proof -
   have *: \<open>cinner x y = 0\<close> if \<open>y \<in> Y\<close> for y
     using bounded_antilinear_cinner_left apply (rule bounded_antilinear_eq_on[where G=X])
     using assms that by auto
   show \<open>cinner x y = 0\<close>
     using bounded_clinear_cinner_right apply (rule bounded_clinear_eq_on[where G=Y])
     using * assms by auto
 qed
 
 
 instantiation ccsubspace :: (complex_inner) "uminus"
 begin
 lift_definition uminus_ccsubspace::\<open>'a ccsubspace  \<Rightarrow> 'a ccsubspace\<close>
   is \<open>orthogonal_complement\<close>
   by simp
 
 instance ..
 end
 
 
 instantiation ccsubspace :: (complex_inner) minus begin
 lift_definition minus_ccsubspace :: "'a ccsubspace \<Rightarrow> 'a ccsubspace \<Rightarrow> 'a ccsubspace"
   is "\<lambda>A B. A \<inter> (orthogonal_complement B)"
   by simp
 instance..
 end
 
 
 text \<open>Orthogonal set\<close>
 definition is_ortho_set :: "'a::complex_inner set \<Rightarrow> bool" where
   \<open>is_ortho_set S = ((\<forall>x\<in>S. \<forall>y\<in>S. x \<noteq> y \<longrightarrow> \<langle>x, y\<rangle> = 0) \<and> 0 \<notin> S)\<close>
 
 lemma is_ortho_set_empty[simp]: "is_ortho_set {}"
   unfolding is_ortho_set_def by auto
 
 lemma is_ortho_set_antimono: \<open>A \<subseteq> B \<Longrightarrow> is_ortho_set B \<Longrightarrow> is_ortho_set A\<close>
   unfolding is_ortho_set_def by auto
 
 lemma orthogonal_complement_of_closure:
   fixes A ::"('a::complex_inner) set"
   shows "orthogonal_complement A = orthogonal_complement (closure A)"
 proof-
-  have s1: \<open>\<langle> y, x \<rangle> = 0\<close> 
+  have s1: \<open>\<langle> y, x \<rangle> = 0\<close>
     if a1: "x \<in> (orthogonal_complement A)"
-      and a2: \<open>y \<in> closure A\<close>  
+      and a2: \<open>y \<in> closure A\<close>
     for x y
   proof-
     have \<open>\<forall> y \<in> A. \<langle> y , x \<rangle> = 0\<close>
       by (simp add: a1 orthogonal_complement_orthoI')
     then obtain yy where \<open>\<forall> n. yy n \<in> A\<close> and \<open>yy \<longlonglongrightarrow> y\<close>
       using a2 closure_sequential by blast
     have \<open>isCont (\<lambda> t. \<langle> t , x \<rangle>) y\<close>
       by simp
     hence \<open>(\<lambda> n. \<langle> yy n , x \<rangle>) \<longlonglongrightarrow>  \<langle> y , x \<rangle>\<close>
       using \<open>yy \<longlonglongrightarrow> y\<close> isCont_tendsto_compose
       by fastforce
     hence \<open>(\<lambda> n. 0) \<longlonglongrightarrow>  \<langle> y , x \<rangle>\<close>
       using \<open>\<forall> y \<in> A. \<langle> y , x \<rangle> = 0\<close>  \<open>\<forall> n. yy n \<in> A\<close> by simp
-    thus ?thesis 
+    thus ?thesis
       using limI by force
   qed
   hence "x \<in> orthogonal_complement (closure A)"
     if a1: "x \<in> (orthogonal_complement A)"
     for x
     using that
     by (meson orthogonal_complementI is_orthogonal_sym)
-  moreover have \<open>x \<in> (orthogonal_complement A)\<close> 
+  moreover have \<open>x \<in> (orthogonal_complement A)\<close>
     if "x \<in> (orthogonal_complement (closure A))"
     for x
     using that
     by (meson closure_subset orthogonal_complement_orthoI orthogonal_complementI subset_eq)
   ultimately show ?thesis by blast
 qed
 
 
-lemma is_orthogonal_closure: 
+lemma is_orthogonal_closure:
   assumes \<open>\<And>s. s \<in> S \<Longrightarrow> is_orthogonal a  s\<close>
-  assumes \<open>x \<in> closure S\<close> 
+  assumes \<open>x \<in> closure S\<close>
   shows \<open>is_orthogonal a x\<close>
   by (metis assms(1) assms(2) orthogonal_complementI orthogonal_complement_of_closure orthogonal_complement_orthoI)
 
 
 lemma is_orthogonal_cspan:
   assumes a1: "\<And>s. s \<in> S \<Longrightarrow> is_orthogonal a s" and a3: "x \<in> cspan S"
   shows "\<langle>a, x\<rangle> = 0"
 proof-
   have "\<exists>t r. finite t \<and> t \<subseteq> S \<and> (\<Sum>a\<in>t. r a *\<^sub>C a) = x"
     using complex_vector.span_explicit
     by (smt a3 mem_Collect_eq)
   then obtain t r where b1: "finite t" and b2: "t \<subseteq> S" and b3: "(\<Sum>a\<in>t. r a *\<^sub>C a) = x"
     by blast
   have x1: "\<langle>a, i\<rangle> = 0"
     if "i\<in>t" for i
     using b2 a1 that by blast
   have  "\<langle>a, x\<rangle> = \<langle>a, (\<Sum>i\<in>t. r i *\<^sub>C i)\<rangle>"
-    by (simp add: b3) 
+    by (simp add: b3)
   also have  "\<dots> = (\<Sum>i\<in>t. r i *\<^sub>C \<langle>a, i\<rangle>)"
     by (simp add: cinner_sum_right)
   also have  "\<dots> = 0"
     using x1 by simp
   finally show ?thesis.
 qed
 
 lemma ccspan_leq_ortho_ccspan:
   assumes "\<And>s t. s\<in>S \<Longrightarrow> t\<in>T \<Longrightarrow> is_orthogonal s t"
   shows "ccspan S \<le> - (ccspan T)"
   using assms apply transfer
-  by (smt (verit, ccfv_threshold) is_orthogonal_closure is_orthogonal_cspan is_orthogonal_sym orthogonal_complementI subsetI) 
+  by (smt (verit, ccfv_threshold) is_orthogonal_closure is_orthogonal_cspan is_orthogonal_sym orthogonal_complementI subsetI)
 
 lemma double_orthogonal_complement_increasing[simp]:
   shows "M \<subseteq> orthogonal_complement (orthogonal_complement M)"
 proof (rule subsetI)
   fix x assume s1: "x \<in> M"
   have \<open>\<forall> y \<in> (orthogonal_complement M). \<langle> x, y \<rangle> = 0\<close>
     using s1 orthogonal_complement_orthoI' by auto
   hence \<open>x \<in> orthogonal_complement (orthogonal_complement M)\<close>
     by (simp add: orthogonal_complement_def)
   then show "x \<in> orthogonal_complement (orthogonal_complement M)"
     by blast
 qed
 
 
 lemma orthonormal_basis_of_cspan:
   fixes S::"'a::complex_inner set"
   assumes "finite S"
   shows "\<exists>A. is_ortho_set A \<and> (\<forall>x\<in>A. norm x = 1) \<and> cspan A = cspan S \<and> finite A"
 proof (use assms in induction)
   case empty
   show ?case
     apply (rule exI[of _ "{}"])
     by auto
 next
   case (insert s S)
   from insert.IH
   obtain A where orthoA: "is_ortho_set A" and normA: "\<And>x. x\<in>A \<Longrightarrow> norm x = 1" and spanA: "cspan A = cspan S" and finiteA: "finite A"
     by auto
   show ?case
   proof (cases \<open>s \<in> cspan S\<close>)
     case True
     then have \<open>cspan (insert s S) = cspan S\<close>
       by (simp add: complex_vector.span_redundant)
     with orthoA normA spanA finiteA
     show ?thesis
       by auto
   next
     case False
     obtain a where a_ortho: \<open>\<And>x. x\<in>A \<Longrightarrow> is_orthogonal x a\<close> and sa_span: \<open>s - a \<in> cspan A\<close>
     proof (atomize_elim, use \<open>finite A\<close> \<open>is_ortho_set A\<close> in induction)
       case empty
       then show ?case
         by auto
     next
       case (insert x A)
       then obtain a where orthoA: \<open>\<And>x. x \<in> A \<Longrightarrow> is_orthogonal x a\<close> and sa: \<open>s - a \<in> cspan A\<close>
         by (meson is_ortho_set_antimono subset_insertI)
       define a' where \<open>a' = a - cinner x a *\<^sub>C inverse (cinner x x) *\<^sub>C x\<close>
       have \<open>is_orthogonal x a'\<close>
         unfolding a'_def cinner_diff_right cinner_scaleC_right
         apply (cases \<open>cinner x x = 0\<close>)
         by auto
       have orthoA: \<open>is_orthogonal y a'\<close> if \<open>y \<in> A\<close> for y
         unfolding a'_def cinner_diff_right cinner_scaleC_right
         apply auto by (metis insert.prems insertCI is_ortho_set_def mult_not_zero orthoA that)
       have \<open>s - a' \<in> cspan (insert x A)\<close>
         unfolding a'_def apply auto
         by (metis (no_types, lifting) complex_vector.span_breakdown_eq diff_add_cancel diff_diff_add sa)
       with \<open>is_orthogonal x a'\<close> orthoA
       show ?case
         apply (rule_tac exI[of _ a'])
         by auto
     qed
 
     from False sa_span
     have \<open>a \<noteq> 0\<close>
       unfolding spanA by auto
     define a' where \<open>a' = inverse (norm a) *\<^sub>C a\<close>
     with \<open>a \<noteq> 0\<close> have \<open>norm a' = 1\<close>
       by (simp add: norm_inverse)
     have a: \<open>a = norm a *\<^sub>C a'\<close>
       by (simp add: \<open>a \<noteq> 0\<close> a'_def)
 
     from sa_span spanA
     have a'_span: \<open>a' \<in> cspan (insert s S)\<close>
       unfolding a'_def
       by (metis complex_vector.eq_span_insert_eq complex_vector.span_scale complex_vector.span_superset in_mono insertI1)
     from sa_span
     have s_span: \<open>s \<in> cspan (insert a' A)\<close>
       apply (subst (asm) a)
       using complex_vector.span_breakdown_eq by blast
 
     from \<open>a \<noteq> 0\<close> a_ortho orthoA
     have ortho: "is_ortho_set (insert a' A)"
       unfolding is_ortho_set_def a'_def
       apply auto
       by (meson is_orthogonal_sym)
 
     have span: \<open>cspan (insert a' A) = cspan (insert s S)\<close>
       using a'_span s_span spanA apply auto
        apply (metis (full_types) complex_vector.span_breakdown_eq complex_vector.span_redundant insert_commute s_span)
       by (metis (full_types) complex_vector.span_breakdown_eq complex_vector.span_redundant insert_commute s_span)
 
     show ?thesis
       apply (rule exI[of _ \<open>insert a' A\<close>])
       by (simp add: ortho \<open>norm a' = 1\<close> normA finiteA span)
   qed
 qed
 
 lemma is_ortho_set_cindependent:
-  assumes "is_ortho_set A" 
+  assumes "is_ortho_set A"
   shows "cindependent A"
 proof -
   have "u v = 0"
     if b1: "finite t" and b2: "t \<subseteq> A" and b3: "(\<Sum>v\<in>t. u v *\<^sub>C v) = 0" and b4: "v \<in> t"
     for t u v
   proof -
     have "\<langle>v, v'\<rangle> = 0" if c1: "v'\<in>t-{v}" for v'
       by (metis DiffE assms b2 b4 insertI1 is_ortho_set_antimono is_ortho_set_def that)
     hence sum0: "(\<Sum>v'\<in>t-{v}. u v' * \<langle>v, v'\<rangle>) = 0"
       by simp
     have "\<langle>v, (\<Sum>v'\<in>t. u v' *\<^sub>C v')\<rangle> = (\<Sum>v'\<in>t. u v' * \<langle>v, v'\<rangle>)"
       using b1
-      by (metis (mono_tags, lifting) cinner_scaleC_right cinner_sum_right sum.cong) 
+      by (metis (mono_tags, lifting) cinner_scaleC_right cinner_sum_right sum.cong)
     also have "\<dots> = u v * \<langle>v, v\<rangle> + (\<Sum>v'\<in>t-{v}. u v' * \<langle>v, v'\<rangle>)"
       by (meson b1 b4 sum.remove)
     also have "\<dots> = u v * \<langle>v, v\<rangle>"
       using sum0 by simp
     finally have "\<langle>v, (\<Sum>v'\<in>t. u v' *\<^sub>C v')\<rangle> =  u v * \<langle>v, v\<rangle>"
       by blast
     hence "u v * \<langle>v, v\<rangle> = 0" using b3 by simp
     moreover have "\<langle>v, v\<rangle> \<noteq> 0"
-      using assms is_ortho_set_def b2 b4 by auto    
+      using assms is_ortho_set_def b2 b4 by auto
     ultimately show "u v = 0" by simp
   qed
   thus ?thesis using complex_vector.independent_explicit_module
     by (smt cdependent_raw_def)
 qed
 
 
 lemma onb_expansion_finite:
   includes notation_norm
   fixes T::\<open>'a::{complex_inner,cfinite_dim} set\<close>
   assumes a1: \<open>cspan T = UNIV\<close> and a3: \<open>is_ortho_set T\<close>
     and a4: \<open>\<And>t. t\<in>T \<Longrightarrow> \<parallel>t\<parallel> = 1\<close>
   shows \<open>x = (\<Sum>t\<in>T. \<langle> t, x \<rangle> *\<^sub>C t)\<close>
 proof -
   have \<open>finite T\<close>
     apply (rule cindependent_cfinite_dim_finite)
     by (simp add: a3 is_ortho_set_cindependent)
   have \<open>closure (complex_vector.span T)  = complex_vector.span T\<close>
     by (simp add: a1)
   have \<open>{\<Sum>a\<in>t. r a *\<^sub>C a |t r. finite t \<and> t \<subseteq> T} = {\<Sum>a\<in>T. r a *\<^sub>C a |r. True}\<close>
     apply auto
      apply (rule_tac x=\<open>\<lambda>a. if a \<in> t then r a else 0\<close> in exI)
      apply (simp add: \<open>finite T\<close> sum.mono_neutral_cong_right)
     using \<open>finite T\<close> by blast
 
   have f1: "\<forall>A. {a. \<exists>Aa f. (a::'a) = (\<Sum>a\<in>Aa. f a *\<^sub>C a) \<and> finite Aa \<and> Aa \<subseteq> A} = cspan A"
-    by (simp add: complex_vector.span_explicit)      
+    by (simp add: complex_vector.span_explicit)
   have f2: "\<forall>a. (\<exists>f. a = (\<Sum>a\<in>T. f a *\<^sub>C a)) \<or> (\<forall>A. (\<forall>f. a \<noteq> (\<Sum>a\<in>A. f a *\<^sub>C a)) \<or> infinite A \<or> \<not> A \<subseteq> T)"
     using \<open>{\<Sum>a\<in>t. r a *\<^sub>C a |t r. finite t \<and> t \<subseteq> T} = {\<Sum>a\<in>T. r a *\<^sub>C a |r. True}\<close> by auto
   have f3: "\<forall>A a. (\<exists>Aa f. (a::'a) = (\<Sum>a\<in>Aa. f a *\<^sub>C a) \<and> finite Aa \<and> Aa \<subseteq> A) \<or> a \<notin> cspan A"
     using f1 by blast
   have "cspan T = UNIV"
     by (metis (full_types, lifting)  \<open>complex_vector.span T = UNIV\<close>)
   hence \<open>\<exists> r. x = (\<Sum> a\<in>T. r a *\<^sub>C a)\<close>
     using f3 f2 by blast
   then obtain r where \<open>x = (\<Sum> a\<in>T. r a *\<^sub>C a)\<close>
     by blast
 
   have \<open>r a = \<langle>a, x\<rangle>\<close> if \<open>a \<in> T\<close> for a
   proof-
     have \<open>norm a = 1\<close>
       using a4
       by (simp add: \<open>a \<in> T\<close>)
     moreover have \<open>norm a = sqrt (norm \<langle>a, a\<rangle>)\<close>
-      using norm_eq_sqrt_cinner by auto        
+      using norm_eq_sqrt_cinner by auto
     ultimately have \<open>sqrt (norm \<langle>a, a\<rangle>) = 1\<close>
       by simp
     hence \<open>norm \<langle>a, a\<rangle> = 1\<close>
       using real_sqrt_eq_1_iff by blast
     moreover have \<open>\<langle>a, a\<rangle> \<in> \<real>\<close>
-      by (simp add: cinner_real)        
+      by (simp add: cinner_real)
     moreover have \<open>\<langle>a, a\<rangle> \<ge> 0\<close>
       using cinner_ge_zero by blast
     ultimately have w1: \<open>\<langle>a, a\<rangle> = 1\<close>
       by (metis \<open>0 \<le> \<langle>a, a\<rangle>\<close> \<open>cmod \<langle>a, a\<rangle> = 1\<close> complex_of_real_cmod of_real_1)
 
     have \<open>r t * \<langle>a, t\<rangle> = 0\<close> if \<open>t \<in> T-{a}\<close> for t
       by (metis DiffD1 DiffD2 \<open>a \<in> T\<close> a3 is_ortho_set_def mult_eq_0_iff singletonI that)
     hence s1: \<open>(\<Sum> t\<in>T-{a}. r t * \<langle>a, t\<rangle>) = 0\<close>
-      by (simp add: \<open>\<And>t. t \<in> T - {a} \<Longrightarrow> r t * \<langle>a, t\<rangle> = 0\<close>) 
+      by (simp add: \<open>\<And>t. t \<in> T - {a} \<Longrightarrow> r t * \<langle>a, t\<rangle> = 0\<close>)
     have \<open>\<langle>a, x\<rangle> = \<langle>a, (\<Sum> t\<in>T. r t *\<^sub>C t)\<rangle>\<close>
       using \<open>x = (\<Sum> a\<in>T. r a *\<^sub>C a)\<close>
       by simp
     also have \<open>\<dots> = (\<Sum> t\<in>T. \<langle>a, r t *\<^sub>C t\<rangle>)\<close>
       using cinner_sum_right by blast
     also have \<open>\<dots> = (\<Sum> t\<in>T. r t * \<langle>a, t\<rangle>)\<close>
-      by simp    
+      by simp
     also have \<open>\<dots> = r a * \<langle>a, a\<rangle> + (\<Sum> t\<in>T-{a}. r t * \<langle>a, t\<rangle>)\<close>
       using \<open>a \<in> T\<close>
       by (meson \<open>finite T\<close> sum.remove)
     also have \<open>\<dots> = r a * \<langle>a, a\<rangle>\<close>
       using s1
       by simp
     also have \<open>\<dots> = r a\<close>
       by (simp add: w1)
     finally show ?thesis by auto
   qed
-  thus ?thesis 
+  thus ?thesis
     using \<open>x = (\<Sum> a\<in>T. r a *\<^sub>C a)\<close>
-    by fastforce 
+    by fastforce
 qed
 
 subsection \<open>Projections\<close>
 
 lemma smallest_norm_exists:
   \<comment> \<open>Theorem 2.5 in @{cite conway2013course} (inside the proof)\<close>
   includes notation_norm
   fixes M :: \<open>'a::chilbert_space set\<close>
   assumes q1: \<open>convex M\<close> and q2: \<open>closed M\<close> and q3: \<open>M \<noteq> {}\<close>
   shows  \<open>\<exists>k. is_arg_min (\<lambda> x. \<parallel>x\<parallel>) (\<lambda> t. t \<in> M) k\<close>
 proof-
-  define d where \<open>d = Inf { \<parallel>x\<parallel>^2 | x. x \<in> M }\<close>    
+  define d where \<open>d = Inf { \<parallel>x\<parallel>^2 | x. x \<in> M }\<close>
   have w4: \<open>{ \<parallel>x\<parallel>^2 | x. x \<in> M } \<noteq> {}\<close>
     by (simp add: assms(3))
   have \<open>\<forall> x. \<parallel>x\<parallel>^2 \<ge> 0\<close>
     by simp
   hence bdd_below1: \<open>bdd_below { \<parallel>x\<parallel>^2 | x. x \<in> M }\<close>
-    by fastforce    
-  have \<open>d \<le> \<parallel>x\<parallel>^2\<close> 
+    by fastforce
+  have \<open>d \<le> \<parallel>x\<parallel>^2\<close>
     if a1: "x \<in> M"
     for x
   proof-
     have "\<forall>v. (\<exists>w. Re (\<langle>v , v\<rangle> ) = \<parallel>w\<parallel>\<^sup>2 \<and> w \<in> M) \<or> v \<notin> M"
       by (metis (no_types) power2_norm_eq_cinner')
     hence "Re (\<langle>x , x\<rangle> ) \<in> {\<parallel>v\<parallel>\<^sup>2 |v. v \<in> M}"
       using a1 by blast
     thus ?thesis
       unfolding d_def
       by (metis (lifting) bdd_below1 cInf_lower power2_norm_eq_cinner')
   qed
 
   have \<open>\<forall> \<epsilon> > 0. \<exists> t \<in> { \<parallel>x\<parallel>^2 | x. x \<in> M }.  t < d + \<epsilon>\<close>
     unfolding d_def
     using w4  bdd_below1
     by (meson cInf_lessD less_add_same_cancel1)
   hence \<open>\<forall> \<epsilon> > 0. \<exists> x \<in> M.  \<parallel>x\<parallel>^2 < d + \<epsilon>\<close>
-    by auto    
+    by auto
   hence \<open>\<forall> \<epsilon> > 0. \<exists> x \<in> M.  \<parallel>x\<parallel>^2 < d + \<epsilon>\<close>
     by (simp add: \<open>\<And>x. x \<in> M \<Longrightarrow> d \<le> \<parallel>x\<parallel>\<^sup>2\<close>)
   hence w1: \<open>\<forall> n::nat. \<exists> x \<in> M.  \<parallel>x\<parallel>^2 < d + 1/(n+1)\<close> by auto
 
   then obtain r::\<open>nat \<Rightarrow> 'a\<close> where w2: \<open>\<forall> n. r n \<in> M \<and>  \<parallel> r n \<parallel>^2 < d + 1/(n+1)\<close>
     by metis
-  have w3: \<open>\<forall> n. r n \<in> M\<close> 
+  have w3: \<open>\<forall> n. r n \<in> M\<close>
     by (simp add: w2)
   have \<open>\<forall> n. \<parallel> r n \<parallel>^2 < d + 1/(n+1)\<close>
-    by (simp add: w2)    
-  have w5: \<open>\<parallel> (r n) - (r m) \<parallel>^2 < 2*(1/(n+1) + 1/(m+1))\<close> 
-    for m n 
+    by (simp add: w2)
+  have w5: \<open>\<parallel> (r n) - (r m) \<parallel>^2 < 2*(1/(n+1) + 1/(m+1))\<close>
+    for m n
   proof-
     have w6: \<open>\<parallel> r n \<parallel>^2 < d + 1/(n+1)\<close>
       by (metis w2  of_nat_1 of_nat_add)
     have \<open> \<parallel> r m \<parallel>^2 < d + 1/(m+1)\<close>
       by (metis w2 of_nat_1 of_nat_add)
     have \<open>(r n) \<in> M\<close>
-      by (simp add: \<open>\<forall>n. r n \<in> M\<close>) 
-    moreover have \<open>(r m) \<in> M\<close> 
+      by (simp add: \<open>\<forall>n. r n \<in> M\<close>)
+    moreover have \<open>(r m) \<in> M\<close>
       by (simp add: \<open>\<forall>n. r n \<in> M\<close>)
     ultimately have \<open>(1/2) *\<^sub>R (r n) + (1/2) *\<^sub>R (r m) \<in> M\<close>
-      using \<open>convex M\<close> 
+      using \<open>convex M\<close>
       by (simp add: convexD)
     hence \<open>\<parallel> (1/2) *\<^sub>R (r n) + (1/2) *\<^sub>R (r m) \<parallel>^2 \<ge> d\<close>
       by (simp add: \<open>\<And>x. x \<in> M \<Longrightarrow> d \<le> \<parallel>x\<parallel>\<^sup>2\<close>)
     have \<open>\<parallel> (1/2) *\<^sub>R (r n) - (1/2) *\<^sub>R (r m) \<parallel>^2
-              = (1/2)*( \<parallel> r n \<parallel>^2 + \<parallel> r m \<parallel>^2 ) - \<parallel> (1/2) *\<^sub>R (r n) + (1/2) *\<^sub>R (r m) \<parallel>^2\<close> 
+              = (1/2)*( \<parallel> r n \<parallel>^2 + \<parallel> r m \<parallel>^2 ) - \<parallel> (1/2) *\<^sub>R (r n) + (1/2) *\<^sub>R (r m) \<parallel>^2\<close>
       by (smt (z3) div_by_1 field_sum_of_halves nonzero_mult_div_cancel_left parallelogram_law polar_identity power2_norm_eq_cinner' scaleR_collapse times_divide_eq_left)
-    also have  \<open>...  
+    also have  \<open>...
               < (1/2)*( d + 1/(n+1) + \<parallel> r m \<parallel>^2 ) - \<parallel> (1/2) *\<^sub>R (r n) + (1/2) *\<^sub>R (r m) \<parallel>^2\<close>
       using \<open>\<parallel>r n\<parallel>\<^sup>2 < d + 1 / real (n + 1)\<close> by auto
-    also have  \<open>...  
+    also have  \<open>...
               < (1/2)*( d + 1/(n+1) + d + 1/(m+1) ) - \<parallel> (1/2) *\<^sub>R (r n) + (1/2) *\<^sub>R (r m) \<parallel>^2\<close>
       using \<open>\<parallel>r m\<parallel>\<^sup>2 < d + 1 / real (m + 1)\<close> by auto
-    also have  \<open>...  
+    also have  \<open>...
               \<le> (1/2)*( d + 1/(n+1) + d + 1/(m+1) ) - d\<close>
       by (simp add: \<open>d \<le> \<parallel>(1 / 2) *\<^sub>R r n + (1 / 2) *\<^sub>R r m\<parallel>\<^sup>2\<close>)
-    also have  \<open>...  
+    also have  \<open>...
               \<le> (1/2)*( 1/(n+1) + 1/(m+1) + 2*d ) - d\<close>
       by simp
-    also have  \<open>...  
+    also have  \<open>...
               \<le> (1/2)*( 1/(n+1) + 1/(m+1) ) + (1/2)*(2*d) - d\<close>
       by (simp add: distrib_left)
-    also have  \<open>...  
+    also have  \<open>...
               \<le> (1/2)*( 1/(n+1) + 1/(m+1) ) + d - d\<close>
       by simp
-    also have  \<open>...  
+    also have  \<open>...
               \<le> (1/2)*( 1/(n+1) + 1/(m+1) )\<close>
       by simp
     finally have \<open> \<parallel>(1 / 2) *\<^sub>R r n - (1 / 2) *\<^sub>R r m\<parallel>\<^sup>2 < 1 / 2 * (1 / real (n + 1) + 1 / real (m + 1)) \<close>
       by blast
     hence \<open> \<parallel>(1 / 2) *\<^sub>R (r n - r m) \<parallel>\<^sup>2 < (1 / 2) * (1 / real (n + 1) + 1 / real (m + 1)) \<close>
-      by (simp add: real_vector.scale_right_diff_distrib)          
+      by (simp add: real_vector.scale_right_diff_distrib)
     hence \<open> ((1 / 2)*\<parallel> (r n - r m) \<parallel>)\<^sup>2 < (1 / 2) * (1 / real (n + 1) + 1 / real (m + 1)) \<close>
       by simp
     hence \<open> (1 / 2)^2*(\<parallel> (r n - r m) \<parallel>)\<^sup>2 < (1 / 2) * (1 / real (n + 1) + 1 / real (m + 1)) \<close>
       by (metis power_mult_distrib)
     hence \<open> (1 / 4) *(\<parallel> (r n - r m) \<parallel>)\<^sup>2 < (1 / 2) * (1 / real (n + 1) + 1 / real (m + 1)) \<close>
       by (simp add: power_divide)
     hence \<open> \<parallel> (r n - r m) \<parallel>\<^sup>2 < 2 * (1 / real (n + 1) + 1 / real (m + 1)) \<close>
       by simp
-    thus ?thesis 
+    thus ?thesis
       by (metis of_nat_1 of_nat_add)
   qed
   hence "\<exists> N. \<forall> n m. n \<ge> N \<and> m \<ge> N \<longrightarrow> \<parallel> (r n) - (r m) \<parallel>^2 < \<epsilon>^2"
-    if "\<epsilon> > 0" 
+    if "\<epsilon> > 0"
     for \<epsilon>
   proof-
     obtain N::nat where \<open>1/(N + 1) < \<epsilon>^2/4\<close>
       using LIMSEQ_ignore_initial_segment[OF lim_inverse_n', where k=1]
-      by (metis Suc_eq_plus1 \<open>0 < \<epsilon>\<close> nat_approx_posE zero_less_divide_iff zero_less_numeral 
+      by (metis Suc_eq_plus1 \<open>0 < \<epsilon>\<close> nat_approx_posE zero_less_divide_iff zero_less_numeral
           zero_less_power )
     hence \<open>4/(N + 1) < \<epsilon>^2\<close>
       by simp
     have "2*(1/(n+1) + 1/(m+1)) < \<epsilon>^2"
-      if f1: "n \<ge> N" and f2: "m \<ge> N" 
+      if f1: "n \<ge> N" and f2: "m \<ge> N"
       for m n::nat
     proof-
-      have \<open>1/(n+1) \<le> 1/(N+1)\<close> 
+      have \<open>1/(n+1) \<le> 1/(N+1)\<close>
         by (simp add: f1 linordered_field_class.frac_le)
-      moreover have \<open>1/(m+1) \<le> 1/(N+1)\<close> 
+      moreover have \<open>1/(m+1) \<le> 1/(N+1)\<close>
         by (simp add: f2 linordered_field_class.frac_le)
       ultimately have  \<open>2*(1/(n+1) + 1/(m+1)) \<le> 4/(N+1)\<close>
         by simp
-      thus ?thesis using \<open>4/(N + 1) < \<epsilon>^2\<close> 
+      thus ?thesis using \<open>4/(N + 1) < \<epsilon>^2\<close>
         by linarith
     qed
     hence "\<parallel> (r n) - (r m) \<parallel>^2 < \<epsilon>^2"
-      if y1: "n \<ge> N" and y2: "m \<ge> N" 
+      if y1: "n \<ge> N" and y2: "m \<ge> N"
       for m n::nat
       using that
       by (smt \<open>\<And>n m. \<parallel>r n - r m\<parallel>\<^sup>2 < 2 * (1 / (real n + 1) + 1 / (real m + 1))\<close> of_nat_1 of_nat_add)
-    thus ?thesis 
+    thus ?thesis
       by blast
   qed
   hence  \<open>\<forall> \<epsilon> > 0. \<exists> N::nat. \<forall> n m::nat. n \<ge> N \<and> m \<ge> N \<longrightarrow> \<parallel> (r n) - (r m) \<parallel>^2 < \<epsilon>^2\<close>
     by blast
   hence  \<open>\<forall> \<epsilon> > 0. \<exists> N::nat. \<forall> n m::nat. n \<ge> N \<and> m \<ge> N \<longrightarrow> \<parallel> (r n) - (r m) \<parallel> < \<epsilon>\<close>
     by (meson less_eq_real_def power_less_imp_less_base)
   hence \<open>Cauchy r\<close>
     using CauchyI by fastforce
   then obtain k where \<open>r \<longlonglongrightarrow> k\<close>
     using  convergent_eq_Cauchy by auto
   have \<open>k \<in> M\<close> using \<open>closed M\<close>
     using \<open>\<forall>n. r n \<in> M\<close> \<open>r \<longlonglongrightarrow> k\<close> closed_sequentially by auto
   have  \<open>(\<lambda> n.  \<parallel> r n \<parallel>^2) \<longlonglongrightarrow>  \<parallel> k \<parallel>^2\<close>
     by (simp add: \<open>r \<longlonglongrightarrow> k\<close> tendsto_norm tendsto_power)
   moreover  have  \<open>(\<lambda> n.  \<parallel> r n \<parallel>^2) \<longlonglongrightarrow>  d\<close>
   proof-
     have \<open>\<bar>\<parallel> r n \<parallel>^2 - d\<bar> < 1/(n+1)\<close> for n :: nat
       using \<open>\<And>x. x \<in> M \<Longrightarrow> d \<le> \<parallel>x\<parallel>\<^sup>2\<close> \<open>\<forall>n. r n \<in> M \<and> \<parallel>r n\<parallel>\<^sup>2 < d + 1 / (real n + 1)\<close> of_nat_1 of_nat_add
       by smt
-    moreover have \<open>(\<lambda>n. 1 / real (n + 1)) \<longlonglongrightarrow> 0\<close> 
-      using  LIMSEQ_ignore_initial_segment[OF lim_inverse_n', where k=1] by blast        
-    ultimately have \<open>(\<lambda> n. \<bar>\<parallel> r n \<parallel>^2 - d\<bar> ) \<longlonglongrightarrow> 0\<close> 
+    moreover have \<open>(\<lambda>n. 1 / real (n + 1)) \<longlonglongrightarrow> 0\<close>
+      using  LIMSEQ_ignore_initial_segment[OF lim_inverse_n', where k=1] by blast
+    ultimately have \<open>(\<lambda> n. \<bar>\<parallel> r n \<parallel>^2 - d\<bar> ) \<longlonglongrightarrow> 0\<close>
       by (simp add: LIMSEQ_norm_0)
-    hence \<open>(\<lambda> n. \<parallel> r n \<parallel>^2 - d ) \<longlonglongrightarrow> 0\<close> 
+    hence \<open>(\<lambda> n. \<parallel> r n \<parallel>^2 - d ) \<longlonglongrightarrow> 0\<close>
       by (simp add: tendsto_rabs_zero_iff)
     moreover have \<open>(\<lambda> n. d ) \<longlonglongrightarrow> d\<close>
       by simp
-    ultimately have \<open>(\<lambda> n. (\<parallel> r n \<parallel>^2 - d)+d ) \<longlonglongrightarrow> 0+d\<close> 
+    ultimately have \<open>(\<lambda> n. (\<parallel> r n \<parallel>^2 - d)+d ) \<longlonglongrightarrow> 0+d\<close>
       using tendsto_add by fastforce
     thus ?thesis by simp
   qed
   ultimately have \<open>d = \<parallel> k \<parallel>^2\<close>
     using LIMSEQ_unique by auto
   hence \<open>t \<in> M \<Longrightarrow> \<parallel> k \<parallel>^2 \<le> \<parallel> t \<parallel>^2\<close> for t
     using \<open>\<And>x. x \<in> M \<Longrightarrow> d \<le> \<parallel>x\<parallel>\<^sup>2\<close> by auto
-  hence q1: \<open>\<exists> k. is_arg_min (\<lambda> x. \<parallel>x\<parallel>^2) (\<lambda> t. t \<in> M) k\<close> 
+  hence q1: \<open>\<exists> k. is_arg_min (\<lambda> x. \<parallel>x\<parallel>^2) (\<lambda> t. t \<in> M) k\<close>
     using \<open>k \<in> M\<close>
       is_arg_min_def \<open>d = \<parallel>k\<parallel>\<^sup>2\<close>
     by smt
-  thus \<open>\<exists> k. is_arg_min (\<lambda> x. \<parallel>x\<parallel>) (\<lambda> t. t \<in> M) k\<close> 
+  thus \<open>\<exists> k. is_arg_min (\<lambda> x. \<parallel>x\<parallel>) (\<lambda> t. t \<in> M) k\<close>
     by (smt is_arg_min_def norm_ge_zero power2_eq_square power2_le_imp_le)
 qed
 
 
 lemma smallest_norm_unique:
   \<comment> \<open>Theorem 2.5 in @{cite conway2013course} (inside the proof)\<close>
   includes notation_norm
   fixes M :: \<open>'a::complex_inner set\<close>
   assumes q1: \<open>convex M\<close>
   assumes r: \<open>is_arg_min (\<lambda> x. \<parallel>x\<parallel>) (\<lambda> t. t \<in> M) r\<close>
   assumes s: \<open>is_arg_min (\<lambda> x. \<parallel>x\<parallel>) (\<lambda> t. t \<in> M) s\<close>
   shows \<open>r = s\<close>
 proof -
-  have \<open>r \<in> M\<close> 
+  have \<open>r \<in> M\<close>
     using \<open>is_arg_min (\<lambda>x. \<parallel>x\<parallel>) (\<lambda> t. t \<in> M) r\<close>
     by (simp add: is_arg_min_def)
-  moreover have \<open>s \<in> M\<close> 
+  moreover have \<open>s \<in> M\<close>
     using \<open>is_arg_min (\<lambda>x. \<parallel>x\<parallel>) (\<lambda> t. t \<in> M) s\<close>
     by (simp add: is_arg_min_def)
   ultimately have \<open>((1/2) *\<^sub>R r + (1/2) *\<^sub>R s) \<in> M\<close> using \<open>convex M\<close>
     by (simp add: convexD)
   hence \<open>\<parallel>r\<parallel> \<le> \<parallel> (1/2) *\<^sub>R r + (1/2) *\<^sub>R s \<parallel>\<close>
     by (metis is_arg_min_linorder r)
   hence u2: \<open>\<parallel>r\<parallel>^2 \<le> \<parallel> (1/2) *\<^sub>R r + (1/2) *\<^sub>R s \<parallel>^2\<close>
     using norm_ge_zero power_mono by blast
 
-  have \<open>\<parallel>r\<parallel> \<le> \<parallel>s\<parallel>\<close> 
+  have \<open>\<parallel>r\<parallel> \<le> \<parallel>s\<parallel>\<close>
     using r s is_arg_min_def
     by (metis is_arg_min_linorder)
   moreover have \<open>\<parallel>s\<parallel> \<le> \<parallel>r\<parallel>\<close>
     using r s is_arg_min_def
     by (metis is_arg_min_linorder)
-  ultimately have u3: \<open>\<parallel>r\<parallel> = \<parallel>s\<parallel>\<close> by simp      
+  ultimately have u3: \<open>\<parallel>r\<parallel> = \<parallel>s\<parallel>\<close> by simp
 
   have \<open>\<parallel> (1/2) *\<^sub>R r - (1/2) *\<^sub>R s \<parallel>^2 \<le> 0\<close>
     using u2 u3 parallelogram_law
     by (smt (verit, ccfv_SIG) polar_identity_minus power2_norm_eq_cinner' scaleR_add_right scaleR_half_double)
   hence \<open>\<parallel> (1/2) *\<^sub>R r - (1/2) *\<^sub>R s \<parallel>^2 = 0\<close>
     by simp
   hence \<open>\<parallel> (1/2) *\<^sub>R r - (1/2) *\<^sub>R s \<parallel> = 0\<close>
     by auto
   hence \<open>(1/2) *\<^sub>R r - (1/2) *\<^sub>R s = 0\<close>
     using norm_eq_zero by blast
   thus ?thesis by simp
 qed
 
 theorem smallest_dist_exists:
-  \<comment> \<open>Theorem 2.5 in @{cite conway2013course}\<close> 
-  fixes M::\<open>'a::chilbert_space set\<close> and h 
+  \<comment> \<open>Theorem 2.5 in @{cite conway2013course}\<close>
+  fixes M::\<open>'a::chilbert_space set\<close> and h
   assumes a1: \<open>convex M\<close> and a2: \<open>closed M\<close> and a3: \<open>M \<noteq> {}\<close>
   shows  \<open>\<exists>k. is_arg_min (\<lambda> x. dist x h) (\<lambda> x. x \<in> M) k\<close>
 proof-
   have *: "is_arg_min (\<lambda>x. dist x h) (\<lambda>x. x\<in>M) (k+h) \<longleftrightarrow> is_arg_min (\<lambda>x. norm x) (\<lambda>x. x\<in>(\<lambda>x. x-h) ` M) k" for k
     unfolding dist_norm is_arg_min_def apply auto using add_implies_diff by blast
   have \<open>\<exists>k. is_arg_min (\<lambda>x. dist x h) (\<lambda>x. x\<in>M) (k+h)\<close>
     apply (subst *)
     apply (rule smallest_norm_exists)
     using assms by (auto simp: closed_translation_subtract)
   then show \<open>\<exists>k. is_arg_min (\<lambda> x. dist x h) (\<lambda> x. x \<in> M) k\<close>
     by metis
 qed
 
 theorem smallest_dist_unique:
-  \<comment> \<open>Theorem 2.5 in @{cite conway2013course}\<close> 
-  fixes M::\<open>'a::complex_inner set\<close> and h 
+  \<comment> \<open>Theorem 2.5 in @{cite conway2013course}\<close>
+  fixes M::\<open>'a::complex_inner set\<close> and h
   assumes a1: \<open>convex M\<close>
   assumes \<open>is_arg_min (\<lambda> x. dist x h) (\<lambda> x. x \<in> M) r\<close>
   assumes \<open>is_arg_min (\<lambda> x. dist x h) (\<lambda> x. x \<in> M) s\<close>
   shows  \<open>r = s\<close>
 proof-
   have *: "is_arg_min (\<lambda>x. dist x h) (\<lambda>x. x\<in>M) k \<longleftrightarrow> is_arg_min (\<lambda>x. norm x) (\<lambda>x. x\<in>(\<lambda>x. x-h) ` M) (k-h)" for k
     unfolding dist_norm is_arg_min_def by auto
   have \<open>r - h = s - h\<close>
     using _ assms(2,3)[unfolded *] apply (rule smallest_norm_unique)
     by (simp add: a1)
   thus \<open>r = s\<close>
     by auto
 qed
 
 
 \<comment> \<open>Theorem 2.6 in @{cite conway2013course}\<close>
 theorem smallest_dist_is_ortho:
-  fixes M::\<open>'a::complex_inner set\<close> and h k::'a 
+  fixes M::\<open>'a::complex_inner set\<close> and h k::'a
   assumes b1: \<open>closed_csubspace M\<close>
-  shows  \<open>(is_arg_min (\<lambda> x. dist x h) (\<lambda> x. x \<in> M) k) \<longleftrightarrow> 
+  shows  \<open>(is_arg_min (\<lambda> x. dist x h) (\<lambda> x. x \<in> M) k) \<longleftrightarrow>
           h - k \<in> (orthogonal_complement M) \<and> k \<in> M\<close>
 proof-
   include notation_norm
   have  \<open>csubspace M\<close>
     using \<open>closed_csubspace M\<close> unfolding closed_csubspace_def by blast
   have r1: \<open>2 * Re (\<langle> h - k , f \<rangle>) \<le> \<parallel> f \<parallel>^2\<close>
     if "f \<in> M" and \<open>k \<in> M\<close> and \<open>is_arg_min (\<lambda>x. dist x h) (\<lambda> x. x \<in> M) k\<close>
     for f
   proof-
-    have \<open>k + f \<in>  M\<close> 
+    have \<open>k + f \<in>  M\<close>
       using \<open>csubspace M\<close>
       by (simp add:complex_vector.subspace_add that)
     have "\<forall>f A a b. \<not> is_arg_min f (\<lambda> x. x \<in> A) (a::'a) \<or> (f a::real) \<le> f b \<or> b \<notin> A"
       by (metis (no_types) is_arg_min_linorder)
     hence "dist k h \<le> dist (f + k) h"
       by (metis \<open>is_arg_min (\<lambda>x. dist x h) (\<lambda> x. x \<in> M) k\<close> \<open>k + f \<in> M\<close> add.commute)
     hence \<open>dist h k \<le> dist  h (k + f)\<close>
       by (simp add: add.commute dist_commute)
     hence \<open>\<parallel> h - k \<parallel> \<le> \<parallel> h - (k + f) \<parallel>\<close>
       by (simp add: dist_norm)
     hence \<open>\<parallel> h - k \<parallel>^2 \<le> \<parallel> h - (k + f) \<parallel>^2\<close>
       by (simp add: power_mono)
     also have \<open>... \<le> \<parallel> (h - k) - f \<parallel>^2\<close>
       by (simp add: diff_diff_add)
     also have \<open>... \<le> \<parallel> (h - k) \<parallel>^2 + \<parallel> f \<parallel>^2 -  2 * Re (\<langle> h - k , f \<rangle>)\<close>
       by (simp add: polar_identity_minus)
     finally have \<open>\<parallel> (h - k) \<parallel>^2 \<le> \<parallel> (h - k) \<parallel>^2 + \<parallel> f \<parallel>^2 -  2 * Re (\<langle> h - k , f \<rangle>)\<close>
       by simp
     thus ?thesis by simp
   qed
 
   have q4: \<open>\<forall> c > 0.  2 * Re (\<langle> h - k , f \<rangle>) \<le> c\<close>
     if  \<open>\<forall>c>0. 2 * Re (\<langle>h - k , f\<rangle> ) \<le> c * \<parallel>f\<parallel>\<^sup>2\<close>
     for f
   proof (cases \<open>\<parallel> f \<parallel>^2 > 0\<close>)
     case True
     hence \<open>\<forall> c > 0.  2 * Re (\<langle> h - k , f \<rangle>) \<le> (c/\<parallel> f \<parallel>^2)*\<parallel> f \<parallel>^2\<close>
       using that linordered_field_class.divide_pos_pos by blast
-    thus ?thesis 
+    thus ?thesis
       using True by auto
   next
     case False
-    hence \<open>\<parallel> f \<parallel>^2 = 0\<close> 
+    hence \<open>\<parallel> f \<parallel>^2 = 0\<close>
       by simp
-    thus ?thesis 
+    thus ?thesis
       by auto
   qed
-  have q3: \<open>\<forall> c::real. c > 0 \<longrightarrow> 2 * Re (\<langle> h - k , f \<rangle>) \<le> 0\<close> 
+  have q3: \<open>\<forall> c::real. c > 0 \<longrightarrow> 2 * Re (\<langle> h - k , f \<rangle>) \<le> 0\<close>
     if a3: \<open>\<forall>f. f \<in> M \<longrightarrow> (\<forall>c>0. 2 * Re \<langle>h - k , f\<rangle> \<le> c * \<parallel>f\<parallel>\<^sup>2)\<close>
       and a2: "f \<in>  M"
       and a1: "is_arg_min (\<lambda> x. dist x h) (\<lambda> x. x \<in> M) k"
     for f
   proof-
     have \<open>\<forall> c > 0.  2 * Re (\<langle> h - k , f \<rangle>) \<le> c*\<parallel> f \<parallel>^2\<close>
-      by (simp add: that )    
-    thus ?thesis 
+      by (simp add: that )
+    thus ?thesis
       using q4 by smt
   qed
   have w2: "h - k \<in> orthogonal_complement M \<and> k \<in> M"
     if a1: "is_arg_min (\<lambda> x. dist x h) (\<lambda> x. x \<in> M) k"
   proof-
     have  \<open>k \<in> M\<close>
-      using is_arg_min_def that by fastforce    
+      using is_arg_min_def that by fastforce
     hence \<open>\<forall> f. f \<in>  M \<longrightarrow> 2 * Re (\<langle> h - k , f \<rangle>) \<le> \<parallel> f \<parallel>^2\<close>
       using r1
-      by (simp add: that) 
-    have \<open>\<forall> f. f \<in>  M \<longrightarrow> 
+      by (simp add: that)
+    have \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real.  2 * Re (\<langle> h - k , c *\<^sub>R f \<rangle>) \<le> \<parallel> c *\<^sub>R f \<parallel>^2)\<close>
       using  assms scaleR_scaleC complex_vector.subspace_def \<open>csubspace M\<close>
       by (metis \<open>\<forall>f. f \<in> M \<longrightarrow> 2 * Re \<langle>h - k, f\<rangle> \<le> \<parallel>f\<parallel>\<^sup>2\<close>)
     hence  \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c * (2 * Re (\<langle> h - k , f \<rangle>)) \<le> \<parallel> c *\<^sub>R f \<parallel>^2)\<close>
       by (metis Re_complex_of_real cinner_scaleC_right complex_add_cnj complex_cnj_complex_of_real
           complex_cnj_mult of_real_mult scaleR_scaleC semiring_normalization_rules(34))
     hence  \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c * (2 * Re (\<langle> h - k , f \<rangle>)) \<le> \<bar>c\<bar>^2*\<parallel> f \<parallel>^2)\<close>
       by (simp add: power_mult_distrib)
-    hence  \<open>\<forall> f. f \<in>  M \<longrightarrow> 
+    hence  \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c * (2 * Re (\<langle> h - k , f \<rangle>)) \<le> c^2*\<parallel> f \<parallel>^2)\<close>
       by auto
-    hence  \<open>\<forall> f. f \<in>  M \<longrightarrow> 
+    hence  \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c > 0 \<longrightarrow> c * (2 * Re (\<langle> h - k , f \<rangle>)) \<le> c^2*\<parallel> f \<parallel>^2)\<close>
       by simp
-    hence  \<open>\<forall> f. f \<in>  M \<longrightarrow> 
+    hence  \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c > 0 \<longrightarrow> c*(2 * Re (\<langle> h - k , f \<rangle>)) \<le> c*(c*\<parallel> f \<parallel>^2))\<close>
       by (simp add: power2_eq_square)
-    hence  q4: \<open>\<forall> f. f \<in>  M \<longrightarrow> 
+    hence  q4: \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c > 0 \<longrightarrow> 2 * Re (\<langle> h - k , f \<rangle>) \<le> c*\<parallel> f \<parallel>^2)\<close>
-      by simp     
+      by simp
     have  \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c > 0 \<longrightarrow> 2 * Re (\<langle> h - k , f \<rangle>) \<le> 0)\<close>
       using q3
-      by (simp add: q4 that)      
-    hence  \<open>\<forall> f. f \<in>  M \<longrightarrow> 
+      by (simp add: q4 that)
+    hence  \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c > 0 \<longrightarrow> (2 * Re (\<langle> h - k , (-1) *\<^sub>R f \<rangle>)) \<le> 0)\<close>
       using assms scaleR_scaleC complex_vector.subspace_def
       by (metis \<open>csubspace M\<close>)
     hence  \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c > 0 \<longrightarrow> -(2 * Re (\<langle> h - k , f \<rangle>)) \<le> 0)\<close>
       by simp
-    hence  \<open>\<forall> f. f \<in>  M \<longrightarrow> 
+    hence  \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c > 0 \<longrightarrow> 2 * Re (\<langle> h - k , f \<rangle>) \<ge> 0)\<close>
       by simp
-    hence \<open>\<forall> f. f \<in>  M \<longrightarrow> 
+    hence \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c > 0 \<longrightarrow> 2 * Re (\<langle> h - k , f \<rangle>) = 0)\<close>
-      using  \<open>\<forall> f. f \<in>  M \<longrightarrow> 
+      using  \<open>\<forall> f. f \<in>  M \<longrightarrow>
                 (\<forall> c::real. c > 0 \<longrightarrow> (2 * Re (\<langle> h - k , f \<rangle>)) \<le> 0)\<close>
       by fastforce
 
-    have \<open>\<forall> f. f \<in>  M \<longrightarrow> 
+    have \<open>\<forall> f. f \<in>  M \<longrightarrow>
                  ((1::real) > 0 \<longrightarrow> 2 * Re (\<langle> h - k , f \<rangle>) = 0)\<close>
       using \<open>\<forall>f. f \<in>  M \<longrightarrow> (\<forall>c>0. 2 * Re (\<langle>h - k , f\<rangle> ) = 0)\<close> by blast
     hence \<open>\<forall> f. f \<in>  M \<longrightarrow> 2 * Re (\<langle> h - k , f \<rangle>) = 0\<close>
       by simp
-    hence \<open>\<forall> f. f \<in>  M \<longrightarrow> Re (\<langle> h - k , f \<rangle>) = 0\<close> 
-      by simp     
+    hence \<open>\<forall> f. f \<in>  M \<longrightarrow> Re (\<langle> h - k , f \<rangle>) = 0\<close>
+      by simp
     have  \<open>\<forall> f. f \<in>  M \<longrightarrow> Re (\<langle> h - k , (Complex 0 (-1)) *\<^sub>C f \<rangle>) = 0\<close>
       using assms  complex_vector.subspace_def \<open>csubspace M\<close>
       by (metis \<open>\<forall>f. f \<in> M \<longrightarrow> Re \<langle>h - k, f\<rangle> = 0\<close>)
     hence  \<open>\<forall> f. f \<in>  M \<longrightarrow> Re ( (Complex 0 (-1))*(\<langle> h - k , f \<rangle>) ) = 0\<close>
       by simp
-    hence \<open>\<forall> f. f \<in>  M \<longrightarrow> Im (\<langle> h - k , f \<rangle>) = 0\<close> 
-      using Complex_eq_neg_1 Re_i_times cinner_scaleC_right complex_of_real_def by auto        
+    hence \<open>\<forall> f. f \<in>  M \<longrightarrow> Im (\<langle> h - k , f \<rangle>) = 0\<close>
+      using Complex_eq_neg_1 Re_i_times cinner_scaleC_right complex_of_real_def by auto
 
     have \<open>\<forall> f. f \<in>  M \<longrightarrow> (\<langle> h - k , f \<rangle>) = 0\<close>
       using complex_eq_iff
       by (simp add: \<open>\<forall>f. f \<in> M \<longrightarrow> Im \<langle>h - k, f\<rangle> = 0\<close> \<open>\<forall>f. f \<in> M \<longrightarrow> Re \<langle>h - k, f\<rangle> = 0\<close>)
     hence \<open>h - k \<in> orthogonal_complement M \<and> k \<in> M\<close>
-      by (simp add: \<open>k \<in> M\<close> orthogonal_complementI) 
+      by (simp add: \<open>k \<in> M\<close> orthogonal_complementI)
     have  \<open>\<forall> c. c *\<^sub>R f \<in> M\<close>
       if "f \<in> M"
       for f
       using that scaleR_scaleC  \<open>csubspace M\<close> complex_vector.subspace_def
       by (simp add: complex_vector.subspace_def scaleR_scaleC)
-    have \<open>\<langle> h - k , f \<rangle> = 0\<close> 
+    have \<open>\<langle> h - k , f \<rangle> = 0\<close>
       if "f \<in> M"
       for f
       using \<open>h - k \<in> orthogonal_complement M \<and> k \<in> M\<close> orthogonal_complement_orthoI that by auto
-    hence \<open>h - k \<in> orthogonal_complement M\<close> 
+    hence \<open>h - k \<in> orthogonal_complement M\<close>
       by (simp add: orthogonal_complement_def)
     thus ?thesis
-      using \<open>k \<in> M\<close> by auto       
+      using \<open>k \<in> M\<close> by auto
   qed
 
-  have q1: \<open>dist h k \<le> dist h f \<close> 
+  have q1: \<open>dist h k \<le> dist h f \<close>
     if "f \<in> M" and  \<open>h - k \<in> orthogonal_complement M \<and> k \<in> M\<close>
     for f
   proof-
     have \<open>\<langle> h - k,  k - f \<rangle> = 0\<close>
-      by (metis (no_types, lifting) that 
+      by (metis (no_types, lifting) that
           cinner_diff_right diff_0_right orthogonal_complement_orthoI that)
     have \<open>\<parallel> h - f \<parallel>^2 = \<parallel> (h - k) + (k - f) \<parallel>^2\<close>
       by simp
     also have \<open>... = \<parallel> h - k \<parallel>^2 + \<parallel> k - f \<parallel>^2\<close>
       using  \<open>\<langle> h - k, k - f \<rangle> = 0\<close> pythagorean_theorem by blast
     also have \<open>... \<ge> \<parallel> h - k \<parallel>^2\<close>
       by simp
     finally have \<open>\<parallel>h - k\<parallel>\<^sup>2 \<le> \<parallel>h - f\<parallel>\<^sup>2 \<close>
       by blast
     hence \<open>\<parallel>h - k\<parallel> \<le> \<parallel>h - f\<parallel>\<close>
       using norm_ge_zero power2_le_imp_le by blast
-    thus ?thesis 
+    thus ?thesis
       by (simp add: dist_norm)
   qed
 
   have  w1: "is_arg_min (\<lambda> x. dist x h) (\<lambda> x. x \<in> M) k"
     if "h - k \<in> orthogonal_complement M \<and> k \<in>  M"
   proof-
     have \<open>h - k \<in> orthogonal_complement M\<close>
       using that by blast
     have \<open>k \<in> M\<close> using \<open>h - k \<in> orthogonal_complement M \<and> k \<in>  M\<close>
-      by blast   
+      by blast
     thus ?thesis
-      by (metis (no_types, lifting) dist_commute is_arg_min_linorder q1 that) 
+      by (metis (no_types, lifting) dist_commute is_arg_min_linorder q1 that)
   qed
   show ?thesis
-    using w1 w2 by blast 
+    using w1 w2 by blast
 qed
 
 corollary orthog_proj_exists:
-  fixes M :: \<open>'a::chilbert_space set\<close> 
+  fixes M :: \<open>'a::chilbert_space set\<close>
   assumes \<open>closed_csubspace M\<close>
   shows  \<open>\<exists>k. h - k \<in> orthogonal_complement M \<and> k \<in> M\<close>
 proof-
   from  \<open>closed_csubspace M\<close>
   have \<open>M \<noteq> {}\<close>
     using closed_csubspace.subspace complex_vector.subspace_0 by blast
   have \<open>closed  M\<close>
     using  \<open>closed_csubspace M\<close>
     by (simp add: closed_csubspace.closed)
   have \<open>convex  M\<close>
     using  \<open>closed_csubspace M\<close>
     by (simp)
   have \<open>\<exists>k.  is_arg_min (\<lambda> x. dist x h) (\<lambda> x. x \<in> M) k\<close>
     by (simp add: smallest_dist_exists \<open>closed M\<close> \<open>convex M\<close> \<open>M \<noteq> {}\<close>)
   thus ?thesis
-    by (simp add: assms smallest_dist_is_ortho)  
+    by (simp add: assms smallest_dist_is_ortho)
 qed
 
 corollary orthog_proj_unique:
-  fixes M :: \<open>'a::complex_inner set\<close> 
+  fixes M :: \<open>'a::complex_inner set\<close>
   assumes \<open>closed_csubspace M\<close>
   assumes \<open>h - r \<in> orthogonal_complement M \<and> r \<in> M\<close>
   assumes \<open>h - s \<in> orthogonal_complement M \<and> s \<in> M\<close>
   shows  \<open>r = s\<close>
   using _ assms(2,3) unfolding smallest_dist_is_ortho[OF assms(1), symmetric]
   apply (rule smallest_dist_unique)
   using assms(1) by (simp)
 
 definition is_projection_on::\<open>('a \<Rightarrow> 'a) \<Rightarrow> ('a::metric_space) set \<Rightarrow> bool\<close> where
   \<open>is_projection_on \<pi> M \<longleftrightarrow> (\<forall>h. is_arg_min (\<lambda> x. dist x h) (\<lambda> x. x \<in> M) (\<pi> h))\<close>
 
 lemma is_projection_on_iff_orthog:
   \<open>closed_csubspace M \<Longrightarrow> is_projection_on \<pi> M \<longleftrightarrow> (\<forall>h. h - \<pi> h \<in> orthogonal_complement M \<and> \<pi> h \<in> M)\<close>
   by (simp add: is_projection_on_def smallest_dist_is_ortho)
 
 lemma is_projection_on_exists:
   fixes M :: \<open>'a::chilbert_space set\<close>
   assumes \<open>convex M\<close> and \<open>closed M\<close> and \<open>M \<noteq> {}\<close>
   shows "\<exists>\<pi>. is_projection_on \<pi> M"
   unfolding is_projection_on_def apply (rule choice)
   using smallest_dist_exists[OF assms] by auto
 
 lemma is_projection_on_unique:
   fixes M :: \<open>'a::complex_inner set\<close>
   assumes \<open>convex M\<close>
   assumes "is_projection_on \<pi>\<^sub>1 M"
   assumes "is_projection_on \<pi>\<^sub>2 M"
   shows "\<pi>\<^sub>1 = \<pi>\<^sub>2"
   using smallest_dist_unique[OF assms(1)] using assms(2,3)
   unfolding is_projection_on_def by blast
 
 definition projection :: \<open>'a::metric_space set \<Rightarrow> ('a \<Rightarrow> 'a)\<close> where
   \<open>projection M \<equiv> SOME \<pi>. is_projection_on \<pi> M\<close>
 
 lemma projection_is_projection_on:
   fixes M :: \<open>'a::chilbert_space set\<close>
   assumes \<open>convex M\<close> and \<open>closed M\<close> and \<open>M \<noteq> {}\<close>
   shows "is_projection_on (projection M) M"
   by (metis assms(1) assms(2) assms(3) is_projection_on_exists projection_def someI)
 
 lemma projection_is_projection_on'[simp]:
   \<comment> \<open>Common special case of @{thm projection_is_projection_on}\<close>
   fixes M :: \<open>'a::chilbert_space set\<close>
   assumes \<open>closed_csubspace M\<close>
   shows "is_projection_on (projection M) M"
   apply (rule projection_is_projection_on)
     apply (auto simp add: assms closed_csubspace.closed)
   using assms closed_csubspace.subspace complex_vector.subspace_0 by blast
 
 lemma projection_orthogonal:
   fixes M :: \<open>'a::chilbert_space set\<close>
   assumes "closed_csubspace M" and \<open>m \<in> M\<close>
   shows \<open>is_orthogonal (h - projection M h) m\<close>
   by (metis assms(1) assms(2) closed_csubspace.closed closed_csubspace.subspace csubspace_is_convex empty_iff is_projection_on_iff_orthog orthogonal_complement_orthoI projection_is_projection_on)
 
 lemma is_projection_on_in_image:
   assumes "is_projection_on \<pi> M"
   shows "\<pi> h \<in> M"
   using assms
   by (simp add: is_arg_min_def is_projection_on_def)
 
 lemma is_projection_on_image:
   assumes "is_projection_on \<pi> M"
   shows "range \<pi> = M"
   using assms
   apply (auto simp: is_projection_on_in_image)
   by (smt (verit, ccfv_threshold) dist_pos_lt dist_self is_arg_min_def is_projection_on_def rangeI)
 
 lemma projection_in_image[simp]:
   fixes M :: \<open>'a::chilbert_space set\<close>
   assumes \<open>convex M\<close> and \<open>closed M\<close> and \<open>M \<noteq> {}\<close>
   shows \<open>projection M h \<in> M\<close>
   by (simp add: assms(1) assms(2) assms(3) is_projection_on_in_image projection_is_projection_on)
 
 lemma projection_image[simp]:
   fixes M :: \<open>'a::chilbert_space set\<close>
   assumes \<open>convex M\<close> and \<open>closed M\<close> and \<open>M \<noteq> {}\<close>
   shows \<open>range (projection M) = M\<close>
   by (simp add: assms(1) assms(2) assms(3) is_projection_on_image projection_is_projection_on)
 
 lemma projection_eqI':
   fixes M :: \<open>'a::complex_inner set\<close>
   assumes \<open>convex M\<close>
   assumes \<open>is_projection_on f M\<close>
   shows \<open>projection M = f\<close>
   by (metis assms(1) assms(2) is_projection_on_unique projection_def someI_ex)
 
 lemma is_projection_on_eqI:
   fixes  M :: \<open>'a::complex_inner set\<close>
-  assumes a1: \<open>closed_csubspace M\<close> and a2: \<open>h - x \<in> orthogonal_complement M\<close> and a3: \<open>x \<in> M\<close> 
+  assumes a1: \<open>closed_csubspace M\<close> and a2: \<open>h - x \<in> orthogonal_complement M\<close> and a3: \<open>x \<in> M\<close>
     and a4: \<open>is_projection_on \<pi> M\<close>
   shows \<open>\<pi> h = x\<close>
   by (meson a1 a2 a3 a4 closed_csubspace.subspace csubspace_is_convex is_projection_on_def smallest_dist_is_ortho smallest_dist_unique)
 
 lemma projection_eqI:
   fixes  M :: \<open>('a::chilbert_space) set\<close>
   assumes  \<open>closed_csubspace M\<close> and \<open>h - x \<in> orthogonal_complement M\<close> and \<open>x \<in> M\<close>
   shows \<open>projection M h = x\<close>
   by (metis assms(1) assms(2) assms(3) is_projection_on_iff_orthog orthog_proj_exists projection_def is_projection_on_eqI tfl_some)
 
 lemma is_projection_on_fixes_image:
   fixes M :: \<open>'a::metric_space set\<close>
   assumes a1: "is_projection_on \<pi> M" and a3: "x \<in> M"
   shows "\<pi> x = x"
   by (metis a1 a3 dist_pos_lt dist_self is_arg_min_def is_projection_on_def)
 
 lemma projection_fixes_image:
   fixes M :: \<open>('a::chilbert_space) set\<close>
   assumes a1: "closed_csubspace M" and a2: "x \<in> M"
   shows "(projection M) x = x"
   using is_projection_on_fixes_image
     \<comment> \<open>Theorem 2.7 in @{cite conway2013course}\<close>
   by (simp add: a1 a2 complex_vector.subspace_0 projection_eqI)
 
 proposition is_projection_on_reduces_norm:
   includes notation_norm
   fixes M :: \<open>('a::complex_inner) set\<close>
   assumes \<open>is_projection_on \<pi> M\<close> and \<open>closed_csubspace M\<close>
   shows \<open>\<parallel> \<pi>  h \<parallel> \<le> \<parallel> h \<parallel>\<close>
 proof-
   have \<open>h - \<pi> h \<in> orthogonal_complement M\<close>
-    using assms is_projection_on_iff_orthog by blast 
+    using assms is_projection_on_iff_orthog by blast
   hence \<open>\<forall> k \<in> M. \<langle>  h - \<pi> h , k \<rangle> = 0\<close>
-    using orthogonal_complement_orthoI by blast 
+    using orthogonal_complement_orthoI by blast
   also have \<open>\<pi> h \<in>  M\<close>
     using \<open>is_projection_on \<pi> M\<close>
     by (simp add: is_projection_on_in_image)
   ultimately have \<open>\<langle>  h - \<pi> h , \<pi> h \<rangle> = 0\<close>
     by auto
   hence \<open>\<parallel> \<pi> h \<parallel>^2 + \<parallel> h - \<pi> h \<parallel>^2 = \<parallel> h \<parallel>^2\<close>
     using pythagorean_theorem by fastforce
   hence \<open>\<parallel>\<pi> h \<parallel>^2 \<le> \<parallel> h \<parallel>^2\<close>
-    by (smt zero_le_power2)    
-  thus ?thesis 
+    by (smt zero_le_power2)
+  thus ?thesis
     using norm_ge_zero power2_le_imp_le by blast
 qed
 
 proposition projection_reduces_norm:
   includes notation_norm
   fixes M :: \<open>'a::chilbert_space set\<close>
   assumes a1: "closed_csubspace M"
   shows \<open>\<parallel> projection M h \<parallel> \<le> \<parallel> h \<parallel>\<close>
   using assms is_projection_on_iff_orthog orthog_proj_exists is_projection_on_reduces_norm projection_eqI by blast
 
 \<comment> \<open>Theorem 2.7 (version) in @{cite conway2013course}\<close>
 theorem is_projection_on_bounded_clinear:
   fixes M :: \<open>'a::complex_inner set\<close>
   assumes a1: "is_projection_on \<pi> M" and a2: "closed_csubspace M"
   shows "bounded_clinear \<pi>"
 proof
   have b1:  \<open>csubspace (orthogonal_complement M)\<close>
     by (simp add: a2)
   have f1: "\<forall>a. a - \<pi> a \<in> orthogonal_complement M \<and> \<pi> a \<in> M"
     using a1 a2 is_projection_on_iff_orthog by blast
   hence "c *\<^sub>C x - c *\<^sub>C \<pi> x \<in> orthogonal_complement M"
     for c x
-    by (metis (no_types) b1 
+    by (metis (no_types) b1
         add_diff_cancel_right' complex_vector.subspace_def diff_add_cancel scaleC_add_right)
   thus r1: \<open>\<pi> (c *\<^sub>C x) = c *\<^sub>C (\<pi> x)\<close> for x c
-    using f1 by (meson a2 a1 closed_csubspace.subspace 
+    using f1 by (meson a2 a1 closed_csubspace.subspace
         complex_vector.subspace_def is_projection_on_eqI)
   show r2: \<open>\<pi> (x + y) =  (\<pi> x) + (\<pi> y)\<close>
     for x y
   proof-
     have "\<forall>A. \<not> closed_csubspace (A::'a set) \<or> csubspace A"
       by (metis closed_csubspace.subspace)
     hence "csubspace M"
-      using a2 by auto      
+      using a2 by auto
     hence \<open>\<pi> (x + y) - ( (\<pi> x) + (\<pi> y) ) \<in> M\<close>
-      by (simp add: complex_vector.subspace_add complex_vector.subspace_diff f1)      
+      by (simp add: complex_vector.subspace_add complex_vector.subspace_diff f1)
     have \<open>closed_csubspace (orthogonal_complement M)\<close>
       using a2
       by simp
     have f1: "\<forall>a b. (b::'a) + (a - b) = a"
       by (metis add.commute diff_add_cancel)
     have f2: "\<forall>a b. (b::'a) - b = a - a"
       by auto
     hence f3: "\<forall>a. a - a \<in> orthogonal_complement M"
       by (simp add: complex_vector.subspace_0)
     have "\<forall>a b. (a \<in> orthogonal_complement M \<or> a + b \<notin> orthogonal_complement M)
              \<or> b \<notin> orthogonal_complement M"
       using add_diff_cancel_right' b1 complex_vector.subspace_diff
       by metis
-    hence "\<forall>a b c. (a \<in> orthogonal_complement M \<or> c - (b + a) \<notin> orthogonal_complement M) 
+    hence "\<forall>a b c. (a \<in> orthogonal_complement M \<or> c - (b + a) \<notin> orthogonal_complement M)
               \<or> c - b \<notin> orthogonal_complement M"
       using f1 by (metis diff_diff_add)
-    hence f4: "\<forall>a b f. (f a - b \<in> orthogonal_complement M \<or> a - b \<notin> orthogonal_complement M) 
+    hence f4: "\<forall>a b f. (f a - b \<in> orthogonal_complement M \<or> a - b \<notin> orthogonal_complement M)
               \<or> \<not> is_projection_on f M"
       using f1
       by (metis a2 is_projection_on_iff_orthog)
     have f5: "\<forall>a b c d. (d::'a) - (c + (b - a)) = d + (a - (b + c))"
       by auto
     have "x - \<pi> x \<in> orthogonal_complement M"
       using a1 a2 is_projection_on_iff_orthog by blast
     hence q1: \<open>\<pi> (x + y) - ( (\<pi> x) + (\<pi> y) ) \<in> orthogonal_complement M\<close>
-      using f5 f4 f3 by (metis \<open>csubspace (orthogonal_complement M)\<close> 
-          \<open>is_projection_on \<pi> M\<close> add_diff_eq complex_vector.subspace_diff diff_diff_add 
+      using f5 f4 f3 by (metis \<open>csubspace (orthogonal_complement M)\<close>
+          \<open>is_projection_on \<pi> M\<close> add_diff_eq complex_vector.subspace_diff diff_diff_add
           diff_diff_eq2)
     hence \<open>\<pi> (x + y) - ( (\<pi> x) + (\<pi> y) ) \<in> M \<inter> (orthogonal_complement M)\<close>
-      by (simp add: \<open>\<pi> (x + y) - (\<pi> x + \<pi> y) \<in> M\<close>)      
+      by (simp add: \<open>\<pi> (x + y) - (\<pi> x + \<pi> y) \<in> M\<close>)
     moreover have \<open>M \<inter> (orthogonal_complement M) = {0}\<close>
       by (simp add: \<open>closed_csubspace M\<close> complex_vector.subspace_0 orthogonal_complement_zero_intersection)
     ultimately have \<open>\<pi> (x + y) - ( (\<pi> x) + (\<pi> y) ) = 0\<close>
-      by auto      
+      by auto
     thus ?thesis by simp
   qed
   from is_projection_on_reduces_norm
   show t1: \<open>\<exists> K. \<forall> x. norm (\<pi> x) \<le> norm x * K\<close>
     by (metis a1 a2 mult.left_neutral ordered_field_class.sign_simps(5))
 qed
 
 theorem projection_bounded_clinear:
   fixes M :: \<open>('a::chilbert_space) set\<close>
   assumes a1: "closed_csubspace M"
-  shows \<open>bounded_clinear (projection M)\<close> 
+  shows \<open>bounded_clinear (projection M)\<close>
     \<comment> \<open>Theorem 2.7 in @{cite conway2013course}\<close>
-  using assms is_projection_on_iff_orthog orthog_proj_exists is_projection_on_bounded_clinear projection_eqI by blast      
+  using assms is_projection_on_iff_orthog orthog_proj_exists is_projection_on_bounded_clinear projection_eqI by blast
 
 proposition is_projection_on_idem:
   fixes M :: \<open>('a::complex_inner) set\<close>
   assumes "is_projection_on \<pi> M"
   shows "\<pi> (\<pi> x) = \<pi> x"
   using is_projection_on_fixes_image is_projection_on_in_image assms by blast
 
 proposition projection_idem:
   fixes M :: "'a::chilbert_space set"
   assumes a1: "closed_csubspace M"
   shows "projection M (projection M x) = projection M x"
   by (metis assms closed_csubspace.closed closed_csubspace.subspace complex_vector.subspace_0 csubspace_is_convex equals0D projection_fixes_image projection_in_image)
 
 
 proposition is_projection_on_kernel_is_orthogonal_complement:
   fixes M :: \<open>'a::complex_inner set\<close>
   assumes a1: "is_projection_on \<pi> M" and a2: "closed_csubspace M"
   shows "\<pi> -` {0} = orthogonal_complement M"
 proof-
-  have "x \<in> (\<pi> -` {0})" 
+  have "x \<in> (\<pi> -` {0})"
     if "x \<in> orthogonal_complement M"
     for x
     by (smt (verit, ccfv_SIG) a1 a2 closed_csubspace_def complex_vector.subspace_def complex_vector.subspace_diff is_projection_on_eqI orthogonal_complement_closed_subspace that vimage_singleton_eq)
   moreover have "x \<in> orthogonal_complement M"
     if s1: "x \<in> \<pi> -` {0}" for x
     by (metis a1 a2 diff_zero is_projection_on_iff_orthog that vimage_singleton_eq)
-  ultimately show ?thesis 
+  ultimately show ?thesis
     by blast
 qed
 
-\<comment> \<open>Theorem 2.7 in @{cite conway2013course}\<close> 
+\<comment> \<open>Theorem 2.7 in @{cite conway2013course}\<close>
 proposition projection_kernel_is_orthogonal_complement:
   fixes M :: \<open>'a::chilbert_space set\<close>
   assumes "closed_csubspace M"
   shows "(projection M) -` {0} = (orthogonal_complement M)"
   by (metis assms closed_csubspace_def complex_vector.subspace_def csubspace_is_convex insert_absorb insert_not_empty is_projection_on_kernel_is_orthogonal_complement projection_is_projection_on)
 
 lemma is_projection_on_id_minus:
   fixes M :: \<open>'a::complex_inner set\<close>
   assumes is_proj: "is_projection_on \<pi> M"
     and cc: "closed_csubspace M"
   shows "is_projection_on (id - \<pi>) (orthogonal_complement M)"
   using is_proj apply (simp add: cc is_projection_on_iff_orthog)
   using double_orthogonal_complement_increasing by blast
 
 
 text \<open>Exercise 2 (section 2, chapter I) in  @{cite conway2013course}\<close>
 lemma projection_on_orthogonal_complement[simp]:
   fixes M :: "'a::chilbert_space set"
   assumes a1: "closed_csubspace M"
   shows "projection (orthogonal_complement M) = id - projection M"
   apply (auto intro!: ext)
   by (smt (verit, ccfv_SIG) add_diff_cancel_left' assms closed_csubspace.closed closed_csubspace.subspace complex_vector.subspace_0 csubspace_is_convex diff_add_cancel double_orthogonal_complement_increasing insert_absorb insert_not_empty is_projection_on_iff_orthog orthogonal_complement_closed_subspace projection_eqI projection_is_projection_on subset_eq)
 
 lemma is_projection_on_zero:
   "is_projection_on (\<lambda>_. 0) {0}"
   by (simp add: is_projection_on_def is_arg_min_def)
 
 lemma projection_zero[simp]:
   "projection {0} = (\<lambda>_. 0)"
   using is_projection_on_zero
   by (metis (full_types) is_projection_on_in_image projection_def singletonD someI_ex)
 
 lemma is_projection_on_rank1:
   fixes t :: \<open>'a::complex_inner\<close>
   shows \<open>is_projection_on (\<lambda>x. (\<langle>t , x\<rangle> / \<langle>t , t\<rangle>) *\<^sub>C t) (cspan {t})\<close>
 proof (cases \<open>t = 0\<close>)
   case True
   then show ?thesis
     by (simp add: is_projection_on_zero)
 next
   case False
   define P where \<open>P x = (\<langle>t , x\<rangle> / \<langle>t , t\<rangle>) *\<^sub>C t\<close> for x
   define t' where \<open>t' = t /\<^sub>C norm t\<close>
   with False have \<open>norm t' = 1\<close>
     by (simp add: norm_inverse)
   have P_def': \<open>P x = cinner t' x *\<^sub>C t'\<close> for x
     unfolding P_def t'_def apply auto
     by (metis divide_divide_eq_left divide_inverse mult.commute power2_eq_square power2_norm_eq_cinner)
   have spant': \<open>cspan {t} = cspan {t'}\<close>
     by (simp add: False t'_def)
   have cc: \<open>closed_csubspace (cspan {t})\<close>
     by (auto intro!: finite_cspan_closed closed_csubspace.intro)
   have ortho: \<open>h - P h \<in> orthogonal_complement (cspan {t})\<close> for h
     unfolding orthogonal_complement_def P_def' spant' apply auto
     by (smt (verit, ccfv_threshold) \<open>norm t' = 1\<close> add_cancel_right_left cinner_add_right cinner_commute' cinner_scaleC_right cnorm_eq_1 complex_vector.span_breakdown_eq complex_vector.span_empty diff_add_cancel mult_cancel_left1 singletonD)
   have inspan: \<open>P h \<in> cspan {t}\<close> for h
     unfolding P_def' spant'
     by (simp add: complex_vector.span_base complex_vector.span_scale)
   show \<open>is_projection_on P (cspan {t})\<close>
     apply (subst is_projection_on_iff_orthog)
-    using cc ortho inspan by auto      
+    using cc ortho inspan by auto
 qed
 
 lemma projection_rank1:
   fixes t x :: \<open>'a::complex_inner\<close>
   shows \<open>projection (cspan {t}) x = (\<langle>t , x\<rangle> / \<langle>t , t\<rangle>) *\<^sub>C t\<close>
   apply (rule fun_cong, rule projection_eqI', simp)
   by (rule is_projection_on_rank1)
 
 subsection \<open>More orthogonal complement\<close>
 
 text \<open>The following lemmas logically fit into the "orthogonality" section but depend on projections for their proofs.\<close>
 
 text \<open>Corollary 2.8 in  @{cite conway2013course}\<close>
 theorem double_orthogonal_complement_id[simp]:
   fixes M :: \<open>'a::chilbert_space set\<close>
   assumes a1: "closed_csubspace M"
-  shows "orthogonal_complement (orthogonal_complement M) = M"  
+  shows "orthogonal_complement (orthogonal_complement M) = M"
 proof-
   have b2: "x \<in> (id - projection M) -` {0}"
     if c1: "x \<in> M" for x
     by (simp add: assms projection_fixes_image that)
 
-  have b3: \<open>x \<in> M\<close> 
+  have b3: \<open>x \<in> M\<close>
     if c1: \<open>x \<in> (id - projection M) -` {0}\<close> for x
     by (metis assms closed_csubspace.closed closed_csubspace.subspace complex_vector.subspace_0 csubspace_is_convex eq_id_iff equals0D fun_diff_def projection_in_image right_minus_eq that vimage_singleton_eq)
   have \<open>x \<in>  M \<longleftrightarrow> x \<in> (id - projection M) -` {0}\<close> for x
-    using b2 b3 by blast      
+    using b2 b3 by blast
   hence b4: \<open>( id - (projection M) ) -` {0} =  M\<close>
     by blast
-  have b1: "orthogonal_complement (orthogonal_complement M) 
+  have b1: "orthogonal_complement (orthogonal_complement M)
           = (projection (orthogonal_complement M)) -` {0}"
     by (simp add: a1 projection_kernel_is_orthogonal_complement del: projection_on_orthogonal_complement)
   also have \<open>... = ( id - (projection M) ) -` {0}\<close>
     by (simp add: a1)
   also have \<open>... = M\<close>
-    by (simp add: b4)     
+    by (simp add: b4)
   finally show ?thesis by blast
 qed
 
 lemma orthogonal_complement_antimono[simp]:
   fixes  A B :: \<open>('a::complex_inner) set\<close>
   assumes "A \<supseteq> B"
   shows \<open>orthogonal_complement A \<subseteq> orthogonal_complement B\<close>
   by (meson assms orthogonal_complementI orthogonal_complement_orthoI' subsetD subsetI)
 
 lemma orthogonal_complement_antimono_iff[simp]:
   fixes  A B :: \<open>('a::chilbert_space) set\<close>
   assumes \<open>closed_csubspace A\<close> and  \<open>closed_csubspace B\<close>
   shows \<open>orthogonal_complement A \<subseteq> orthogonal_complement B \<longleftrightarrow> A \<supseteq> B\<close>
 proof
   show \<open>orthogonal_complement A \<subseteq> orthogonal_complement B\<close> if \<open>A \<supseteq> B\<close>
     using that by auto
 
   assume \<open>orthogonal_complement A \<subseteq> orthogonal_complement B\<close>
   then have \<open>orthogonal_complement (orthogonal_complement A) \<supseteq> orthogonal_complement (orthogonal_complement B)\<close>
     by simp
   then show \<open>A \<supseteq> B\<close>
     using assms by auto
 qed
 
-lemma orthogonal_complement_UNIV[simp]: 
+lemma orthogonal_complement_UNIV[simp]:
   "orthogonal_complement UNIV = {0}"
   by (metis Int_UNIV_left complex_vector.subspace_UNIV complex_vector.subspace_def orthogonal_complement_zero_intersection)
 
 lemma orthogonal_complement_zero[simp]:
   "orthogonal_complement {0} = UNIV"
   unfolding orthogonal_complement_def by auto
 
 
-lemma de_morgan_orthogonal_complement_plus:        
+lemma de_morgan_orthogonal_complement_plus:
   fixes A B::"('a::complex_inner) set"
   assumes \<open>0 \<in> A\<close> and \<open>0 \<in> B\<close>
   shows \<open>orthogonal_complement (A +\<^sub>M B) = (orthogonal_complement A) \<inter> (orthogonal_complement B)\<close>
 proof-
   have "x \<in> (orthogonal_complement A) \<inter> (orthogonal_complement B)"
-    if "x \<in> orthogonal_complement (A +\<^sub>M B)" 
+    if "x \<in> orthogonal_complement (A +\<^sub>M B)"
     for x
   proof-
     have \<open>orthogonal_complement (A +\<^sub>M B) = orthogonal_complement (A + B)\<close>
       unfolding closed_sum_def by (subst orthogonal_complement_of_closure[symmetric], simp)
     hence \<open>x \<in> orthogonal_complement (A + B)\<close>
-      using that by blast      
+      using that by blast
     hence t1: \<open>\<forall>z \<in> (A + B). \<langle> z , x \<rangle> = 0\<close>
-      by (simp add: orthogonal_complement_orthoI') 
+      by (simp add: orthogonal_complement_orthoI')
     have \<open>A \<subseteq> A + B\<close>
       using subset_iff add.commute set_zero_plus2 \<open>0 \<in> B\<close>
       by fastforce
-    hence \<open>\<forall>z \<in> A. \<langle> z , x \<rangle> = 0\<close> 
+    hence \<open>\<forall>z \<in> A. \<langle> z , x \<rangle> = 0\<close>
       using t1 by auto
     hence w1: \<open>x \<in> (orthogonal_complement A)\<close>
       by (smt mem_Collect_eq is_orthogonal_sym orthogonal_complement_def)
     have \<open>B \<subseteq> A + B\<close>
-      using \<open>0 \<in> A\<close> subset_iff set_zero_plus2 by blast        
+      using \<open>0 \<in> A\<close> subset_iff set_zero_plus2 by blast
     hence \<open>\<forall> z \<in> B. \<langle> z , x \<rangle> = 0\<close>
-      using t1 by auto   
+      using t1 by auto
     hence \<open>x \<in> (orthogonal_complement B)\<close>
       by (smt mem_Collect_eq is_orthogonal_sym orthogonal_complement_def)
-    thus ?thesis 
+    thus ?thesis
       using w1 by auto
   qed
   moreover have "x \<in> (orthogonal_complement (A +\<^sub>M B))"
     if v1: "x \<in> (orthogonal_complement A) \<inter> (orthogonal_complement B)"
     for x
   proof-
-    have \<open>x \<in> (orthogonal_complement A)\<close> 
+    have \<open>x \<in> (orthogonal_complement A)\<close>
       using v1
       by blast
     hence \<open>\<forall>y\<in> A. \<langle> y , x \<rangle> = 0\<close>
       by (simp add: orthogonal_complement_orthoI')
-    have \<open>x \<in> (orthogonal_complement B)\<close> 
-      using v1 
+    have \<open>x \<in> (orthogonal_complement B)\<close>
+      using v1
       by blast
     hence \<open>\<forall> y\<in> B. \<langle> y , x \<rangle> = 0\<close>
       by (simp add: orthogonal_complement_orthoI')
     have \<open>\<forall> a\<in>A. \<forall> b\<in>B. \<langle> a+b , x \<rangle> = 0\<close>
       by (simp add: \<open>\<forall>y\<in>A. \<langle>y , x\<rangle> = 0\<close> \<open>\<forall>y\<in>B. \<langle>y , x\<rangle> = 0\<close> cinner_add_left)
     hence \<open>\<forall> y \<in> (A + B). \<langle> y , x \<rangle> = 0\<close>
       using set_plus_elim by force
     hence \<open>x \<in> (orthogonal_complement (A + B))\<close>
       by (smt mem_Collect_eq is_orthogonal_sym orthogonal_complement_def)
     moreover have \<open>(orthogonal_complement (A + B)) = (orthogonal_complement (A +\<^sub>M B))\<close>
       unfolding closed_sum_def by (subst orthogonal_complement_of_closure[symmetric], simp)
     ultimately have \<open>x \<in> (orthogonal_complement (A +\<^sub>M B))\<close>
       by blast
     thus ?thesis
       by blast
   qed
   ultimately show ?thesis by blast
 qed
 
 lemma de_morgan_orthogonal_complement_inter:
   fixes A B::"'a::chilbert_space set"
   assumes a1: \<open>closed_csubspace A\<close> and a2: \<open>closed_csubspace B\<close>
   shows  \<open>orthogonal_complement (A \<inter> B) = orthogonal_complement A +\<^sub>M orthogonal_complement B\<close>
 proof-
   have \<open>orthogonal_complement A +\<^sub>M orthogonal_complement B
     = orthogonal_complement (orthogonal_complement (orthogonal_complement A +\<^sub>M orthogonal_complement B))\<close>
     by (simp add: closed_subspace_closed_sum)
   also have \<open>\<dots> = orthogonal_complement (orthogonal_complement (orthogonal_complement A) \<inter> orthogonal_complement (orthogonal_complement B))\<close>
     by (simp add: de_morgan_orthogonal_complement_plus orthogonal_complementI)
   also have \<open>\<dots> = orthogonal_complement (A \<inter> B)\<close>
     by (simp add: a1 a2)
   finally show ?thesis
     by simp
 qed
 
 subsection \<open>Riesz-representation theorem\<close>
 
 lemma orthogonal_complement_kernel_functional:
   fixes f :: \<open>'a::complex_inner \<Rightarrow> complex\<close>
   assumes \<open>bounded_clinear f\<close>
   shows \<open>\<exists>x. orthogonal_complement (f -` {0}) = cspan {x}\<close>
 proof (cases \<open>orthogonal_complement (f -` {0}) = {0}\<close>)
   case True
   then show ?thesis
     apply (rule_tac x=0 in exI) by auto
 next
   case False
   then obtain x where xortho: \<open>x \<in> orthogonal_complement (f -` {0})\<close> and xnon0: \<open>x \<noteq> 0\<close>
     using complex_vector.subspace_def by fastforce
 
   from xnon0 xortho
   have r1: \<open>f x \<noteq> 0\<close>
     by (metis cinner_eq_zero_iff orthogonal_complement_orthoI vimage_singleton_eq)
 
   have \<open>\<exists> k. y = k *\<^sub>C x\<close> if \<open>y \<in> orthogonal_complement (f -` {0})\<close> for y
   proof (cases \<open>y = 0\<close>)
     case True
     then show ?thesis by auto
   next
     case False
     with that
     have \<open>f y \<noteq> 0\<close>
       by (metis cinner_eq_zero_iff orthogonal_complement_orthoI vimage_singleton_eq)
     then obtain k where k_def: \<open>f x = k * f y\<close>
       by (metis add.inverse_inverse minus_divide_eq_eq)
     with assms have \<open>f x = f (k *\<^sub>C y)\<close>
       by (simp add: bounded_clinear.axioms(1) clinear.scaleC)
     hence \<open>f x - f (k *\<^sub>C y) = 0\<close>
       by simp
     with assms have s1: \<open>f (x - k *\<^sub>C y) = 0\<close>
       by (simp add: bounded_clinear.axioms(1) complex_vector.linear_diff)
     from that have \<open>k *\<^sub>C y \<in> orthogonal_complement (f -` {0})\<close>
       by (simp add: complex_vector.subspace_scale)
     with xortho have s2: \<open>x - (k *\<^sub>C y) \<in> orthogonal_complement (f -` {0})\<close>
       by (simp add: complex_vector.subspace_diff)
     have s3: \<open>(x - (k *\<^sub>C y)) \<in> f -` {0}\<close>
       using s1 by simp
     moreover have \<open>(f -` {0}) \<inter> (orthogonal_complement (f -` {0})) = {0}\<close>
-      by (meson assms closed_csubspace_def complex_vector.subspace_def kernel_is_closed_csubspace 
+      by (meson assms closed_csubspace_def complex_vector.subspace_def kernel_is_closed_csubspace
           orthogonal_complement_zero_intersection)
     ultimately have \<open>x - (k *\<^sub>C y) = 0\<close>
       using s2 by blast
     thus ?thesis
       by (metis ceq_vector_fraction_iff eq_iff_diff_eq_0 k_def r1 scaleC_scaleC)
   qed
   then have \<open>orthogonal_complement (f -` {0}) \<subseteq> cspan {x}\<close>
     using complex_vector.span_superset complex_vector.subspace_scale by blast
 
   moreover from xortho have \<open>orthogonal_complement (f -` {0}) \<supseteq> cspan {x}\<close>
     by (simp add: complex_vector.span_minimal)
 
   ultimately show ?thesis
     by auto
 qed
 
 lemma riesz_frechet_representation_existence:
   \<comment> \<open>Theorem 3.4 in @{cite conway2013course}\<close>
   fixes f::\<open>'a::chilbert_space \<Rightarrow> complex\<close>
   assumes a1: \<open>bounded_clinear f\<close>
   shows \<open>\<exists>t. \<forall>x.  f x = \<langle>t, x\<rangle>\<close>
 proof(cases \<open>\<forall> x. f x = 0\<close>)
   case True
   thus ?thesis
-    by (metis cinner_zero_left) 
+    by (metis cinner_zero_left)
 next
   case False
   obtain t where spant: \<open>orthogonal_complement (f -` {0}) = cspan {t}\<close>
     using orthogonal_complement_kernel_functional
     using assms by blast
   have \<open>projection (orthogonal_complement (f -` {0})) x = (\<langle>t , x\<rangle>/\<langle>t , t\<rangle>) *\<^sub>C t\<close> for x
     apply (subst spant) by (rule projection_rank1)
   hence \<open>f (projection (orthogonal_complement (f -` {0})) x) = ((\<langle>t , x\<rangle>)/(\<langle>t , t\<rangle>)) * (f t)\<close> for x
     using a1 unfolding bounded_clinear_def
     by (simp add: complex_vector.linear_scale)
   hence l2: \<open>f (projection (orthogonal_complement (f -` {0})) x) = \<langle>((cnj (f t)/\<langle>t , t\<rangle>) *\<^sub>C t) , x\<rangle>\<close> for x
     using complex_cnj_divide by force
   have \<open>f (projection (f -` {0}) x) = 0\<close> for x
     by (metis (no_types, lifting) assms bounded_clinear_def closed_csubspace.closed
         complex_vector.linear_subspace_vimage complex_vector.subspace_0 complex_vector.subspace_single_0
         csubspace_is_convex insert_absorb insert_not_empty kernel_is_closed_csubspace projection_in_image vimage_singleton_eq)
   hence "\<And>a b. f (projection (f -` {0}) a + b) = 0 + f b"
     using additive.add assms
     by (simp add: bounded_clinear_def complex_vector.linear_add)
   hence "\<And>a. 0 + f (projection (orthogonal_complement (f -` {0})) a) = f a"
     apply (simp add: assms)
     by (metis add.commute diff_add_cancel)
   hence \<open>f x = \<langle>(cnj (f t)/\<langle>t , t\<rangle>) *\<^sub>C t, x\<rangle>\<close> for x
-    by (simp add: l2) 
+    by (simp add: l2)
   thus ?thesis
     by blast
 qed
 
 lemma riesz_frechet_representation_unique:
   \<comment> \<open>Theorem 3.4 in @{cite conway2013course}\<close>
   fixes f::\<open>'a::complex_inner \<Rightarrow> complex\<close>
   assumes \<open>\<And>x. f x = \<langle>t, x\<rangle>\<close>
   assumes \<open>\<And>x. f x = \<langle>u, x\<rangle>\<close>
   shows \<open>t = u\<close>
   by (metis add_diff_cancel_left' assms(1) assms(2) cinner_diff_left cinner_gt_zero_iff diff_add_cancel diff_zero)
 
 
 subsection \<open>Adjoints\<close>
 
 definition "is_cadjoint F G \<longleftrightarrow> (\<forall>x. \<forall>y. \<langle>F x, y\<rangle> = \<langle>x, G y\<rangle>)"
 
 lemma is_adjoint_sym:
   \<open>is_cadjoint F G \<Longrightarrow> is_cadjoint G F\<close>
   unfolding is_cadjoint_def apply auto
   by (metis cinner_commute')
 
 definition \<open>cadjoint G = (SOME F. is_cadjoint F G)\<close>
   for G :: "'b::complex_inner \<Rightarrow> 'a::complex_inner"
 
 lemma cadjoint_exists:
   fixes G :: "'b::chilbert_space \<Rightarrow> 'a::complex_inner"
   assumes [simp]: \<open>bounded_clinear G\<close>
   shows \<open>\<exists>F. is_cadjoint F G\<close>
 proof -
   include notation_norm
   have [simp]: \<open>clinear G\<close>
     using assms unfolding bounded_clinear_def by blast
-  define g :: \<open>'a \<Rightarrow> 'b \<Rightarrow> complex\<close> 
+  define g :: \<open>'a \<Rightarrow> 'b \<Rightarrow> complex\<close>
     where \<open>g x y = \<langle>x , G y\<rangle>\<close> for x y
   have \<open>bounded_clinear (g x)\<close> for x
   proof -
     have \<open>g x (a + b) = g x a + g x b\<close> for a b
       unfolding g_def
       using additive.add cinner_add_right clinear_def
       by (simp add: cinner_add_right complex_vector.linear_add)
     moreover have  \<open>g x (k *\<^sub>C a) = k *\<^sub>C (g x a)\<close>
       for a k
       unfolding g_def
       by (simp add: complex_vector.linear_scale)
     ultimately have \<open>clinear (g x)\<close>
-      by (simp add: clinearI)    
-    moreover 
+      by (simp add: clinearI)
+    moreover
     have \<open>\<exists> M. \<forall> y. \<parallel> G y \<parallel> \<le> \<parallel> y \<parallel> * M\<close>
       using \<open>bounded_clinear G\<close>
       unfolding bounded_clinear_def bounded_clinear_axioms_def by blast
     then have \<open>\<exists>M. \<forall>y. \<parallel> g x y \<parallel> \<le> \<parallel> y \<parallel> * M\<close>
       using g_def
       by (simp add: bounded_clinear.bounded bounded_clinear_cinner_right_comp)
     ultimately show ?thesis unfolding bounded_linear_def
       using bounded_clinear.intro
       using bounded_clinear_axioms_def by blast
   qed
   hence \<open>\<forall>x. \<exists>t. \<forall>y.  g x y = \<langle>t, y\<rangle>\<close>
     using riesz_frechet_representation_existence by blast
   then obtain F where \<open>\<forall>x. \<forall>y. g x y = \<langle>F x, y\<rangle>\<close>
     by metis
   then have \<open>is_cadjoint F G\<close>
     unfolding is_cadjoint_def g_def by simp
   thus ?thesis
     by auto
 qed
 
 lemma cadjoint_is_cadjoint[simp]:
   fixes G :: "'b::chilbert_space \<Rightarrow> 'a::complex_inner"
   assumes [simp]: \<open>bounded_clinear G\<close>
   shows \<open>is_cadjoint (cadjoint G) G\<close>
   by (metis assms cadjoint_def cadjoint_exists someI_ex)
 
 lemma is_cadjoint_unique:
   assumes \<open>is_cadjoint F1 G\<close>
   assumes \<open>is_cadjoint F2 G\<close>
   shows \<open>F1 = F2\<close>
 proof (rule ext)
   fix x
-  { 
+  {
     fix y
     have \<open>cinner (F1 x - F2 x) y = cinner (F1 x) y - cinner (F2 x) y\<close>
       by (simp add: cinner_diff_left)
     also have \<open>\<dots> = cinner x (G y) - cinner x (G y)\<close>
       by (metis assms(1) assms(2) is_cadjoint_def)
     also have \<open>\<dots> = 0\<close>
       by simp
     finally have \<open>cinner (F1 x - F2 x) y = 0\<close>
       by -
   }
   then show \<open>F1 x = F2 x\<close>
     by fastforce
 qed
 
 lemma cadjoint_univ_prop:
   fixes G :: "'b::chilbert_space \<Rightarrow> 'a::complex_inner"
   assumes a1: \<open>bounded_clinear G\<close>
   shows \<open>\<forall>x. \<forall>y. \<langle>cadjoint G x, y\<rangle> = \<langle>x, G y\<rangle>\<close>
   using assms cadjoint_is_cadjoint is_cadjoint_def by blast
 
 lemma cadjoint_univ_prop':
   fixes G :: "'b::chilbert_space \<Rightarrow> 'a::complex_inner"
   assumes a1: \<open>bounded_clinear G\<close>
   shows \<open>\<forall>x. \<forall>y. \<langle>x, cadjoint G y\<rangle> = \<langle>G x, y\<rangle>\<close>
   by (metis cadjoint_univ_prop assms cinner_commute')
 
 notation cadjoint ("_\<^sup>\<dagger>" [99] 100)
 
 lemma cadjoint_eqI:
   fixes G:: \<open>'b::complex_inner \<Rightarrow> 'a::complex_inner\<close>
     and F:: \<open>'a \<Rightarrow> 'b\<close>
   assumes \<open>\<And>x y. \<langle>F x, y\<rangle> = \<langle>x, G y\<rangle>\<close>
   shows \<open>G\<^sup>\<dagger> = F\<close>
   by (metis assms cadjoint_def is_cadjoint_def is_cadjoint_unique someI_ex)
 
 lemma cadjoint_bounded_clinear:
   fixes A :: "'a::chilbert_space \<Rightarrow> 'b::complex_inner"
   assumes a1: "bounded_clinear A"
   shows \<open>bounded_clinear (A\<^sup>\<dagger>)\<close>
 proof
-  include notation_norm 
+  include notation_norm
   have b1: \<open>\<langle>(A\<^sup>\<dagger>) x, y\<rangle> = \<langle>x , A y\<rangle>\<close> for x y
     using cadjoint_univ_prop a1 by auto
   have \<open>\<langle>(A\<^sup>\<dagger>) (x1 + x2) - ((A\<^sup>\<dagger>) x1 + (A\<^sup>\<dagger>) x2) , y\<rangle> = 0\<close> for x1 x2 y
-    by (simp add: b1 cinner_diff_left cinner_add_left)        
+    by (simp add: b1 cinner_diff_left cinner_add_left)
   hence b2: \<open>(A\<^sup>\<dagger>) (x1 + x2) - ((A\<^sup>\<dagger>) x1 + (A\<^sup>\<dagger>) x2) = 0\<close> for x1 x2
     using cinner_eq_zero_iff by blast
   thus z1: \<open>(A\<^sup>\<dagger>) (x1 + x2) = (A\<^sup>\<dagger>) x1 + (A\<^sup>\<dagger>) x2\<close> for x1 x2
     by (simp add: b2 eq_iff_diff_eq_0)
 
   have f1: \<open>\<langle>(A\<^sup>\<dagger>) (r *\<^sub>C x) - (r *\<^sub>C (A\<^sup>\<dagger>) x ), y\<rangle> = 0\<close> for r x y
     by (simp add: b1 cinner_diff_left)
   thus z2: \<open>(A\<^sup>\<dagger>) (r *\<^sub>C x) = r *\<^sub>C (A\<^sup>\<dagger>) x\<close> for r x
     using cinner_eq_zero_iff eq_iff_diff_eq_0 by blast
   have \<open>\<parallel> (A\<^sup>\<dagger>) x \<parallel>^2 = \<langle>(A\<^sup>\<dagger>) x, (A\<^sup>\<dagger>) x\<rangle>\<close> for x
     by (metis cnorm_eq_square)
   moreover have \<open>\<parallel> (A\<^sup>\<dagger>) x \<parallel>^2 \<ge> 0\<close> for x
     by simp
   ultimately have \<open>\<parallel> (A\<^sup>\<dagger>) x \<parallel>^2 = \<bar> \<langle>(A\<^sup>\<dagger>) x, (A\<^sup>\<dagger>) x\<rangle> \<bar>\<close> for x
     by (metis abs_pos cinner_ge_zero)
   hence \<open>\<parallel> (A\<^sup>\<dagger>) x \<parallel>^2 = \<bar> \<langle>x, A ((A\<^sup>\<dagger>) x)\<rangle> \<bar>\<close> for x
     by (simp add: b1)
   moreover have  \<open>\<bar>\<langle>x , A ((A\<^sup>\<dagger>) x)\<rangle>\<bar> \<le> \<parallel>x\<parallel> *  \<parallel>A ((A\<^sup>\<dagger>) x)\<parallel>\<close> for x
     by (simp add: abs_complex_def complex_inner_class.Cauchy_Schwarz_ineq2)
   ultimately have b5: \<open>\<parallel> (A\<^sup>\<dagger>) x \<parallel>^2  \<le> \<parallel>x\<parallel> * \<parallel>A ((A\<^sup>\<dagger>) x)\<parallel>\<close> for x
     by (metis complex_of_real_mono_iff)
   have \<open>\<exists>M. M \<ge> 0 \<and> (\<forall> x. \<parallel>A ((A\<^sup>\<dagger>) x)\<parallel> \<le> M *  \<parallel>(A\<^sup>\<dagger>) x\<parallel>)\<close>
     using a1
-    by (metis (mono_tags, hide_lams) bounded_clinear.bounded linear mult_nonneg_nonpos
-        mult_zero_right norm_ge_zero order.trans semiring_normalization_rules(7)) 
+    by (metis (mono_tags, opaque_lifting) bounded_clinear.bounded linear mult_nonneg_nonpos
+        mult_zero_right norm_ge_zero order.trans semiring_normalization_rules(7))
   then obtain M where q1: \<open>M \<ge> 0\<close> and q2: \<open>\<forall> x. \<parallel>A ((A\<^sup>\<dagger>) x)\<parallel> \<le> M * \<parallel>(A\<^sup>\<dagger>) x\<parallel>\<close>
     by blast
   have \<open>\<forall> x::'b. \<parallel>x\<parallel> \<ge> 0\<close>
     by simp
   hence b6: \<open>\<parallel>x\<parallel> * \<parallel>A ((A\<^sup>\<dagger>) x)\<parallel> \<le>  \<parallel>x\<parallel> * M * \<parallel>(A\<^sup>\<dagger>) x\<parallel>\<close> for x
     using q2
-    by (smt ordered_comm_semiring_class.comm_mult_left_mono vector_space_over_itself.scale_scale) 
+    by (smt ordered_comm_semiring_class.comm_mult_left_mono vector_space_over_itself.scale_scale)
   have z3: \<open>\<parallel> (A\<^sup>\<dagger>) x \<parallel> \<le> \<parallel>x\<parallel> * M\<close> for x
   proof(cases \<open>\<parallel>(A\<^sup>\<dagger>) x\<parallel> = 0\<close>)
     case True
     thus ?thesis
-      by (simp add: \<open>0 \<le> M\<close>) 
+      by (simp add: \<open>0 \<le> M\<close>)
   next
     case False
     have \<open>\<parallel> (A\<^sup>\<dagger>) x \<parallel>^2 \<le> \<parallel>x\<parallel> *  M *  \<parallel>(A\<^sup>\<dagger>) x\<parallel>\<close>
       by (smt b5 b6)
     thus ?thesis
-      by (smt False mult_right_cancel mult_right_mono norm_ge_zero semiring_normalization_rules(29)) 
+      by (smt False mult_right_cancel mult_right_mono norm_ge_zero semiring_normalization_rules(29))
   qed
   thus \<open>\<exists>K. \<forall>x. \<parallel>(A\<^sup>\<dagger>) x\<parallel> \<le> \<parallel>x\<parallel> * K\<close>
     by auto
 qed
 
 proposition double_cadjoint:
   fixes U :: \<open>'a::chilbert_space \<Rightarrow> 'b::complex_inner\<close>
   assumes a1: "bounded_clinear U"
   shows "U\<^sup>\<dagger>\<^sup>\<dagger> = U"
   by (metis assms cadjoint_def cadjoint_is_cadjoint is_adjoint_sym is_cadjoint_unique someI_ex)
 
 lemma cadjoint_id: \<open>(id::'a::complex_inner\<Rightarrow>'a)\<^sup>\<dagger> = id\<close>
   by (simp add: cadjoint_eqI id_def)
 
 lemma scaleC_cadjoint:
   fixes A::"'a::chilbert_space \<Rightarrow> 'b::complex_inner"
   assumes "bounded_clinear A"
   shows \<open>(\<lambda>t. a *\<^sub>C (A t))\<^sup>\<dagger> = (\<lambda>s. (cnj a) *\<^sub>C ((A\<^sup>\<dagger>) s))\<close>
 proof-
   have b3: \<open>\<langle>(\<lambda> s. (cnj a) *\<^sub>C ((A\<^sup>\<dagger>) s)) x, y \<rangle> = \<langle>x, (\<lambda> t. a *\<^sub>C (A t)) y \<rangle>\<close>
     for x y
     by (simp add: assms cadjoint_univ_prop)
 
   have "((\<lambda>t. a *\<^sub>C A t)\<^sup>\<dagger>) b = cnj a *\<^sub>C (A\<^sup>\<dagger>) b"
     for b::'b
   proof-
     have "bounded_clinear (\<lambda>t. a *\<^sub>C A t)"
       by (simp add: assms bounded_clinear_const_scaleC)
     thus ?thesis
-      by (metis (no_types) cadjoint_eqI b3) 
+      by (metis (no_types) cadjoint_eqI b3)
   qed
   thus ?thesis
     by blast
 qed
 
 
 lemma is_projection_on_is_cadjoint:
   fixes M :: \<open>'a::complex_inner set\<close>
   assumes a1: \<open>is_projection_on \<pi> M\<close> and a2: \<open>closed_csubspace M\<close>
   shows \<open>is_cadjoint \<pi> \<pi>\<close>
 proof -
   have \<open>cinner (x - \<pi> x) y = 0\<close> if \<open>y\<in>M\<close> for x y
     using a1 a2 is_projection_on_iff_orthog orthogonal_complement_orthoI that by blast
   then have \<open>cinner x y = cinner (\<pi> x) y\<close> if \<open>y\<in>M\<close> for x y
     by (metis cinner_diff_left eq_iff_diff_eq_0 that)
   moreover have \<open>cinner x y = cinner x (\<pi> y)\<close> if \<open>y\<in>M\<close> for x y
     using a1 is_projection_on_fixes_image that by fastforce
   ultimately have 1: \<open>cinner (\<pi> x) y = cinner x (\<pi> y)\<close> if \<open>y\<in>M\<close> for x y
     using that by metis
 
   have \<open>cinner (\<pi> x) y = 0\<close> if \<open>y \<in> orthogonal_complement M\<close> for x y
     by (meson a1 is_projection_on_in_image orthogonal_complement_orthoI' that)
   also have \<open>0 = cinner x (\<pi> y)\<close> if \<open>y \<in> orthogonal_complement M\<close> for x y
     by (metis a1 a2 cinner_zero_right closed_csubspace.subspace complex_vector.subspace_0 diff_zero is_projection_on_eqI that)
   finally have 2: \<open>cinner (\<pi> x) y = cinner x (\<pi> y)\<close> if \<open>y \<in> orthogonal_complement M\<close> for x y
     using that by simp
 
   from 1 2
   have \<open>cinner (\<pi> x) y = cinner x (\<pi> y)\<close> for x y
     by (smt (verit, ccfv_threshold) a1 a2 cinner_commute cinner_diff_left eq_iff_diff_eq_0 is_projection_on_iff_orthog orthogonal_complement_orthoI)
   then show ?thesis
     by (simp add: is_cadjoint_def)
 qed
 
 lemma is_projection_on_cadjoint:
   fixes M :: \<open>'a::complex_inner set\<close>
   assumes \<open>is_projection_on \<pi> M\<close> and \<open>closed_csubspace M\<close>
   shows \<open>\<pi>\<^sup>\<dagger> = \<pi>\<close>
   using assms is_projection_on_is_cadjoint cadjoint_eqI is_cadjoint_def by blast
 
 lemma projection_cadjoint:
   fixes M :: \<open>'a::chilbert_space set\<close>
   assumes \<open>closed_csubspace M\<close>
   shows \<open>(projection M)\<^sup>\<dagger> = projection M\<close>
   using is_projection_on_cadjoint assms
-  by (metis closed_csubspace.closed closed_csubspace.subspace csubspace_is_convex empty_iff orthog_proj_exists projection_is_projection_on) 
+  by (metis closed_csubspace.closed closed_csubspace.subspace csubspace_is_convex empty_iff orthog_proj_exists projection_is_projection_on)
 
 instance ccsubspace :: (chilbert_space) complete_orthomodular_lattice
 proof
   show "inf x (- x) = bot"
     for x :: "'a ccsubspace"
     apply transfer
     by (simp add: closed_csubspace_def complex_vector.subspace_0 orthogonal_complement_zero_intersection)
 
   have \<open>t \<in> x +\<^sub>M orthogonal_complement x\<close>
     if a1: \<open>closed_csubspace x\<close>
     for t::'a and x
   proof-
     have e1: \<open>t = (projection x) t + (projection (orthogonal_complement x)) t\<close>
       by (simp add: that)
     have e2: \<open>(projection x) t \<in> x\<close>
       by (metis closed_csubspace.closed closed_csubspace.subspace csubspace_is_convex empty_iff orthog_proj_exists projection_in_image that)
     have e3: \<open>(projection (orthogonal_complement x)) t \<in> orthogonal_complement x\<close>
       by (metis add_diff_cancel_left' e1 orthogonal_complementI projection_orthogonal that)
     have "orthogonal_complement x \<subseteq> x +\<^sub>M orthogonal_complement x"
       by (simp add: closed_sum_right_subset complex_vector.subspace_0 that)
     thus ?thesis
-      using \<open>closed_csubspace x\<close> 
+      using \<open>closed_csubspace x\<close>
         \<open>projection (orthogonal_complement x) t \<in> orthogonal_complement x\<close> \<open>projection x t \<in> x\<close>
-        \<open>t = projection x t + projection (orthogonal_complement x) t\<close> in_mono 
+        \<open>t = projection x t + projection (orthogonal_complement x) t\<close> in_mono
         closed_sum_left_subset complex_vector.subspace_def
-      by (metis closed_csubspace.subspace closed_subspace_closed_sum orthogonal_complement_closed_subspace) 
-  qed  
+      by (metis closed_csubspace.subspace closed_subspace_closed_sum orthogonal_complement_closed_subspace)
+  qed
   hence b1: \<open>x +\<^sub>M orthogonal_complement x = UNIV\<close>
     if a1: \<open>closed_csubspace x\<close>
     for x::\<open>'a set\<close>
     using that by blast
   show "sup x (- x) = top"
     for x :: "'a ccsubspace"
     apply transfer
     using b1 by auto
   show "- (- x) = x"
     for x :: "'a ccsubspace"
     apply transfer
     by (simp)
 
   show "- y \<le> - x"
     if "x \<le> y"
     for x :: "'a ccsubspace"
       and y :: "'a ccsubspace"
     using that apply transfer
-    by simp 
+    by simp
 
   have c1: "x +\<^sub>M orthogonal_complement x \<inter> y \<subseteq> y"
     if "closed_csubspace x"
       and "closed_csubspace y"
       and "x \<subseteq> y"
     for x :: "'a set"
       and y :: "'a set"
     using that
-    by (simp add: closed_sum_is_sup) 
+    by (simp add: closed_sum_is_sup)
 
   have c2: \<open>u \<in> x +\<^sub>M ((orthogonal_complement x) \<inter> y)\<close>
     if a1: "closed_csubspace x" and a2: "closed_csubspace y" and a3: "x \<subseteq> y" and x1: \<open>u \<in> y\<close>
     for x :: "'a set" and y :: "'a set"  and u
   proof-
     have d4: \<open>(projection x) u \<in> x\<close>
       by (metis a1 closed_csubspace_def csubspace_is_convex equals0D orthog_proj_exists projection_in_image)
     hence d2: \<open>(projection x) u \<in> y\<close>
       using a3 by auto
     have d1: \<open>csubspace y\<close>
       by (simp add: a2)
     have \<open>u - (projection x) u \<in> orthogonal_complement x\<close>
       by (simp add: a1 orthogonal_complementI projection_orthogonal)
     moreover have  \<open>u - (projection x) u \<in> y\<close>
-      by (simp add: d1 d2 complex_vector.subspace_diff x1)      
+      by (simp add: d1 d2 complex_vector.subspace_diff x1)
     ultimately have d3: \<open>u - (projection x) u \<in> ((orthogonal_complement x) \<inter> y)\<close>
       by simp
     hence \<open>\<exists> v \<in> ((orthogonal_complement x) \<inter> y). u = (projection x) u + v\<close>
       by (metis d3 diff_add_cancel ordered_field_class.sign_simps(2))
     then obtain v where \<open>v \<in> ((orthogonal_complement x) \<inter> y)\<close> and \<open>u = (projection x) u + v\<close>
       by blast
     hence \<open>u \<in> x + ((orthogonal_complement x) \<inter> y)\<close>
       by (metis d4 set_plus_intro)
     thus ?thesis
       unfolding closed_sum_def
-      using closure_subset by blast 
+      using closure_subset by blast
   qed
 
   have c3: "y \<subseteq> x +\<^sub>M ((orthogonal_complement x) \<inter> y)"
     if a1: "closed_csubspace x" and a2: "closed_csubspace y" and a3: "x \<subseteq> y"
-    for x y :: "'a set"   
-    using c2 a1 a2 a3 by auto 
+    for x y :: "'a set"
+    using c2 a1 a2 a3 by auto
 
   show "sup x (inf (- x) y) = y"
     if "x \<le> y"
     for x y :: "'a ccsubspace"
     using that apply transfer
     using c1 c3
     by (simp add: subset_antisym)
 
   show "x - y = inf x (- y)"
     for x y :: "'a ccsubspace"
     apply transfer
     by simp
 qed
 
 subsection \<open>More projections\<close>
 
 text \<open>These lemmas logically belong in the "projections" section above but depend on lemmas developed later.\<close>
 
 lemma is_projection_on_plus:
   assumes "\<And>x y. x:A \<Longrightarrow> y:B \<Longrightarrow> is_orthogonal x y"
   assumes \<open>closed_csubspace A\<close>
   assumes \<open>closed_csubspace B\<close>
   assumes \<open>is_projection_on \<pi>A A\<close>
   assumes \<open>is_projection_on \<pi>B B\<close>
   shows \<open>is_projection_on (\<lambda>x. \<pi>A x + \<pi>B x) (A +\<^sub>M B)\<close>
 proof (rule is_projection_on_iff_orthog[THEN iffD2, rule_format])
   show clAB: \<open>closed_csubspace (A +\<^sub>M B)\<close>
     by (simp add: assms(2) assms(3) closed_subspace_closed_sum)
   fix h
   have 1: \<open>\<pi>A h + \<pi>B h \<in> A +\<^sub>M B\<close>
     by (meson clAB assms(2) assms(3) assms(4) assms(5) closed_csubspace_def closed_sum_left_subset closed_sum_right_subset complex_vector.subspace_def in_mono is_projection_on_in_image)
 
   have \<open>\<pi>A (\<pi>B h) = 0\<close>
     by (smt (verit, del_insts) assms(1) assms(2) assms(4) assms(5) cinner_eq_zero_iff is_cadjoint_def is_projection_on_in_image is_projection_on_is_cadjoint)
   then have \<open>h - (\<pi>A h + \<pi>B h) = (h - \<pi>B h) - \<pi>A (h - \<pi>B h)\<close>
     by (smt (verit) add.right_neutral add_diff_cancel_left' assms(2) assms(4) closed_csubspace.subspace complex_vector.subspace_diff diff_add_eq_diff_diff_swap diff_diff_add is_projection_on_iff_orthog orthog_proj_unique orthogonal_complement_closed_subspace)
   also have \<open>\<dots> \<in> orthogonal_complement A\<close>
     using assms(2) assms(4) is_projection_on_iff_orthog by blast
   finally have orthoA: \<open>h - (\<pi>A h + \<pi>B h) \<in> orthogonal_complement A\<close>
     by -
 
   have \<open>\<pi>B (\<pi>A h) = 0\<close>
     by (smt (verit, del_insts) assms(1) assms(3) assms(4) assms(5) cinner_eq_zero_iff is_cadjoint_def is_projection_on_in_image is_projection_on_is_cadjoint)
   then have \<open>h - (\<pi>A h + \<pi>B h) = (h - \<pi>A h) - \<pi>B (h - \<pi>A h)\<close>
     by (smt (verit) add.right_neutral add_diff_cancel assms(3) assms(5) closed_csubspace.subspace complex_vector.subspace_diff diff_add_eq_diff_diff_swap diff_diff_add is_projection_on_iff_orthog orthog_proj_unique orthogonal_complement_closed_subspace)
   also have \<open>\<dots> \<in> orthogonal_complement B\<close>
     using assms(3) assms(5) is_projection_on_iff_orthog by blast
   finally have orthoB: \<open>h - (\<pi>A h + \<pi>B h) \<in> orthogonal_complement B\<close>
     by -
 
   from orthoA orthoB
   have 2: \<open>h - (\<pi>A h + \<pi>B h) \<in> orthogonal_complement (A +\<^sub>M B)\<close>
     by (metis IntI assms(2) assms(3) closed_csubspace_def complex_vector.subspace_def de_morgan_orthogonal_complement_plus)
 
   from 1 2 show \<open>h - (\<pi>A h + \<pi>B h) \<in> orthogonal_complement (A +\<^sub>M B) \<and> \<pi>A h + \<pi>B h \<in> A +\<^sub>M B\<close>
     by simp
 qed
 
 lemma projection_plus:
   fixes A B :: "'a::chilbert_space set"
   assumes "\<And>x y. x:A \<Longrightarrow> y:B \<Longrightarrow> is_orthogonal x y"
   assumes \<open>closed_csubspace A\<close>
   assumes \<open>closed_csubspace B\<close>
   shows \<open>projection (A +\<^sub>M B) = (\<lambda>x. projection A x + projection B x)\<close>
 proof -
   have \<open>is_projection_on (\<lambda>x. projection A x + projection B x) (A +\<^sub>M B)\<close>
     apply (rule is_projection_on_plus)
     using assms by auto
   then show ?thesis
     by (meson assms(2) assms(3) closed_csubspace.subspace closed_subspace_closed_sum csubspace_is_convex projection_eqI')
 qed
 
 lemma is_projection_on_insert:
   assumes ortho: "\<And>s. s \<in> S \<Longrightarrow> \<langle>a, s\<rangle> = 0"
   assumes \<open>is_projection_on \<pi> (closure (cspan S))\<close>
   assumes \<open>is_projection_on \<pi>a (cspan {a})\<close>
   shows "is_projection_on (\<lambda>x. \<pi>a x + \<pi> x) (closure (cspan (insert a S)))"
 proof -
   from ortho
   have \<open>x \<in> cspan {a} \<Longrightarrow> y \<in> closure (cspan S) \<Longrightarrow> is_orthogonal x y\<close> for x y
     using is_orthogonal_cspan is_orthogonal_closure is_orthogonal_sym
     by (smt (verit, ccfv_threshold) empty_iff insert_iff)
   then have \<open>is_projection_on (\<lambda>x. \<pi>a x + \<pi> x) (cspan {a} +\<^sub>M closure (cspan S))\<close>
     apply (rule is_projection_on_plus)
     using assms by (auto simp add: closed_csubspace.intro)
   also have \<open>\<dots> = closure (cspan (insert a S))\<close>
     using closed_sum_cspan[where X=\<open>{a}\<close>] by simp
   finally show ?thesis
     by -
 qed
 
 lemma projection_insert:
   fixes a :: \<open>'a::chilbert_space\<close>
   assumes a1: "\<And>s. s \<in> S \<Longrightarrow> \<langle>a, s\<rangle> = 0"
   shows "projection (closure (cspan (insert a S))) u
         = projection (cspan {a}) u + projection (closure (cspan S)) u"
   using is_projection_on_insert[where S=S, OF a1]
   by (metis (no_types, lifting) closed_closure closed_csubspace.intro closure_is_csubspace complex_vector.subspace_span csubspace_is_convex finite.intros(1) finite.intros(2) finite_cspan_closed_csubspace projection_eqI' projection_is_projection_on')
 
 lemma projection_insert_finite:
   assumes a1: "\<And>s. s \<in> S \<Longrightarrow> \<langle>a, s\<rangle> = 0" and a2: "finite (S::'a::chilbert_space set)"
   shows "projection (cspan (insert a S)) u
         = projection (cspan {a}) u + projection (cspan S) u"
   using projection_insert
-  by (metis a1 a2 closure_finite_cspan finite.insertI) 
+  by (metis a1 a2 closure_finite_cspan finite.insertI)
 
 subsection \<open>Canonical basis (\<open>onb_enum\<close>)\<close>
 
 setup \<open>Sign.add_const_constraint (\<^const_name>\<open>is_ortho_set\<close>, SOME \<^typ>\<open>'a set \<Rightarrow> bool\<close>)\<close>
 
 class onb_enum = basis_enum + complex_inner +
   assumes is_orthonormal: "is_ortho_set (set canonical_basis)"
     and is_normal: "\<And>x. x \<in> (set canonical_basis) \<Longrightarrow> norm x = 1"
 
 setup \<open>Sign.add_const_constraint (\<^const_name>\<open>is_ortho_set\<close>, SOME \<^typ>\<open>'a::complex_inner set \<Rightarrow> bool\<close>)\<close>
 
 lemma cinner_canonical_basis:
   assumes \<open>i < length (canonical_basis :: 'a::onb_enum list)\<close>
   assumes \<open>j < length (canonical_basis :: 'a::onb_enum list)\<close>
   shows \<open>cinner (canonical_basis!i :: 'a) (canonical_basis!j) = (if i=j then 1 else 0)\<close>
   by (metis assms(1) assms(2) distinct_canonical_basis is_normal is_ortho_set_def is_orthonormal nth_eq_iff_index_eq nth_mem of_real_1 power2_norm_eq_cinner power_one)
 
 instance onb_enum \<subseteq> chilbert_space
 proof
   show "convergent X"
     if "Cauchy X"
     for X :: "nat \<Rightarrow> 'a"
   proof-
     have \<open>finite (set canonical_basis)\<close>
       by simp
     have \<open>Cauchy (\<lambda> n. \<langle> t, X n \<rangle>)\<close> for t
       by (simp add: bounded_clinear.Cauchy bounded_clinear_cinner_right that)
     hence \<open>convergent (\<lambda> n. \<langle> t, X n \<rangle>)\<close>
       for t
-      by (simp add: Cauchy_convergent_iff)      
+      by (simp add: Cauchy_convergent_iff)
     hence \<open>\<forall> t\<in>set canonical_basis. \<exists> L. (\<lambda> n. \<langle> t, X n \<rangle>) \<longlonglongrightarrow> L\<close>
       by (simp add: convergentD)
     hence \<open>\<exists> L. \<forall> t\<in>set canonical_basis. (\<lambda> n. \<langle> t, X n \<rangle>) \<longlonglongrightarrow> L t\<close>
       by metis
     then obtain L where \<open>\<And> t. t\<in>set canonical_basis \<Longrightarrow> (\<lambda> n. \<langle> t, X n \<rangle>) \<longlonglongrightarrow> L t\<close>
       by blast
     define l where \<open>l = (\<Sum>t\<in>set canonical_basis. L t *\<^sub>C t)\<close>
     have x1: \<open>X n = (\<Sum>t\<in>set canonical_basis. \<langle> t, X n \<rangle> *\<^sub>C t)\<close>
       for n
       using onb_expansion_finite[where T = "set canonical_basis" and x = "X n"]
-        \<open>finite (set canonical_basis)\<close> 
+        \<open>finite (set canonical_basis)\<close>
       by (smt is_generator_set is_normal is_orthonormal)
 
-    have \<open>(\<lambda> n. \<langle> t, X n \<rangle> *\<^sub>C t) \<longlonglongrightarrow> L t *\<^sub>C t\<close> 
+    have \<open>(\<lambda> n. \<langle> t, X n \<rangle> *\<^sub>C t) \<longlonglongrightarrow> L t *\<^sub>C t\<close>
       if r1: \<open>t\<in>set canonical_basis\<close>
       for t
     proof-
       have \<open>(\<lambda> n. \<langle> t, X n \<rangle>) \<longlonglongrightarrow> L t\<close>
         using r1  \<open>\<And> t. t\<in>set canonical_basis \<Longrightarrow> (\<lambda> n. \<langle> t, X n \<rangle>) \<longlonglongrightarrow> L t\<close>
         by blast
       define f where \<open>f x = x *\<^sub>C t\<close> for x
       have \<open>isCont f r\<close>
         for r
         unfolding f_def
         by (simp add: bounded_clinear_scaleC_left clinear_continuous_at)
       hence \<open>(\<lambda> n. f \<langle> t, X n \<rangle>) \<longlonglongrightarrow> f (L t)\<close>
         using \<open>(\<lambda>n. \<langle>t, X n\<rangle>) \<longlonglongrightarrow> L t\<close> isCont_tendsto_compose by blast
       hence \<open>(\<lambda> n. \<langle> t, X n \<rangle> *\<^sub>C t) \<longlonglongrightarrow> L t *\<^sub>C t\<close>
         unfolding f_def
         by simp
       thus ?thesis by blast
     qed
     hence \<open>(\<lambda> n. (\<Sum>t\<in>set canonical_basis. \<langle> t, X n \<rangle> *\<^sub>C t))
     \<longlonglongrightarrow>  (\<Sum>t\<in>set canonical_basis. L t *\<^sub>C t)\<close>
       using \<open>finite (set canonical_basis)\<close>
         tendsto_sum[where I = "set canonical_basis" and f = "\<lambda> t. \<lambda> n. \<langle>t, X n\<rangle> *\<^sub>C t"
           and a = "\<lambda> t. L t *\<^sub>C t"]
-      by auto      
+      by auto
     hence x2: \<open>(\<lambda> n. (\<Sum>t\<in>set canonical_basis. \<langle> t, X n \<rangle> *\<^sub>C t)) \<longlonglongrightarrow> l\<close>
-      using l_def by blast 
+      using l_def by blast
     have \<open>X \<longlonglongrightarrow> l\<close>
       using x1 x2 by simp
-    thus ?thesis 
+    thus ?thesis
       unfolding convergent_def by blast
   qed
 qed
 
 subsection \<open>Conjugate space\<close>
 
 instantiation conjugate_space :: (complex_inner) complex_inner begin
 lift_definition cinner_conjugate_space :: "'a conjugate_space \<Rightarrow> 'a conjugate_space \<Rightarrow> complex" is
   \<open>\<lambda>x y. cinner y x\<close>.
 instance
   apply (intro_classes; transfer)
        apply (simp_all add: )
     apply (simp add: cinner_add_right)
   using cinner_ge_zero norm_eq_sqrt_cinner by auto
 end
 
 instance conjugate_space :: (chilbert_space) chilbert_space..
 
 end
diff --git a/thys/Complex_Bounded_Operators/Complex_Inner_Product0.thy b/thys/Complex_Bounded_Operators/Complex_Inner_Product0.thy
--- a/thys/Complex_Bounded_Operators/Complex_Inner_Product0.thy
+++ b/thys/Complex_Bounded_Operators/Complex_Inner_Product0.thy
@@ -1,548 +1,548 @@
 (*  Based on HOL/Real_Vector_Spaces.thy by Brian Huffman
     Adapted to the complex case by Dominique Unruh *)
 
 section \<open>\<open>Complex_Inner_Product0\<close> -- Inner Product Spaces and Gradient Derivative\<close>
 
 theory Complex_Inner_Product0
   imports
     Complex_Main Complex_Vector_Spaces
     "HOL-Analysis.Inner_Product"
     "Complex_Bounded_Operators.Extra_Ordered_Fields"
 begin
 
 subsection \<open>Complex inner product spaces\<close>
 
 text \<open>
   Temporarily relax type constraints for \<^term>\<open>open\<close>, \<^term>\<open>uniformity\<close>,
   \<^term>\<open>dist\<close>, and \<^term>\<open>norm\<close>.
 \<close>
 
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>open\<close>, SOME \<^typ>\<open>'a::open set \<Rightarrow> bool\<close>)\<close>
 
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>dist\<close>, SOME \<^typ>\<open>'a::dist \<Rightarrow> 'a \<Rightarrow> real\<close>)\<close>
 
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>uniformity\<close>, SOME \<^typ>\<open>('a::uniformity \<times> 'a) filter\<close>)\<close>
 
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>norm\<close>, SOME \<^typ>\<open>'a::norm \<Rightarrow> real\<close>)\<close>
 
 class complex_inner = complex_vector + sgn_div_norm + dist_norm + uniformity_dist + open_uniformity +
   fixes cinner :: "'a \<Rightarrow> 'a \<Rightarrow> complex"
   assumes cinner_commute: "cinner x y = cnj (cinner y x)"
     and cinner_add_left: "cinner (x + y) z = cinner x z + cinner y z"
     and cinner_scaleC_left [simp]: "cinner (scaleC r x) y = (cnj r) * (cinner x y)"
     and cinner_ge_zero [simp]: "0 \<le> cinner x x"
     and cinner_eq_zero_iff [simp]: "cinner x x = 0 \<longleftrightarrow> x = 0"
     and norm_eq_sqrt_cinner: "norm x = sqrt (cmod (cinner x x))"
 begin
 
 lemma cinner_zero_left [simp]: "cinner 0 x = 0"
   using cinner_add_left [of 0 0 x] by simp
 
 lemma cinner_minus_left [simp]: "cinner (- x) y = - cinner x y"
   using cinner_add_left [of x "- x" y]
   by (simp add: group_add_class.add_eq_0_iff)
 
 lemma cinner_diff_left: "cinner (x - y) z = cinner x z - cinner y z"
   using cinner_add_left [of x "- y" z] by simp
 
 lemma cinner_sum_left: "cinner (\<Sum>x\<in>A. f x) y = (\<Sum>x\<in>A. cinner (f x) y)"
   by (cases "finite A", induct set: finite, simp_all add: cinner_add_left)
 
 lemma call_zero_iff [simp]: "(\<forall>u. cinner x u = 0) \<longleftrightarrow> (x = 0)"
   by auto (use cinner_eq_zero_iff in blast)
 
 text \<open>Transfer distributivity rules to right argument.\<close>
 
 lemma cinner_add_right: "cinner x (y + z) = cinner x y + cinner x z"
   using cinner_add_left [of y z x]
   by (metis complex_cnj_add local.cinner_commute)
 
 lemma cinner_scaleC_right [simp]: "cinner x (scaleC r y) = r * (cinner x y)"
   using cinner_scaleC_left [of r y x]
   by (metis complex_cnj_cnj complex_cnj_mult local.cinner_commute)
 
 lemma cinner_zero_right [simp]: "cinner x 0 = 0"
   using cinner_zero_left [of x]
-  by (metis (mono_tags, hide_lams) complex_cnj_zero local.cinner_commute)
+  by (metis (mono_tags, opaque_lifting) complex_cnj_zero local.cinner_commute)
 
 lemma cinner_minus_right [simp]: "cinner x (- y) = - cinner x y"
   using cinner_minus_left [of y x]
   by (metis complex_cnj_minus local.cinner_commute)
 
 lemma cinner_diff_right: "cinner x (y - z) = cinner x y - cinner x z"
   using cinner_diff_left [of y z x]
   by (metis complex_cnj_diff local.cinner_commute)
 
 lemma cinner_sum_right: "cinner x (\<Sum>y\<in>A. f y) = (\<Sum>y\<in>A. cinner x (f y))"
 proof (subst cinner_commute)
-  have "(\<Sum>y\<in>A. cinner (f y) x) = (\<Sum>y\<in>A. cinner (f y) x)" 
-    by blast   
+  have "(\<Sum>y\<in>A. cinner (f y) x) = (\<Sum>y\<in>A. cinner (f y) x)"
+    by blast
   hence "cnj (\<Sum>y\<in>A. cinner (f y) x) = cnj (\<Sum>y\<in>A. (cinner (f y) x))"
     by simp
   hence "cnj (cinner (sum f A) x) = (\<Sum>y\<in>A. cnj (cinner (f y) x))"
     by (simp add: cinner_sum_left)
   thus "cnj (cinner (sum f A) x) = (\<Sum>y\<in>A. (cinner x (f y)))"
-    by (subst (2) cinner_commute)    
+    by (subst (2) cinner_commute)
 qed
 
 lemmas cinner_add [algebra_simps] = cinner_add_left cinner_add_right
 lemmas cinner_diff [algebra_simps]  = cinner_diff_left cinner_diff_right
 lemmas cinner_scaleC = cinner_scaleC_left cinner_scaleC_right
 
 (* text \<open>Legacy theorem names\<close>
 lemmas cinner_left_distrib = cinner_add_left
 lemmas cinner_right_distrib = cinner_add_right
 lemmas cinner_distrib = cinner_left_distrib cinner_right_distrib *)
 
 lemma cinner_gt_zero_iff [simp]: "0 < cinner x x \<longleftrightarrow> x \<noteq> 0"
   by (smt (verit) less_irrefl local.cinner_eq_zero_iff local.cinner_ge_zero order.not_eq_order_implies_strict)
 
 (* In Inner_Product, we have
   lemma power2_norm_eq_cinner: "(norm x)\<^sup>2 = cinner x x"
 The following are two ways of inserting the conversions between real and complex into this:
 *)
 
 lemma power2_norm_eq_cinner:
   shows "(complex_of_real (norm x))\<^sup>2 = (cinner x x)"
   by (smt (verit, del_insts) Im_complex_of_real Re_complex_of_real cinner_gt_zero_iff cinner_zero_right cmod_def complex_eq_0 complex_eq_iff less_complex_def local.norm_eq_sqrt_cinner of_real_power real_sqrt_abs real_sqrt_pow2_iff zero_complex.sel(1))
 
 lemma power2_norm_eq_cinner':
   shows "(norm x)\<^sup>2 = Re (cinner x x)"
   by (metis Re_complex_of_real of_real_power power2_norm_eq_cinner)
 
 text \<open>Identities involving real multiplication and division.\<close>
 
 lemma cinner_mult_left: "cinner (of_complex m * a) b = cnj m * (cinner a b)"
   by (simp add: of_complex_def)
 
 lemma cinner_mult_right: "cinner a (of_complex m * b) = m * (cinner a b)"
   by (metis complex_inner_class.cinner_scaleC_right scaleC_conv_of_complex)
 
 lemma cinner_mult_left': "cinner (a * of_complex m) b = cnj m * (cinner a b)"
   by (metis cinner_mult_left mult.right_neutral mult_scaleC_right scaleC_conv_of_complex)
 
 lemma cinner_mult_right': "cinner a (b * of_complex m) = (cinner a b) * m"
   by (simp add: complex_inner_class.cinner_scaleC_right of_complex_def)
 
 (* In Inner_Product, we have
 lemma Cauchy_Schwarz_ineq:
   "(cinner x y)\<^sup>2 \<le> cinner x x * cinner y y"
 The following are two ways of inserting the conversions between real and complex into this:
 *)
 
 lemma Cauchy_Schwarz_ineq:
   "(cinner x y) * (cinner y x) \<le> cinner x x * cinner y y"
 proof (cases)
   assume "y = 0"
   thus ?thesis by simp
 next
   assume y: "y \<noteq> 0"
   have [simp]: "cnj (cinner y y) = cinner y y" for y
     by (metis cinner_commute)
   define r where "r = cnj (cinner x y) / cinner y y"
   have "0 \<le> cinner (x - scaleC r y) (x - scaleC r y)"
     by (rule cinner_ge_zero)
   also have "\<dots> = cinner x x - r * cinner x y - cnj r * cinner y x + r * cnj r * cinner y y"
     unfolding cinner_diff_left cinner_diff_right cinner_scaleC_left cinner_scaleC_right
     by (smt (z3) cancel_comm_monoid_add_class.diff_cancel cancel_comm_monoid_add_class.diff_zero complex_cnj_divide group_add_class.diff_add_cancel local.cinner_commute local.cinner_eq_zero_iff local.cinner_scaleC_left mult.assoc mult.commute mult_eq_0_iff nonzero_eq_divide_eq r_def y)
   also have "\<dots> = cinner x x - cinner y x * cnj r"
     unfolding r_def by auto
   also have "\<dots> = cinner x x - cinner x y * cnj (cinner x y) / cinner y y"
     unfolding r_def
     by (metis complex_cnj_divide local.cinner_commute mult.commute times_divide_eq_left)
   finally have "0 \<le> cinner x x - cinner x y * cnj (cinner x y) / cinner y y" .
   hence "cinner x y * cnj (cinner x y) / cinner y y \<le> cinner x x"
     by (simp add: le_diff_eq)
   thus "cinner x y * cinner y x \<le> cinner x x * cinner y y"
     by (metis cinner_gt_zero_iff local.cinner_commute nice_ordered_field_class.pos_divide_le_eq y)
 qed
 
 
 lemma Cauchy_Schwarz_ineq2:
   shows "norm (cinner x y) \<le> norm x * norm y"
 proof (rule power2_le_imp_le)
   have "(norm (cinner x y))^2 = Re (cinner x y * cinner y x)"
     by (metis (full_types) Re_complex_of_real complex_norm_square local.cinner_commute)
   also have "\<dots> \<le> Re (cinner x x * cinner y y)"
     using Cauchy_Schwarz_ineq by (rule Re_mono)
   also have "\<dots> = Re (complex_of_real ((norm x)^2) * complex_of_real ((norm y)^2))"
     by (simp add: power2_norm_eq_cinner)
   also have "\<dots> = (norm x * norm y)\<^sup>2"
     by (simp add: power_mult_distrib)
   finally show "(cmod (cinner x y))^2 \<le> (norm x * norm y)\<^sup>2" .
   show "0 \<le> norm x * norm y"
     by (simp add: local.norm_eq_sqrt_cinner)
 qed
 
 (* The following variant does not hold in the complex case: *)
 (* lemma norm_cauchy_schwarz: "cinner x y \<le> norm x * norm y"
   using Cauchy_Schwarz_ineq2 [of x y] by auto *)
 
 subclass complex_normed_vector
 proof
   fix a :: complex and r :: real and x y :: 'a
   show "norm x = 0 \<longleftrightarrow> x = 0"
     unfolding norm_eq_sqrt_cinner by simp
   show "norm (x + y) \<le> norm x + norm y"
   proof (rule power2_le_imp_le)
     have "Re (cinner x y) \<le> cmod (cinner x y)"
       if "\<And>x. Re x \<le> cmod x" and
         "\<And>x y. x \<le> y \<Longrightarrow> complex_of_real x \<le> complex_of_real y"
       using that by simp
     hence a1: "2 * Re (cinner x y) \<le> 2 * cmod (cinner x y)"
       if "\<And>x. Re x \<le> cmod x" and
         "\<And>x y. x \<le> y \<Longrightarrow> complex_of_real x \<le> complex_of_real y"
       using that by simp
     have "cinner x y + cinner y x = complex_of_real (2 * Re (cinner x y))"
       by (metis complex_add_cnj local.cinner_commute)
     also have "\<dots> \<le> complex_of_real (2 * cmod (cinner x y))"
       using complex_Re_le_cmod complex_of_real_mono a1
-      by blast      
+      by blast
     also have "\<dots> = 2 * abs (cinner x y)"
       unfolding abs_complex_def by simp
     also have "\<dots> \<le> 2 * complex_of_real (norm x) * complex_of_real (norm y)"
       using Cauchy_Schwarz_ineq2 unfolding abs_complex_def by auto
-    finally have xyyx: "cinner x y + cinner y x \<le> complex_of_real (2 * norm x * norm y)" 
+    finally have xyyx: "cinner x y + cinner y x \<le> complex_of_real (2 * norm x * norm y)"
       by auto
     have "complex_of_real ((norm (x + y))\<^sup>2) = cinner (x+y) (x+y)"
       by (simp add: power2_norm_eq_cinner)
     also have "\<dots> = cinner x x + cinner x y + cinner y x + cinner y y"
       by (simp add: cinner_add)
     also have "\<dots> = complex_of_real ((norm x)\<^sup>2) + complex_of_real ((norm y)\<^sup>2) + cinner x y + cinner y x"
       by (simp add: power2_norm_eq_cinner)
     also have "\<dots> \<le> complex_of_real ((norm x)\<^sup>2) + complex_of_real ((norm y)\<^sup>2) + complex_of_real (2 * norm x * norm y)"
       using xyyx by auto
     also have "\<dots> = complex_of_real ((norm x + norm y)\<^sup>2)"
       unfolding power2_sum by auto
     finally show "(norm (x + y))\<^sup>2 \<le> (norm x + norm y)\<^sup>2"
       using complex_of_real_mono_iff by blast
     show "0 \<le> norm x + norm y"
       unfolding norm_eq_sqrt_cinner by simp
   qed
   show norm_scaleC: "norm (a *\<^sub>C x) = cmod a * norm x" for a
   proof (rule power2_eq_imp_eq)
     show "(norm (a *\<^sub>C x))\<^sup>2 = (cmod a * norm x)\<^sup>2"
       by (simp_all add: norm_eq_sqrt_cinner norm_mult power2_eq_square)
     show "0 \<le> norm (a *\<^sub>C x)"
-      by (simp_all add: norm_eq_sqrt_cinner)     
+      by (simp_all add: norm_eq_sqrt_cinner)
     show "0 \<le> cmod a * norm x"
-      by (simp_all add: norm_eq_sqrt_cinner)     
+      by (simp_all add: norm_eq_sqrt_cinner)
   qed
   show "norm (r *\<^sub>R x) = \<bar>r\<bar> * norm x"
     unfolding scaleR_scaleC norm_scaleC by auto
 qed
 
 end
 
 (* Does not hold in the complex case *)
 (* lemma csquare_bound_lemma:
   fixes x :: complex
   shows "x < (1 + x) * (1 + x)" *)
 
 lemma csquare_continuous:
   fixes e :: real
   shows "e > 0 \<Longrightarrow> \<exists>d. 0 < d \<and> (\<forall>y. cmod (y - x) < d \<longrightarrow> cmod (y * y - x * x) < e)"
   using isCont_power[OF continuous_ident, of x, unfolded isCont_def LIM_eq, rule_format, of e 2]
   by (force simp add: power2_eq_square)
 
 lemma cnorm_le: "norm x \<le> norm y \<longleftrightarrow> cinner x x \<le> cinner y y"
   by (smt (verit) complex_of_real_mono_iff norm_eq_sqrt_cinner norm_ge_zero of_real_power power2_norm_eq_cinner real_sqrt_le_mono real_sqrt_pow2)
 
 lemma cnorm_lt: "norm x < norm y \<longleftrightarrow> cinner x x < cinner y y"
   by (meson cnorm_le less_le_not_le)
 
 lemma cnorm_eq: "norm x = norm y \<longleftrightarrow> cinner x x = cinner y y"
   by (metis norm_eq_sqrt_cinner power2_norm_eq_cinner)
 
 lemma cnorm_eq_1: "norm x = 1 \<longleftrightarrow> cinner x x = 1"
   by (metis cinner_ge_zero complex_of_real_cmod norm_eq_sqrt_cinner norm_one of_real_1 real_sqrt_eq_iff real_sqrt_one)
 
 lemma cinner_divide_left:
   fixes a :: "'a :: {complex_inner,complex_div_algebra}"
   shows "cinner (a / of_complex m) b = (cinner a b) / cnj m"
   by (metis cinner_mult_left' complex_cnj_inverse divide_inverse of_complex_inverse ordered_field_class.sign_simps(33))
 
 lemma cinner_divide_right:
   fixes a :: "'a :: {complex_inner,complex_div_algebra}"
   shows "cinner a (b / of_complex m) = (cinner a b) / m"
   by (metis cinner_mult_right' divide_inverse of_complex_inverse)
 
 text \<open>
   Re-enable constraints for \<^term>\<open>open\<close>, \<^term>\<open>uniformity\<close>,
   \<^term>\<open>dist\<close>, and \<^term>\<open>norm\<close>.
 \<close>
 
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>open\<close>, SOME \<^typ>\<open>'a::topological_space set \<Rightarrow> bool\<close>)\<close>
 
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>uniformity\<close>, SOME \<^typ>\<open>('a::uniform_space \<times> 'a) filter\<close>)\<close>
 
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>dist\<close>, SOME \<^typ>\<open>'a::metric_space \<Rightarrow> 'a \<Rightarrow> real\<close>)\<close>
 
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>norm\<close>, SOME \<^typ>\<open>'a::real_normed_vector \<Rightarrow> real\<close>)\<close>
 
 
 lemma bounded_sesquilinear_cinner:
   "bounded_sesquilinear (cinner::'a::complex_inner \<Rightarrow> 'a \<Rightarrow> complex)"
 proof
   fix x y z :: 'a and r :: complex
   show "cinner (x + y) z = cinner x z + cinner y z"
     by (rule cinner_add_left)
   show "cinner x (y + z) = cinner x y + cinner x z"
     by (rule cinner_add_right)
   show "cinner (scaleC r x) y = scaleC (cnj r) (cinner x y)"
     unfolding complex_scaleC_def by (rule cinner_scaleC_left)
   show "cinner x (scaleC r y) = scaleC r (cinner x y)"
     unfolding complex_scaleC_def by (rule cinner_scaleC_right)
   have "\<forall>x y::'a. norm (cinner x y) \<le> norm x * norm y * 1"
     by (simp add: complex_inner_class.Cauchy_Schwarz_ineq2)
   thus "\<exists>K. \<forall>x y::'a. norm (cinner x y) \<le> norm x * norm y * K"
     by metis
 qed
 
 lemmas tendsto_cinner [tendsto_intros] =
   bounded_bilinear.tendsto [OF bounded_sesquilinear_cinner[THEN bounded_sesquilinear.bounded_bilinear]]
 
 lemmas isCont_cinner [simp] =
   bounded_bilinear.isCont [OF bounded_sesquilinear_cinner[THEN bounded_sesquilinear.bounded_bilinear]]
 
 lemmas has_derivative_cinner [derivative_intros] =
   bounded_bilinear.FDERIV [OF bounded_sesquilinear_cinner[THEN bounded_sesquilinear.bounded_bilinear]]
 
 lemmas bounded_antilinear_cinner_left =
   bounded_sesquilinear.bounded_antilinear_left [OF bounded_sesquilinear_cinner]
 
 lemmas bounded_clinear_cinner_right =
   bounded_sesquilinear.bounded_clinear_right [OF bounded_sesquilinear_cinner]
 
 lemmas bounded_antilinear_cinner_left_comp = bounded_antilinear_cinner_left[THEN bounded_antilinear_o_bounded_clinear]
 
 lemmas bounded_clinear_cinner_right_comp = bounded_clinear_cinner_right[THEN bounded_clinear_compose]
 
 lemmas has_derivative_cinner_right [derivative_intros] =
   bounded_linear.has_derivative [OF bounded_clinear_cinner_right[THEN bounded_clinear.bounded_linear]]
 
 lemmas has_derivative_cinner_left [derivative_intros] =
   bounded_linear.has_derivative [OF bounded_antilinear_cinner_left[THEN bounded_antilinear.bounded_linear]]
 
 lemma differentiable_cinner [simp]:
   "f differentiable (at x within s) \<Longrightarrow> g differentiable at x within s \<Longrightarrow> (\<lambda>x. cinner (f x) (g x)) differentiable at x within s"
   unfolding differentiable_def by (blast intro: has_derivative_cinner)
 
 
 subsection \<open>Class instances\<close>
 
 instantiation complex :: complex_inner
 begin
 
 definition cinner_complex_def [simp]: "cinner x y = cnj x * y"
 
 instance
 proof
   fix x y z r :: complex
   show "cinner x y = cnj (cinner y x)"
     unfolding cinner_complex_def by auto
   show "cinner (x + y) z = cinner x z + cinner y z"
     unfolding cinner_complex_def
     by (simp add: ring_class.ring_distribs(2))
   show "cinner (scaleC r x) y = cnj r * cinner x y"
     unfolding cinner_complex_def complex_scaleC_def by simp
   show "0 \<le> cinner x x"
     by simp
   show "cinner x x = 0 \<longleftrightarrow> x = 0"
     unfolding cinner_complex_def by simp
   have "cmod (Complex x1 x2) = sqrt (cmod (cinner (Complex x1 x2) (Complex x1 x2)))"
     for x1 x2
     unfolding cinner_complex_def complex_cnj complex_mult complex_norm
     by (simp add: power2_eq_square)
   thus "norm x = sqrt (cmod (cinner x x))"
-    by (cases x, hypsubst_thin) 
+    by (cases x, hypsubst_thin)
 qed
 
 end
 
 lemma
   shows complex_inner_1_left[simp]: "cinner 1 x = x"
     and complex_inner_1_right[simp]: "cinner x 1 = cnj x"
   by simp_all
 
 (* No analogous to \<open>instantiation complex :: real_inner\<close> or to
 lemma complex_inner_1 [simp]: "inner 1 x = Re x"
 lemma complex_inner_1_right [simp]: "inner x 1 = Re x"
 lemma complex_inner_i_left [simp]: "inner \<i> x = Im x"
 lemma complex_inner_i_right [simp]: "inner x \<i> = Im x"
  *)
 
 lemma cdot_square_norm: "cinner x x = complex_of_real ((norm x)\<^sup>2)"
   by (metis Im_complex_of_real Re_complex_of_real cinner_ge_zero complex_eq_iff less_eq_complex_def power2_norm_eq_cinner' zero_complex.simps(2))
 
 lemma cnorm_eq_square: "norm x = a \<longleftrightarrow> 0 \<le> a \<and> cinner x x = complex_of_real (a\<^sup>2)"
   by (metis cdot_square_norm norm_ge_zero of_real_eq_iff power2_eq_iff_nonneg)
 
 lemma cnorm_le_square: "norm x \<le> a \<longleftrightarrow> 0 \<le> a \<and> cinner x x \<le> complex_of_real (a\<^sup>2)"
   by (smt (verit) cdot_square_norm complex_of_real_mono_iff norm_ge_zero power2_le_imp_le)
 
 lemma cnorm_ge_square: "norm x \<ge> a \<longleftrightarrow> a \<le> 0 \<or> cinner x x \<ge> complex_of_real (a\<^sup>2)"
   by (smt (verit, best) antisym_conv cnorm_eq_square cnorm_le_square complex_of_real_nn_iff nn_comparable zero_le_power2)
 
 lemma norm_lt_square: "norm x < a \<longleftrightarrow> 0 < a \<and> cinner x x < complex_of_real (a\<^sup>2)"
   by (meson cnorm_ge_square cnorm_le_square less_le_not_le)
 
 lemma norm_gt_square: "norm x > a \<longleftrightarrow> a < 0 \<or> cinner x x > complex_of_real (a\<^sup>2)"
   by (smt (verit, ccfv_SIG) cdot_square_norm complex_of_real_strict_mono_iff norm_ge_zero power2_eq_imp_eq power_mono)
 
 text\<open>Dot product in terms of the norm rather than conversely.\<close>
 
 lemmas cinner_simps = cinner_add_left cinner_add_right cinner_diff_right cinner_diff_left
   cinner_scaleC_left cinner_scaleC_right
 
 (* Analogue to both dot_norm and dot_norm_neg *)
 lemma cdot_norm: "cinner x y = ((norm (x+y))\<^sup>2 - (norm (x-y))\<^sup>2 - \<i> * (norm (x + \<i> *\<^sub>C y))\<^sup>2 + \<i> * (norm (x - \<i> *\<^sub>C y))\<^sup>2) / 4"
   unfolding power2_norm_eq_cinner
-  by (simp add: power2_norm_eq_cinner cinner_add_left cinner_add_right 
+  by (simp add: power2_norm_eq_cinner cinner_add_left cinner_add_right
       cinner_diff_left cinner_diff_right ring_distribs)
 
-lemma of_complex_inner_1 [simp]: 
+lemma of_complex_inner_1 [simp]:
   "cinner (of_complex x) (1 :: 'a :: {complex_inner, complex_normed_algebra_1}) = cnj x"
   by (metis Complex_Inner_Product0.complex_inner_1_right cinner_complex_def cinner_mult_left complex_cnj_one norm_one of_complex_def power2_norm_eq_cinner scaleC_conv_of_complex)
 
-lemma summable_of_complex_iff: 
+lemma summable_of_complex_iff:
   "summable (\<lambda>x. of_complex (f x) :: 'a :: {complex_normed_algebra_1,complex_inner}) \<longleftrightarrow> summable f"
 proof
   assume *: "summable (\<lambda>x. of_complex (f x) :: 'a)"
   have "bounded_clinear (cinner (1::'a))"
     by (rule bounded_clinear_cinner_right)
   then interpret bounded_linear "\<lambda>x::'a. cinner 1 x"
     by (rule bounded_clinear.bounded_linear)
   from summable [OF *] show "summable f"
     apply (subst (asm) cinner_commute) by simp
 next
   assume sum: "summable f"
   thus "summable (\<lambda>x. of_complex (f x) :: 'a)"
     by (rule summable_of_complex)
 qed
 
 subsection \<open>Gradient derivative\<close>
 
 definition\<^marker>\<open>tag important\<close>
   cgderiv :: "['a::complex_inner \<Rightarrow> complex, 'a, 'a] \<Rightarrow> bool"
   ("(cGDERIV (_)/ (_)/ :> (_))" [1000, 1000, 60] 60)
   where
     (* Must be "cinner D" not "\<lambda>h. cinner h D", otherwise not even "cGDERIV id x :> 1" holds *)
     "cGDERIV f x :> D \<longleftrightarrow> FDERIV f x :> cinner D"
 
 lemma cgderiv_deriv [simp]: "cGDERIV f x :> D \<longleftrightarrow> DERIV f x :> cnj D"
   by (simp only: cgderiv_def has_field_derivative_def cinner_complex_def[THEN ext])
 
 lemma cGDERIV_DERIV_compose:
   assumes "cGDERIV f x :> df" and "DERIV g (f x) :> cnj dg"
   shows "cGDERIV (\<lambda>x. g (f x)) x :> scaleC dg df"
 proof (insert assms)
   show "cGDERIV (\<lambda>x. g (f x)) x :> dg *\<^sub>C df"
     if "cGDERIV f x :> df"
       and "(g has_field_derivative cnj dg) (at (f x))"
     unfolding cgderiv_def has_field_derivative_def cinner_scaleC_left complex_cnj_cnj
     using that
-    by (simp add: cgderiv_def has_derivative_compose has_field_derivative_imp_has_derivative) 
+    by (simp add: cgderiv_def has_derivative_compose has_field_derivative_imp_has_derivative)
 
 qed
 
 (* Not specific to complex/real *)
 (* lemma has_derivative_subst: "\<lbrakk>FDERIV f x :> df; df = d\<rbrakk> \<Longrightarrow> FDERIV f x :> d" *)
 
 lemma cGDERIV_subst: "\<lbrakk>cGDERIV f x :> df; df = d\<rbrakk> \<Longrightarrow> cGDERIV f x :> d"
   by simp
 
 lemma cGDERIV_const: "cGDERIV (\<lambda>x. k) x :> 0"
   unfolding cgderiv_def cinner_zero_left[THEN ext] by (rule has_derivative_const)
 
 lemma cGDERIV_add:
   "\<lbrakk>cGDERIV f x :> df; cGDERIV g x :> dg\<rbrakk>
      \<Longrightarrow> cGDERIV (\<lambda>x. f x + g x) x :> df + dg"
   unfolding cgderiv_def cinner_add_left[THEN ext] by (rule has_derivative_add)
 
 lemma cGDERIV_minus:
   "cGDERIV f x :> df \<Longrightarrow> cGDERIV (\<lambda>x. - f x) x :> - df"
   unfolding cgderiv_def cinner_minus_left[THEN ext] by (rule has_derivative_minus)
 
 lemma cGDERIV_diff:
   "\<lbrakk>cGDERIV f x :> df; cGDERIV g x :> dg\<rbrakk>
      \<Longrightarrow> cGDERIV (\<lambda>x. f x - g x) x :> df - dg"
   unfolding cgderiv_def cinner_diff_left by (rule has_derivative_diff)
 
 lemma cGDERIV_scaleC:
   "\<lbrakk>DERIV f x :> df; cGDERIV g x :> dg\<rbrakk>
      \<Longrightarrow> cGDERIV (\<lambda>x. scaleC (f x) (g x)) x
       :> (scaleC (cnj (f x)) dg + scaleC (cnj df) (cnj (g x)))"
   unfolding cgderiv_def has_field_derivative_def cinner_add_left cinner_scaleC_left
   apply (rule has_derivative_subst)
    apply (erule (1) has_derivative_scaleC)
   by (simp add: ac_simps)
 
 lemma GDERIV_mult:
   "\<lbrakk>cGDERIV f x :> df; cGDERIV g x :> dg\<rbrakk>
      \<Longrightarrow> cGDERIV (\<lambda>x. f x * g x) x :> cnj (f x) *\<^sub>C dg + cnj (g x) *\<^sub>C df"
   unfolding cgderiv_def
   apply (rule has_derivative_subst)
    apply (erule (1) has_derivative_mult)
   apply (rule ext)
   by (simp add: cinner_add ac_simps)
 
 lemma cGDERIV_inverse:
   "\<lbrakk>cGDERIV f x :> df; f x \<noteq> 0\<rbrakk>
      \<Longrightarrow> cGDERIV (\<lambda>x. inverse (f x)) x :> - cnj ((inverse (f x))\<^sup>2) *\<^sub>C df"
   by (metis DERIV_inverse cGDERIV_DERIV_compose complex_cnj_cnj complex_cnj_minus numerals(2))
 
 (* Don't know if this holds: *)
 (* lemma cGDERIV_norm:
-  assumes "x \<noteq> 0" shows "cGDERIV (\<lambda>x. norm x) x :> sgn x" 
+  assumes "x \<noteq> 0" shows "cGDERIV (\<lambda>x. norm x) x :> sgn x"
 *)
 
 
 lemma has_derivative_norm[derivative_intros]:
   fixes x :: "'a::complex_inner"
-  assumes "x \<noteq> 0" 
+  assumes "x \<noteq> 0"
   shows "(norm has_derivative (\<lambda>h. Re (cinner (sgn x) h))) (at x)"
   thm has_derivative_norm
 proof -
   have Re_pos: "0 < Re (cinner x x)"
-    using assms 
+    using assms
     by (metis Re_strict_mono cinner_gt_zero_iff zero_complex.simps(1))
-  have Re_plus_Re: "Re (cinner x y) + Re (cinner y x) = 2 * Re (cinner x y)" 
+  have Re_plus_Re: "Re (cinner x y) + Re (cinner y x) = 2 * Re (cinner x y)"
     for x y :: 'a
     by (metis cinner_commute cnj.simps(1) mult_2_right semiring_normalization_rules(7))
   have norm: "norm x = sqrt (Re (cinner x x))" for x :: 'a
     apply (subst norm_eq_sqrt_cinner, subst cmod_Re)
     using cinner_ge_zero by auto
   have v2:"((\<lambda>x. sqrt (Re (cinner x x))) has_derivative
-          (\<lambda>xa. (Re (cinner x xa) + Re (cinner xa x)) * (inverse (sqrt (Re (cinner x x))) / 2))) (at x)" 
+          (\<lambda>xa. (Re (cinner x xa) + Re (cinner xa x)) * (inverse (sqrt (Re (cinner x x))) / 2))) (at x)"
     by (rule derivative_eq_intros | simp add: Re_pos)+
   have v1: "((\<lambda>x. sqrt (Re (cinner x x))) has_derivative (\<lambda>y. Re (cinner x y) / sqrt (Re (cinner x x)))) (at x)"
     if "((\<lambda>x. sqrt (Re (cinner x x))) has_derivative (\<lambda>xa. Re (cinner x xa) * inverse (sqrt (Re (cinner x x))))) (at x)"
     using that apply (subst divide_real_def)
     by simp
   have \<open>(norm has_derivative (\<lambda>y. Re (cinner x y) / norm x)) (at x)\<close>
     using v2
     apply (auto simp: Re_plus_Re norm [abs_def])
     using v1 by blast
   then show ?thesis
     by (auto simp: power2_eq_square sgn_div_norm scaleR_scaleC)
 qed
 
 
 bundle cinner_syntax begin
 notation cinner (infix "\<bullet>\<^sub>C" 70)
 end
 
 bundle no_cinner_syntax begin
 no_notation cinner (infix "\<bullet>\<^sub>C" 70)
 end
 
 end
diff --git a/thys/Complex_Bounded_Operators/Complex_Vector_Spaces.thy b/thys/Complex_Bounded_Operators/Complex_Vector_Spaces.thy
--- a/thys/Complex_Bounded_Operators/Complex_Vector_Spaces.thy
+++ b/thys/Complex_Bounded_Operators/Complex_Vector_Spaces.thy
@@ -1,2820 +1,2820 @@
 section \<open>\<open>Complex_Vector_Spaces\<close> -- Complex Vector Spaces\<close>
 
 (*
-Authors: 
+Authors:
 
   Dominique Unruh, University of Tartu, unruh@ut.ee
   Jose Manuel Rodriguez Caballero, University of Tartu, jose.manuel.rodriguez.caballero@ut.ee
 *)
 
 theory Complex_Vector_Spaces
   imports
     "HOL-Analysis.Elementary_Topology"
     "HOL-Analysis.Operator_Norm"
     "HOL-Analysis.Elementary_Normed_Spaces"
     "HOL-Library.Set_Algebras"
     "HOL-Analysis.Starlike"
     "HOL-Types_To_Sets.Types_To_Sets"
 
     "Complex_Bounded_Operators.Extra_Vector_Spaces"
     "Complex_Bounded_Operators.Extra_Ordered_Fields"
     "Complex_Bounded_Operators.Extra_Lattice"
     "Complex_Bounded_Operators.Extra_General"
 
     Complex_Vector_Spaces0
 begin
 
 bundle notation_norm begin
 notation norm ("\<parallel>_\<parallel>")
 end
 
 subsection \<open>Misc\<close>
 
 lemma (in scaleC) scaleC_real: assumes "r\<in>\<real>" shows "r *\<^sub>C x = Re r *\<^sub>R x"
   unfolding scaleR_scaleC using assms by simp
 
 lemma of_complex_of_real_eq [simp]: "of_complex (of_real n) = of_real n"
   unfolding of_complex_def of_real_def unfolding scaleR_scaleC by simp
 
 lemma Complexs_of_real [simp]: "of_real r \<in> \<complex>"
-  unfolding Complexs_def of_real_def of_complex_def 
+  unfolding Complexs_def of_real_def of_complex_def
   apply (subst scaleR_scaleC) by simp
 
 lemma Reals_in_Complexs: "\<real> \<subseteq> \<complex>"
   unfolding Reals_def by auto
 
 lemma (in clinear) "linear f"
   apply standard
   by (simp_all add: add scaleC scaleR_scaleC)
 
 lemma (in bounded_clinear) bounded_linear: "bounded_linear f"
   by (simp add: add bounded bounded_linear.intro bounded_linear_axioms.intro linearI scaleC scaleR_scaleC)
 
 lemma clinear_times: "clinear (\<lambda>x. c * x)"
   for c :: "'a::complex_algebra"
   by (auto simp: clinearI distrib_left)
 
 lemma (in clinear) linear:
   shows \<open>linear f\<close>
   by (simp add: add linearI scaleC scaleR_scaleC)
 
 lemma bounded_clinearI:
   assumes \<open>\<And>b1 b2. f (b1 + b2) = f b1 + f b2\<close>
   assumes \<open>\<And>r b. f (r *\<^sub>C b) = r *\<^sub>C f b\<close>
   assumes \<open>\<forall>x. norm (f x) \<le> norm x * K\<close>
   shows "bounded_clinear f"
   using assms by (auto intro!: exI bounded_clinear.intro clinearI simp: bounded_clinear_axioms_def)
 
 lemma bounded_clinear_id[simp]: \<open>bounded_clinear id\<close>
   by (simp add: id_def)
 
 (* The following would be a natural inclusion of locales, but unfortunately it leads to
    name conflicts upon interpretation of bounded_cbilinear *)
 (* sublocale bounded_cbilinear \<subseteq> bounded_bilinear
   by (rule bounded_bilinear) *)
 
 
 definition cbilinear :: \<open>('a::complex_vector \<Rightarrow> 'b::complex_vector \<Rightarrow> 'c::complex_vector) \<Rightarrow> bool\<close>
   where \<open>cbilinear = (\<lambda> f. (\<forall> y. clinear (\<lambda> x. f x y)) \<and> (\<forall> x. clinear (\<lambda> y. f x y)) )\<close>
 
 lemma cbilinear_add_left:
   assumes \<open>cbilinear f\<close>
   shows \<open>f (a + b) c = f a c + f b c\<close>
   by (smt (verit, del_insts) assms cbilinear_def complex_vector.linear_add)
 
 lemma cbilinear_add_right:
   assumes \<open>cbilinear f\<close>
   shows \<open>f a (b + c) = f a b + f a c\<close>
   by (smt (verit, del_insts) assms cbilinear_def complex_vector.linear_add)
 
 lemma cbilinear_times:
   fixes g' :: \<open>'a::complex_vector \<Rightarrow> complex\<close> and g :: \<open>'b::complex_vector \<Rightarrow> complex\<close>
   assumes \<open>\<And> x y. h x y = (g' x)*(g y)\<close> and \<open>clinear g\<close> and \<open>clinear g'\<close>
   shows \<open>cbilinear h\<close>
 proof -
   have w1: "h (b1 + b2) y = h b1 y + h b2 y"
     for b1 :: 'a
       and b2 :: 'a
       and y
   proof-
     have \<open>h (b1 + b2) y = g' (b1 + b2) * g y\<close>
       using \<open>\<And> x y. h x y = (g' x)*(g y)\<close>
       by auto
     also have \<open>\<dots> = (g' b1 + g' b2) * g y\<close>
       using \<open>clinear g'\<close>
       unfolding clinear_def
       by (simp add: assms(3) complex_vector.linear_add)
     also have \<open>\<dots> = g' b1 * g y + g' b2 * g y\<close>
       by (simp add: ring_class.ring_distribs(2))
     also have \<open>\<dots> = h b1 y + h b2 y\<close>
-      using assms(1) by auto          
+      using assms(1) by auto
     finally show ?thesis by blast
   qed
   have w2: "h (r *\<^sub>C b) y = r *\<^sub>C h b y"
     for r :: complex
       and b :: 'a
       and y
   proof-
     have \<open>h (r *\<^sub>C b) y = g' (r *\<^sub>C b) * g y\<close>
       by (simp add: assms(1))
     also have \<open>\<dots> = r *\<^sub>C (g' b * g y)\<close>
       by (simp add: assms(3) complex_vector.linear_scale)
     also have \<open>\<dots> = r *\<^sub>C (h b y)\<close>
-      by (simp add: assms(1))          
+      by (simp add: assms(1))
     finally show ?thesis by blast
   qed
   have "clinear (\<lambda>x. h x y)"
     for y :: 'b
     unfolding clinear_def
     by (meson clinearI clinear_def w1 w2)
   hence t2: "\<forall>y. clinear (\<lambda>x. h x y)"
     by simp
   have v1: "h x (b1 + b2) = h x b1 + h x b2"
     for b1 :: 'b
       and b2 :: 'b
       and x
   proof-
     have \<open>h x (b1 + b2)  = g' x * g (b1 + b2)\<close>
       using \<open>\<And> x y. h x y = (g' x)*(g y)\<close>
       by auto
     also have \<open>\<dots> = g' x * (g b1 + g b2)\<close>
       using \<open>clinear g'\<close>
       unfolding clinear_def
       by (simp add: assms(2) complex_vector.linear_add)
     also have \<open>\<dots> = g' x * g b1 + g' x * g b2\<close>
       by (simp add: ring_class.ring_distribs(1))
     also have \<open>\<dots> = h x b1 + h x b2\<close>
-      using assms(1) by auto          
+      using assms(1) by auto
     finally show ?thesis by blast
   qed
 
   have v2:  "h x (r *\<^sub>C b) = r *\<^sub>C h x b"
     for r :: complex
       and b :: 'b
       and x
   proof-
     have \<open>h x (r *\<^sub>C b) =  g' x * g (r *\<^sub>C b)\<close>
       by (simp add: assms(1))
     also have \<open>\<dots> = r *\<^sub>C (g' x * g b)\<close>
       by (simp add: assms(2) complex_vector.linear_scale)
     also have \<open>\<dots> = r *\<^sub>C (h x b)\<close>
-      by (simp add: assms(1))          
+      by (simp add: assms(1))
     finally show ?thesis by blast
   qed
   have "Vector_Spaces.linear (*\<^sub>C) (*\<^sub>C) (h x)"
     for x :: 'a
     using v1 v2
-    by (meson clinearI clinear_def) 
+    by (meson clinearI clinear_def)
   hence t1: "\<forall>x. clinear (h x)"
     unfolding clinear_def
     by simp
   show ?thesis
     unfolding cbilinear_def
-    by (simp add: t1 t2)    
+    by (simp add: t1 t2)
 qed
 
 lemma csubspace_is_subspace: "csubspace A \<Longrightarrow> subspace A"
-  apply (rule subspaceI) 
+  apply (rule subspaceI)
   by (auto simp: complex_vector.subspace_def scaleR_scaleC)
 
 lemma span_subset_cspan: "span A \<subseteq> cspan A"
   unfolding span_def complex_vector.span_def
   by (simp add: csubspace_is_subspace hull_antimono)
 
 
-lemma cindependent_implies_independent: 
+lemma cindependent_implies_independent:
   assumes "cindependent (S::'a::complex_vector set)"
   shows "independent S"
   using assms unfolding dependent_def complex_vector.dependent_def
   using span_subset_cspan by blast
 
 lemma cspan_singleton: "cspan {x} = {\<alpha> *\<^sub>C x| \<alpha>. True}"
 proof -
   have \<open>cspan {x} = {y. y\<in>cspan {x}}\<close>
     by auto
   also have \<open>\<dots> = {\<alpha> *\<^sub>C x| \<alpha>. True}\<close>
     apply (subst complex_vector.span_breakdown_eq)
     by auto
   finally show ?thesis
     by -
 qed
 
 
 lemma cspan_as_span:
   "cspan (B::'a::complex_vector set) = span (B \<union> scaleC \<i> ` B)"
 proof auto
   let ?cspan = complex_vector.span
   let ?rspan = real_vector.span
   fix \<psi>
   assume cspan: "\<psi> \<in> ?cspan B"
   have "\<exists>B' r. finite B' \<and> B' \<subseteq> B \<and> \<psi> = (\<Sum>b\<in>B'. r b *\<^sub>C b)"
     using complex_vector.span_explicit[of B] cspan
     by auto
   then obtain B' r where "finite B'" and "B' \<subseteq> B" and \<psi>_explicit: "\<psi> = (\<Sum>b\<in>B'. r b *\<^sub>C b)"
-    by atomize_elim 
+    by atomize_elim
   define R where "R = B \<union> scaleC \<i> ` B"
 
-  have x2: "(case x of (b, i) \<Rightarrow> if i 
-            then Im (r b) *\<^sub>R \<i> *\<^sub>C b 
+  have x2: "(case x of (b, i) \<Rightarrow> if i
+            then Im (r b) *\<^sub>R \<i> *\<^sub>C b
             else Re (r b) *\<^sub>R b) \<in> span (B \<union> (*\<^sub>C) \<i> ` B)"
     if "x \<in> B' \<times> (UNIV::bool set)"
     for x :: "'a \<times> bool"
     using that \<open>B' \<subseteq> B\<close> by (auto simp add: real_vector.span_base real_vector.span_scale subset_iff)
   have x1: "\<psi> = (\<Sum>x\<in>B'. \<Sum>i\<in>UNIV. if i then Im (r x) *\<^sub>R \<i> *\<^sub>C x else Re (r x) *\<^sub>R x)"
     if "\<And>b. r b *\<^sub>C b = Re (r b) *\<^sub>R b + Im (r b) *\<^sub>R \<i> *\<^sub>C b"
     using that by (simp add: UNIV_bool \<psi>_explicit)
   moreover have "r b *\<^sub>C b = Re (r b) *\<^sub>R b + Im (r b) *\<^sub>R \<i> *\<^sub>C b" for b
     using complex_eq scaleC_add_left scaleC_scaleC scaleR_scaleC
     by (metis (no_types, lifting) complex_of_real_i i_complex_of_real)
   ultimately have "\<psi> = (\<Sum>(b,i)\<in>(B'\<times>UNIV). if i then Im (r b) *\<^sub>R (\<i> *\<^sub>C b) else Re (r b) *\<^sub>R b)"
-    by (simp add: sum.cartesian_product)     
+    by (simp add: sum.cartesian_product)
   also have "\<dots> \<in> ?rspan R"
     unfolding R_def
     using x2
-    by (rule real_vector.span_sum) 
+    by (rule real_vector.span_sum)
   finally show "\<psi> \<in> ?rspan R" by -
 next
   let ?cspan = complex_vector.span
   let ?rspan = real_vector.span
   define R where "R = B \<union> scaleC \<i> ` B"
   fix \<psi>
   assume rspan: "\<psi> \<in> ?rspan R"
   have "subspace {a. a \<in> cspan B}"
-    by (rule real_vector.subspaceI, auto simp add: complex_vector.span_zero 
+    by (rule real_vector.subspaceI, auto simp add: complex_vector.span_zero
         complex_vector.span_add_eq2 complex_vector.span_scale scaleR_scaleC)
   moreover have "x \<in> cspan B"
     if "x \<in> R"
     for x :: 'a
     using that R_def complex_vector.span_base complex_vector.span_scale by fastforce
   ultimately show "\<psi> \<in> ?cspan B"
-    using real_vector.span_induct rspan by blast  
+    using real_vector.span_induct rspan by blast
 qed
 
 
 lemma isomorphic_equal_cdim:
   assumes lin_f: \<open>clinear f\<close>
   assumes inj_f: \<open>inj_on f (cspan S)\<close>
   assumes im_S: \<open>f ` S = T\<close>
   shows \<open>cdim S = cdim T\<close>
 proof -
   obtain SB where SB_span: "cspan SB = cspan S" and indep_SB: \<open>cindependent SB\<close>
     by (metis complex_vector.basis_exists complex_vector.span_mono complex_vector.span_span subset_antisym)
   with lin_f inj_f have indep_fSB: \<open>cindependent (f ` SB)\<close>
     apply (rule_tac complex_vector.linear_independent_injective_image)
     by auto
   from lin_f have \<open>cspan (f ` SB) = f ` cspan SB\<close>
     by (meson complex_vector.linear_span_image)
   also from SB_span lin_f have \<open>\<dots> = cspan T\<close>
     by (metis complex_vector.linear_span_image im_S)
   finally have \<open>cdim T = card (f ` SB)\<close>
     using indep_fSB complex_vector.dim_eq_card by blast
   also have \<open>\<dots> = card SB\<close>
     apply (rule card_image) using inj_f
     by (metis SB_span complex_vector.linear_inj_on_span_iff_independent_image indep_fSB lin_f)
   also have \<open>\<dots> = cdim S\<close>
     using indep_SB SB_span
     by (metis complex_vector.dim_eq_card)
   finally show ?thesis by simp
 qed
 
 
 lemma cindependent_inter_scaleC_cindependent:
   assumes a1: "cindependent (B::'a::complex_vector set)" and a3: "c \<noteq> 1"
   shows "B \<inter> (*\<^sub>C) c ` B = {}"
 proof (rule classical, cases \<open>c = 0\<close>)
   case True
   then show ?thesis
     using a1 by (auto simp add: complex_vector.dependent_zero)
 next
   case False
   assume "\<not>(B \<inter> (*\<^sub>C) c ` B = {})"
   hence "B \<inter> (*\<^sub>C) c ` B \<noteq> {}"
     by blast
   then obtain x where u1: "x \<in> B \<inter> (*\<^sub>C) c ` B"
     by blast
   then obtain b where u2: "x = b" and u3: "b\<in>B"
     by blast
   then  obtain b' where u2': "x = c *\<^sub>C b'" and u3': "b'\<in>B"
     using u1
     by blast
   have g1: "b = c *\<^sub>C b'"
     using u2 and u2' by simp
   hence "b \<in> complex_vector.span {b'}"
     using False
     by (simp add: complex_vector.span_base complex_vector.span_scale)
   hence "b = b'"
-    by (metis  u3' a1 complex_vector.dependent_def complex_vector.span_base 
-        complex_vector.span_scale insertE insert_Diff u2 u2' u3) 
+    by (metis  u3' a1 complex_vector.dependent_def complex_vector.span_base
+        complex_vector.span_scale insertE insert_Diff u2 u2' u3)
   hence "b' = c *\<^sub>C b'"
     using g1 by blast
   thus ?thesis
     by (metis a1 a3 complex_vector.dependent_zero complex_vector.scale_right_imp_eq
         mult_cancel_right2 scaleC_scaleC u3')
 qed
 
 lemma real_independent_from_complex_independent:
   assumes "cindependent (B::'a::complex_vector set)"
   defines "B' == ((*\<^sub>C) \<i> ` B)"
   shows "independent (B \<union> B')"
 proof (rule notI)
   assume \<open>dependent (B \<union> B')\<close>
   then obtain T f0 x where [simp]: \<open>finite T\<close> and \<open>T \<subseteq> B \<union> B'\<close> and f0_sum: \<open>(\<Sum>v\<in>T. f0 v *\<^sub>R v) = 0\<close>
     and x: \<open>x \<in> T\<close> and f0_x: \<open>f0 x \<noteq> 0\<close>
     by (auto simp: real_vector.dependent_explicit)
-  define f T1 T2 T' f' x' where \<open>f v = (if v \<in> T then f0 v else 0)\<close> 
+  define f T1 T2 T' f' x' where \<open>f v = (if v \<in> T then f0 v else 0)\<close>
     and \<open>T1 = T \<inter> B\<close> and \<open>T2 = scaleC (-\<i>) ` (T \<inter> B')\<close>
     and \<open>T' = T1 \<union> T2\<close> and \<open>f' v = f v + \<i> * f (\<i> *\<^sub>C v)\<close>
     and \<open>x' = (if x \<in> T1 then x else -\<i> *\<^sub>C x)\<close> for v
   have \<open>B \<inter> B' = {}\<close>
     by (simp add: assms cindependent_inter_scaleC_cindependent)
-  have \<open>T' \<subseteq> B\<close> 
+  have \<open>T' \<subseteq> B\<close>
     by (auto simp: T'_def T1_def T2_def B'_def)
   have [simp]: \<open>finite T'\<close> \<open>finite T1\<close> \<open>finite T2\<close>
     by (auto simp add: T'_def T1_def T2_def)
   have f_sum: \<open>(\<Sum>v\<in>T. f v *\<^sub>R v) = 0\<close>
     unfolding f_def using f0_sum by auto
   have f_x: \<open>f x \<noteq> 0\<close>
     using f0_x x by (auto simp: f_def)
   have f'_sum: \<open>(\<Sum>v\<in>T'. f' v *\<^sub>C v) = 0\<close>
   proof -
     have \<open>(\<Sum>v\<in>T'. f' v *\<^sub>C v) = (\<Sum>v\<in>T'. complex_of_real (f v) *\<^sub>C v) + (\<Sum>v\<in>T'. (\<i> * complex_of_real (f (\<i> *\<^sub>C v))) *\<^sub>C v)\<close>
       by (auto simp: f'_def sum.distrib scaleC_add_left)
     also have \<open>(\<Sum>v\<in>T'. complex_of_real (f v) *\<^sub>C v) = (\<Sum>v\<in>T1. f v *\<^sub>R v)\<close> (is \<open>_ = ?left\<close>)
       apply (auto simp: T'_def scaleR_scaleC intro!: sum.mono_neutral_cong_right)
       using T'_def T1_def \<open>T' \<subseteq> B\<close> f_def by auto
     also have \<open>(\<Sum>v\<in>T'. (\<i> * complex_of_real (f (\<i> *\<^sub>C v))) *\<^sub>C v) = (\<Sum>v\<in>T2. (\<i> * complex_of_real (f (\<i> *\<^sub>C v))) *\<^sub>C v)\<close> (is \<open>_ = ?right\<close>)
       apply (auto simp: T'_def intro!: sum.mono_neutral_cong_right)
       by (smt (z3) B'_def IntE IntI T1_def T2_def \<open>f \<equiv> \<lambda>v. if v \<in> T then f0 v else 0\<close> add.inverse_inverse complex_vector.vector_space_axioms i_squared imageI mult_minus_left vector_space.vector_space_assms(3) vector_space.vector_space_assms(4))
     also have \<open>?right = (\<Sum>v\<in>T\<inter>B'. f v *\<^sub>R v)\<close> (is \<open>_ = ?right\<close>)
       apply (rule sum.reindex_cong[symmetric, where l=\<open>scaleC \<i>\<close>])
         apply (auto simp: T2_def image_image scaleR_scaleC)
       using inj_on_def by fastforce
     also have \<open>?left + ?right = (\<Sum>v\<in>T. f v *\<^sub>R v)\<close>
       apply (subst sum.union_disjoint[symmetric])
       using \<open>B \<inter> B' = {}\<close> \<open>T \<subseteq> B \<union> B'\<close> apply (auto simp: T1_def)
       by (metis Int_Un_distrib Un_Int_eq(4) sup.absorb_iff1)
     also have \<open>\<dots> = 0\<close>
       by (rule f_sum)
     finally show ?thesis
       by -
   qed
 
   have x': \<open>x' \<in> T'\<close>
     using \<open>T \<subseteq> B \<union> B'\<close> x by (auto simp: x'_def T'_def T1_def T2_def)
 
   have f'_x': \<open>f' x' \<noteq> 0\<close>
     using Complex_eq Complex_eq_0 f'_def f_x x'_def by auto
 
   from \<open>finite T'\<close> \<open>T' \<subseteq> B\<close> f'_sum x' f'_x'
   have \<open>cdependent B\<close>
     using complex_vector.independent_explicit_module by blast
   with assms show False
     by auto
 qed
 
-lemma crepresentation_from_representation: 
+lemma crepresentation_from_representation:
   assumes a1: "cindependent B" and a2: "b \<in> B" and a3: "finite B"
   shows "crepresentation B \<psi> b = (representation (B \<union> (*\<^sub>C) \<i> ` B) \<psi> b)
                            + \<i> *\<^sub>C (representation (B \<union> (*\<^sub>C) \<i> ` B) \<psi> (\<i> *\<^sub>C b))"
 proof (cases "\<psi> \<in> cspan B")
   define B' where "B' = B \<union> (*\<^sub>C) \<i> ` B"
   case True
   define r  where "r v = real_vector.representation B' \<psi> v" for v
   define r' where "r' v = real_vector.representation B' \<psi> (\<i> *\<^sub>C v)" for v
   define f  where "f v = r v + \<i> *\<^sub>C r' v" for v
   define g  where "g v = crepresentation B \<psi> v" for v
   have "(\<Sum>v | g v \<noteq> 0. g v *\<^sub>C v) = \<psi>"
     unfolding g_def
-    using Collect_cong Collect_mono_iff DiffD1 DiffD2 True a1 
+    using Collect_cong Collect_mono_iff DiffD1 DiffD2 True a1
       complex_vector.finite_representation
       complex_vector.sum_nonzero_representation_eq sum.mono_neutral_cong_left
     by fastforce
   moreover have "finite {v. g v \<noteq> 0}"
     unfolding g_def
     by (simp add: complex_vector.finite_representation)
   moreover have "v \<in> B"
     if "g v \<noteq> 0" for v
     using that unfolding g_def
-    by (simp add: complex_vector.representation_ne_zero)        
-  ultimately have rep1: "(\<Sum>v\<in>B. g v *\<^sub>C v) = \<psi>"    
+    by (simp add: complex_vector.representation_ne_zero)
+  ultimately have rep1: "(\<Sum>v\<in>B. g v *\<^sub>C v) = \<psi>"
     unfolding g_def
     using a3 True a1 complex_vector.sum_representation_eq by blast
   have l0': "inj ((*\<^sub>C) \<i>::'a \<Rightarrow>'a)"
-    unfolding inj_def 
-    by simp 
+    unfolding inj_def
+    by simp
   have l0: "inj ((*\<^sub>C) (- \<i>)::'a \<Rightarrow>'a)"
-    unfolding inj_def 
-    by simp 
+    unfolding inj_def
+    by simp
   have l1: "(*\<^sub>C) (- \<i>) ` B \<inter> B = {}"
     using cindependent_inter_scaleC_cindependent[where B=B and c = "- \<i>"]
-    by (metis Int_commute a1 add.inverse_inverse complex_i_not_one i_squared mult_cancel_left1 
+    by (metis Int_commute a1 add.inverse_inverse complex_i_not_one i_squared mult_cancel_left1
         neg_equal_0_iff_equal)
   have l2: "B \<inter> (*\<^sub>C) \<i> ` B = {}"
     by (simp add: a1 cindependent_inter_scaleC_cindependent)
   have rr1: "r (\<i> *\<^sub>C v) = r' v" for v
     unfolding r_def r'_def
-    by simp 
+    by simp
   have k1: "independent B'"
     unfolding B'_def using a1 real_independent_from_complex_independent by simp
   have "\<psi> \<in> span B'"
-    using B'_def True cspan_as_span by blast    
+    using B'_def True cspan_as_span by blast
   have "v \<in> B'"
     if "r v \<noteq> 0"
     for v
     unfolding r_def
     using r_def real_vector.representation_ne_zero that by auto
   have "finite B'"
     unfolding B'_def using a3
-    by simp 
+    by simp
   have "(\<Sum>v\<in>B'. r v *\<^sub>R v) = \<psi>"
-    unfolding r_def 
-    using True  Real_Vector_Spaces.real_vector.sum_representation_eq[where B = B' and basis = B' 
-        and v = \<psi>]  
-    by (smt Real_Vector_Spaces.dependent_raw_def \<open>\<psi> \<in> Real_Vector_Spaces.span B'\<close> \<open>finite B'\<close> 
+    unfolding r_def
+    using True  Real_Vector_Spaces.real_vector.sum_representation_eq[where B = B' and basis = B'
+        and v = \<psi>]
+    by (smt Real_Vector_Spaces.dependent_raw_def \<open>\<psi> \<in> Real_Vector_Spaces.span B'\<close> \<open>finite B'\<close>
         equalityD2 k1)
   have d1: "(\<Sum>v\<in>B. r (\<i> *\<^sub>C v) *\<^sub>R (\<i> *\<^sub>C v)) = (\<Sum>v\<in>(*\<^sub>C) \<i> ` B. r v *\<^sub>R v)"
     using l0'
     by (metis (mono_tags, lifting) inj_eq inj_on_def sum.reindex_cong)
   have "(\<Sum>v\<in>B. (r v + \<i> * (r' v)) *\<^sub>C v) = (\<Sum>v\<in>B. r v *\<^sub>C v + (\<i> * r' v) *\<^sub>C v)"
     by (meson scaleC_left.add)
   also have "\<dots> = (\<Sum>v\<in>B. r v *\<^sub>C v) + (\<Sum>v\<in>B. (\<i> * r' v) *\<^sub>C v)"
     using sum.distrib by fastforce
   also have "\<dots> = (\<Sum>v\<in>B. r v *\<^sub>C v) + (\<Sum>v\<in>B. \<i> *\<^sub>C (r' v *\<^sub>C v))"
     by auto
   also have "\<dots> = (\<Sum>v\<in>B. r v *\<^sub>R v) + (\<Sum>v\<in>B. \<i> *\<^sub>C (r (\<i> *\<^sub>C v) *\<^sub>R v))"
     unfolding r'_def r_def
-    by (metis (mono_tags, lifting) scaleR_scaleC sum.cong) 
+    by (metis (mono_tags, lifting) scaleR_scaleC sum.cong)
   also have "\<dots> = (\<Sum>v\<in>B. r v *\<^sub>R v) + (\<Sum>v\<in>B. r (\<i> *\<^sub>C v) *\<^sub>R (\<i> *\<^sub>C v))"
-    by (metis (no_types, lifting) complex_vector.scale_left_commute scaleR_scaleC)      
+    by (metis (no_types, lifting) complex_vector.scale_left_commute scaleR_scaleC)
   also have "\<dots> = (\<Sum>v\<in>B. r v *\<^sub>R v) + (\<Sum>v\<in>(*\<^sub>C) \<i> ` B. r v *\<^sub>R v)"
     using d1
     by simp
   also have "\<dots> = \<psi>"
     using l2 \<open>(\<Sum>v\<in>B'. r v *\<^sub>R v) = \<psi>\<close>
     unfolding B'_def
-    by (simp add: a3 sum.union_disjoint) 
+    by (simp add: a3 sum.union_disjoint)
   finally have "(\<Sum>v\<in>B. f v *\<^sub>C v) = \<psi>" unfolding r'_def r_def f_def by simp
   hence "0 = (\<Sum>v\<in>B. f v *\<^sub>C v) - (\<Sum>v\<in>B. crepresentation B \<psi> v *\<^sub>C v)"
     using rep1
     unfolding g_def
     by simp
   also have "\<dots> = (\<Sum>v\<in>B. f v *\<^sub>C v - crepresentation B \<psi> v *\<^sub>C v)"
     by (simp add: sum_subtractf)
   also have "\<dots> = (\<Sum>v\<in>B. (f v - crepresentation B \<psi> v) *\<^sub>C v)"
     by (metis scaleC_left.diff)
   finally have "0 = (\<Sum>v\<in>B. (f v - crepresentation B \<psi> v) *\<^sub>C v)".
   hence "(\<Sum>v\<in>B. (f v - crepresentation B \<psi> v) *\<^sub>C v) = 0"
     by simp
   hence "f b - crepresentation B \<psi> b = 0"
-    using a1 a2 a3 complex_vector.independentD[where s = B and t = B 
+    using a1 a2 a3 complex_vector.independentD[where s = B and t = B
         and u = "\<lambda>v. f v - crepresentation B \<psi> v" and v = b]
       order_refl  by smt
   hence "crepresentation B \<psi> b = f b"
     by simp
   thus ?thesis unfolding f_def r_def r'_def B'_def by auto
 next
   define B' where "B' = B \<union> (*\<^sub>C) \<i> ` B"
   case False
   have b2: "\<psi> \<notin> real_vector.span B'"
     unfolding B'_def
-    using False cspan_as_span by auto    
+    using False cspan_as_span by auto
   have "\<psi> \<notin> complex_vector.span B"
     using False by blast
   have "crepresentation B \<psi> b = 0"
     unfolding complex_vector.representation_def
     by (simp add: False)
   moreover have "real_vector.representation B' \<psi> b = 0"
     unfolding real_vector.representation_def
     by (simp add: b2)
   moreover have "real_vector.representation B' \<psi> ((*\<^sub>C) \<i> b) = 0"
     unfolding real_vector.representation_def
     by (simp add: b2)
   ultimately show ?thesis unfolding B'_def by simp
 qed
 
 
 lemma CARD_1_vec_0[simp]: \<open>(\<psi> :: _ ::{complex_vector,CARD_1}) = 0\<close>
   by auto
 
 
 lemma scaleC_cindependent:
   assumes a1: "cindependent (B::'a::complex_vector set)" and a3: "c \<noteq> 0"
   shows "cindependent ((*\<^sub>C) c ` B)"
 proof-
   have "u y = 0"
     if g1: "y\<in>S" and g2: "(\<Sum>x\<in>S. u x *\<^sub>C x) = 0" and g3: "finite S" and g4: "S\<subseteq>(*\<^sub>C) c ` B"
     for u y S
   proof-
     define v where "v x = u (c *\<^sub>C x)" for x
     obtain S' where "S'\<subseteq>B" and S_S': "S = (*\<^sub>C) c ` S'"
-      by (meson g4 subset_imageE)      
+      by (meson g4 subset_imageE)
     have "inj ((*\<^sub>C) c::'a\<Rightarrow>_)"
       unfolding inj_def
-      using a3 by auto 
+      using a3 by auto
     hence "finite S'"
-      using S_S' finite_imageD g3 subset_inj_on by blast            
+      using S_S' finite_imageD g3 subset_inj_on by blast
     have "t \<in> (*\<^sub>C) (inverse c) ` S"
       if "t \<in> S'" for t
     proof-
       have "c *\<^sub>C t \<in> S"
         using \<open>S = (*\<^sub>C) c ` S'\<close> that by blast
       hence "(inverse c) *\<^sub>C (c *\<^sub>C t) \<in> (*\<^sub>C) (inverse c) ` S"
         by blast
       moreover have "(inverse c) *\<^sub>C (c *\<^sub>C t) = t"
         by (simp add: a3)
       ultimately show ?thesis by simp
     qed
     moreover have "t \<in> S'"
       if "t \<in> (*\<^sub>C) (inverse c) ` S" for t
     proof-
       obtain t' where "t = (inverse c) *\<^sub>C t'" and "t' \<in> S"
         using \<open>t \<in> (*\<^sub>C) (inverse c) ` S\<close> by auto
       have "c *\<^sub>C t = c *\<^sub>C ((inverse c) *\<^sub>C t')"
         using \<open>t = (inverse c) *\<^sub>C t'\<close> by simp
       also have "\<dots> = (c * (inverse c)) *\<^sub>C t'"
         by simp
       also have "\<dots> = t'"
         by (simp add: a3)
       finally have "c *\<^sub>C t = t'".
       thus ?thesis using \<open>t' \<in> S\<close>
-        using \<open>S = (*\<^sub>C) c ` S'\<close> a3 complex_vector.scale_left_imp_eq by blast 
+        using \<open>S = (*\<^sub>C) c ` S'\<close> a3 complex_vector.scale_left_imp_eq by blast
     qed
     ultimately have "S' = (*\<^sub>C) (inverse c) ` S"
-      by blast 
+      by blast
     hence "inverse c *\<^sub>C y \<in> S'"
-      using that(1) by blast 
+      using that(1) by blast
     have t: "inj (((*\<^sub>C) c)::'a \<Rightarrow> _)"
       using a3 complex_vector.injective_scale[where c = c]
       by blast
     have "0 = (\<Sum>x\<in>(*\<^sub>C) c ` S'. u x *\<^sub>C x)"
       using \<open>S = (*\<^sub>C) c ` S'\<close> that(2) by auto
     also have "\<dots> = (\<Sum>x\<in>S'. v x *\<^sub>C (c *\<^sub>C x))"
       unfolding v_def
-      using t Groups_Big.comm_monoid_add_class.sum.reindex[where h = "((*\<^sub>C) c)" and A = S' 
-          and g = "\<lambda>x. u x *\<^sub>C x"] subset_inj_on by auto     
+      using t Groups_Big.comm_monoid_add_class.sum.reindex[where h = "((*\<^sub>C) c)" and A = S'
+          and g = "\<lambda>x. u x *\<^sub>C x"] subset_inj_on by auto
     also have "\<dots> = c *\<^sub>C (\<Sum>x\<in>S'. v x *\<^sub>C x)"
       by (metis (mono_tags, lifting) complex_vector.scale_left_commute scaleC_right.sum sum.cong)
     finally have "0 = c *\<^sub>C (\<Sum>x\<in>S'. v x *\<^sub>C x)".
     hence "(\<Sum>x\<in>S'. v x *\<^sub>C x) = 0"
       using a3 by auto
     hence "v (inverse c *\<^sub>C y) = 0"
       using \<open>inverse c *\<^sub>C y \<in> S'\<close> \<open>finite S'\<close> \<open>S' \<subseteq> B\<close> a1
         complex_vector.independentD
-      by blast 
+      by blast
     thus "u y = 0"
       unfolding v_def
-      by (simp add: a3) 
+      by (simp add: a3)
   qed
   thus ?thesis
     using complex_vector.dependent_explicit
-    by (simp add: complex_vector.dependent_explicit ) 
+    by (simp add: complex_vector.dependent_explicit )
 qed
 
 subsection \<open>Antilinear maps and friends\<close>
 
 locale antilinear = additive f for f :: "'a::complex_vector \<Rightarrow> 'b::complex_vector" +
   assumes scaleC: "f (scaleC r x) = cnj r *\<^sub>C f x"
 
 sublocale antilinear \<subseteq> linear
 proof (rule linearI)
   show "f (b1 + b2) = f b1 + f b2"
     for b1 :: 'a
       and b2 :: 'a
-    by (simp add: add)    
+    by (simp add: add)
   show "f (r *\<^sub>R b) = r *\<^sub>R f b"
     for r :: real
       and b :: 'a
-    unfolding scaleR_scaleC by (subst scaleC, simp)  
+    unfolding scaleR_scaleC by (subst scaleC, simp)
 qed
 
 lemma antilinear_imp_scaleC:
   fixes D :: "complex \<Rightarrow> 'a::complex_vector"
   assumes "antilinear D"
   obtains d where "D = (\<lambda>x. cnj x *\<^sub>C d)"
 proof -
   interpret clinear "D o cnj"
     apply standard apply auto
      apply (simp add: additive.add assms antilinear.axioms(1))
     using assms antilinear.scaleC by fastforce
   obtain d where "D o cnj = (\<lambda>x. x *\<^sub>C d)"
     using clinear_axioms complex_vector.linear_imp_scale by blast
   then have \<open>D = (\<lambda>x. cnj x *\<^sub>C d)\<close>
     by (metis comp_apply complex_cnj_cnj)
   then show ?thesis
     by (rule that)
 qed
 
 corollary complex_antilinearD:
   fixes f :: "complex \<Rightarrow> complex"
   assumes "antilinear f" obtains c where "f = (\<lambda>x. c * cnj x)"
   by (rule antilinear_imp_scaleC [OF assms]) (force simp: scaleC_conv_of_complex)
 
 lemma antilinearI:
   assumes "\<And>x y. f (x + y) = f x + f y"
     and "\<And>c x. f (c *\<^sub>C x) = cnj c *\<^sub>C f x"
   shows "antilinear f"
   by standard (rule assms)+
 
 lemma antilinear_o_antilinear: "antilinear f \<Longrightarrow> antilinear g \<Longrightarrow> clinear (g o f)"
   apply (rule clinearI)
    apply (simp add: additive.add antilinear_def)
   by (simp add: antilinear.scaleC)
 
 lemma clinear_o_antilinear: "antilinear f \<Longrightarrow> clinear g \<Longrightarrow> antilinear (g o f)"
   apply (rule antilinearI)
    apply (simp add: additive.add complex_vector.linear_add antilinear_def)
   by (simp add: complex_vector.linear_scale antilinear.scaleC)
 
 lemma antilinear_o_clinear: "clinear f \<Longrightarrow> antilinear g \<Longrightarrow> antilinear (g o f)"
   apply (rule antilinearI)
    apply (simp add: additive.add complex_vector.linear_add antilinear_def)
   by (simp add: complex_vector.linear_scale antilinear.scaleC)
 
 locale bounded_antilinear = antilinear f for f :: "'a::complex_normed_vector \<Rightarrow> 'b::complex_normed_vector" +
   assumes bounded: "\<exists>K. \<forall>x. norm (f x) \<le> norm x * K"
 
 lemma bounded_antilinearI:
   assumes \<open>\<And>b1 b2. f (b1 + b2) = f b1 + f b2\<close>
   assumes \<open>\<And>r b. f (r *\<^sub>C b) = cnj r *\<^sub>C f b\<close>
   assumes \<open>\<forall>x. norm (f x) \<le> norm x * K\<close>
   shows "bounded_antilinear f"
   using assms by (auto intro!: exI bounded_antilinear.intro antilinearI simp: bounded_antilinear_axioms_def)
 
 sublocale bounded_antilinear \<subseteq> bounded_linear
   apply standard by (fact bounded)
 
 lemma (in bounded_antilinear) bounded_linear: "bounded_linear f"
   by (fact bounded_linear)
 
 lemma (in bounded_antilinear) antilinear: "antilinear f"
   by (fact antilinear_axioms)
 
 lemma bounded_antilinear_intro:
   assumes "\<And>x y. f (x + y) = f x + f y"
     and "\<And>r x. f (scaleC r x) = scaleC (cnj r) (f x)"
     and "\<And>x. norm (f x) \<le> norm x * K"
   shows "bounded_antilinear f"
   by standard (blast intro: assms)+
 
 lemma bounded_antilinear_0[simp]: \<open>bounded_antilinear (\<lambda>_. 0)\<close>
   by (rule bounded_antilinear_intro[where K=0], auto)
 
 lemma cnj_bounded_antilinear[simp]: "bounded_antilinear cnj"
   apply (rule bounded_antilinear_intro [where K = 1])
   by auto
 
 lemma bounded_antilinear_o_bounded_antilinear:
   assumes "bounded_antilinear f"
     and "bounded_antilinear g"
   shows "bounded_clinear (\<lambda>x. f (g x))"
 proof
   interpret f: bounded_antilinear f by fact
   interpret g: bounded_antilinear g by fact
   fix b1 b2 b r
   show "f (g (b1 + b2)) = f (g b1) + f (g b2)"
     by (simp add: f.add g.add)
   show "f (g (r *\<^sub>C b)) = r *\<^sub>C f (g b)"
     by (simp add: f.scaleC g.scaleC)
   have "bounded_linear (\<lambda>x. f (g x))"
     using f.bounded_linear g.bounded_linear by (rule bounded_linear_compose)
   then show "\<exists>K. \<forall>x. norm (f (g x)) \<le> norm x * K"
     by (rule bounded_linear.bounded)
 qed
 
 lemma bounded_antilinear_o_bounded_clinear:
   assumes "bounded_antilinear f"
     and "bounded_clinear g"
   shows "bounded_antilinear (\<lambda>x. f (g x))"
 proof
   interpret f: bounded_antilinear f by fact
   interpret g: bounded_clinear g by fact
   show "f (g (x + y)) = f (g x) + f (g y)" for x y
     by (simp only: f.add g.add)
   show "f (g (scaleC r x)) = scaleC (cnj r) (f (g x))" for r x
     by (simp add: f.scaleC g.scaleC)
   have "bounded_linear (\<lambda>x. f (g x))"
     using f.bounded_linear g.bounded_linear by (rule bounded_linear_compose)
   then show "\<exists>K. \<forall>x. norm (f (g x)) \<le> norm x * K"
     by (rule bounded_linear.bounded)
 qed
 
 lemma bounded_clinear_o_bounded_antilinear:
   assumes "bounded_clinear f"
     and "bounded_antilinear g"
   shows "bounded_antilinear (\<lambda>x. f (g x))"
 proof
   interpret f: bounded_clinear f by fact
   interpret g: bounded_antilinear g by fact
   show "f (g (x + y)) = f (g x) + f (g y)" for x y
     by (simp only: f.add g.add)
   show "f (g (scaleC r x)) = scaleC (cnj r) (f (g x))" for r x
     using f.scaleC g.scaleC by fastforce
   have "bounded_linear (\<lambda>x. f (g x))"
     using f.bounded_linear g.bounded_linear by (rule bounded_linear_compose)
   then show "\<exists>K. \<forall>x. norm (f (g x)) \<le> norm x * K"
     by (rule bounded_linear.bounded)
 qed
 
 lemma bij_clinear_imp_inv_clinear: "clinear (inv f)"
   if a1: "clinear f" and a2: "bij f"
 proof
   fix b1 b2 r b
   show "inv f (b1 + b2) = inv f b1 + inv f b2"
     by (simp add: a1 a2 bij_is_inj bij_is_surj complex_vector.linear_add inv_f_eq surj_f_inv_f)
   show "inv f (r *\<^sub>C b) = r *\<^sub>C inv f b"
     using that
-    by (smt bij_inv_eq_iff clinear_def complex_vector.linear_scale) 
+    by (smt bij_inv_eq_iff clinear_def complex_vector.linear_scale)
 qed
 
 
 locale bounded_sesquilinear =
-  fixes 
+  fixes
     prod :: "'a::complex_normed_vector \<Rightarrow> 'b::complex_normed_vector \<Rightarrow> 'c::complex_normed_vector"
       (infixl "**" 70)
   assumes add_left: "prod (a + a') b = prod a b + prod a' b"
     and add_right: "prod a (b + b') = prod a b + prod a b'"
     and scaleC_left: "prod (r *\<^sub>C a) b = (cnj r) *\<^sub>C (prod a b)"
     and scaleC_right: "prod a (r *\<^sub>C b) = r *\<^sub>C (prod a b)"
     and bounded: "\<exists>K. \<forall>a b. norm (prod a b) \<le> norm a * norm b * K"
 
 sublocale bounded_sesquilinear \<subseteq> bounded_bilinear
   apply standard
   by (auto simp: add_left add_right scaleC_left scaleC_right bounded scaleR_scaleC)
 
-lemma (in bounded_sesquilinear) bounded_bilinear[simp]: "bounded_bilinear prod" 
+lemma (in bounded_sesquilinear) bounded_bilinear[simp]: "bounded_bilinear prod"
   by (fact bounded_bilinear_axioms)
 
 lemma (in bounded_sesquilinear) bounded_antilinear_left: "bounded_antilinear (\<lambda>a. prod a b)"
   apply standard
     apply (auto simp add: scaleC_left add_left)
   by (metis ab_semigroup_mult_class.mult_ac(1) bounded)
 
 lemma (in bounded_sesquilinear) bounded_clinear_right: "bounded_clinear (\<lambda>b. prod a b)"
   apply standard
     apply (auto simp add: scaleC_right add_right)
   by (metis ab_semigroup_mult_class.mult_ac(1) ordered_field_class.sign_simps(34) pos_bounded)
 
 lemma (in bounded_sesquilinear) comp1:
   assumes \<open>bounded_clinear g\<close>
   shows \<open>bounded_sesquilinear (\<lambda>x. prod (g x))\<close>
 proof
   interpret bounded_clinear g by fact
   fix a a' b b' r
   show "prod (g (a + a')) b = prod (g a) b + prod (g a') b"
     by (simp add: add add_left)
   show "prod (g a) (b + b') = prod (g a) b + prod (g a) b'"
     by (simp add: add add_right)
   show "prod (g (r *\<^sub>C a)) b = cnj r *\<^sub>C prod (g a) b"
     by (simp add: scaleC scaleC_left)
   show "prod (g a) (r *\<^sub>C b) = r *\<^sub>C prod (g a) b"
     by (simp add: scaleC_right)
   interpret bounded_bilinear \<open>(\<lambda>x. prod (g x))\<close>
     by (simp add: bounded_linear comp1)
   show "\<exists>K. \<forall>a b. norm (prod (g a) b) \<le> norm a * norm b * K"
     using bounded by blast
 qed
 
 lemma (in bounded_sesquilinear) comp2:
   assumes \<open>bounded_clinear g\<close>
   shows \<open>bounded_sesquilinear (\<lambda>x y. prod x (g y))\<close>
 proof
   interpret bounded_clinear g by fact
   fix a a' b b' r
   show "prod (a + a') (g b) = prod a (g b) + prod a' (g b)"
     by (simp add: add add_left)
   show "prod a (g (b + b')) = prod a (g b) + prod a (g b')"
     by (simp add: add add_right)
   show "prod (r *\<^sub>C a) (g b) = cnj r *\<^sub>C prod a (g b)"
     by (simp add: scaleC scaleC_left)
   show "prod a (g (r *\<^sub>C b)) = r *\<^sub>C prod a (g b)"
     by (simp add: scaleC scaleC_right)
   interpret bounded_bilinear \<open>(\<lambda>x y. prod x (g y))\<close>
     apply (rule bounded_bilinear.flip)
     using _ bounded_linear apply (rule bounded_bilinear.comp1)
     using bounded_bilinear by (rule bounded_bilinear.flip)
   show "\<exists>K. \<forall>a b. norm (prod a (g b)) \<le> norm a * norm b * K"
     using bounded by blast
 qed
 
-lemma (in bounded_sesquilinear) comp: "bounded_clinear f \<Longrightarrow> bounded_clinear g \<Longrightarrow> bounded_sesquilinear (\<lambda>x y. prod (f x) (g y))" 
+lemma (in bounded_sesquilinear) comp: "bounded_clinear f \<Longrightarrow> bounded_clinear g \<Longrightarrow> bounded_sesquilinear (\<lambda>x y. prod (f x) (g y))"
   using comp1 bounded_sesquilinear.comp2 by auto
 
 lemma bounded_clinear_const_scaleR:
   fixes c :: real
   assumes \<open>bounded_clinear f\<close>
   shows \<open>bounded_clinear (\<lambda> x. c *\<^sub>R f x )\<close>
 proof-
   have  \<open>bounded_clinear (\<lambda> x. (complex_of_real c) *\<^sub>C f x )\<close>
     by (simp add: assms bounded_clinear_const_scaleC)
   thus ?thesis
-    by (simp add: scaleR_scaleC) 
+    by (simp add: scaleR_scaleC)
 qed
 
 lemma bounded_linear_bounded_clinear:
   \<open>bounded_linear A \<Longrightarrow> \<forall>c x. A (c *\<^sub>C x) = c *\<^sub>C A x \<Longrightarrow> bounded_clinear A\<close>
   apply standard
   by (simp_all add: linear_simps bounded_linear.bounded)
 
 lemma comp_bounded_clinear:
-  fixes  A :: \<open>'b::complex_normed_vector \<Rightarrow> 'c::complex_normed_vector\<close> 
+  fixes  A :: \<open>'b::complex_normed_vector \<Rightarrow> 'c::complex_normed_vector\<close>
     and B :: \<open>'a::complex_normed_vector \<Rightarrow> 'b\<close>
   assumes \<open>bounded_clinear A\<close> and \<open>bounded_clinear B\<close>
   shows \<open>bounded_clinear (A \<circ> B)\<close>
   by (metis clinear_compose assms(1) assms(2) bounded_clinear_axioms_def bounded_clinear_compose bounded_clinear_def o_def)
 
 
 lemmas isCont_scaleC [simp] =
   bounded_bilinear.isCont [OF bounded_cbilinear_scaleC[THEN bounded_cbilinear.bounded_bilinear]]
 
 subsection \<open>Misc 2\<close>
 
 lemmas sums_of_complex = bounded_linear.sums [OF bounded_clinear_of_complex[THEN bounded_clinear.bounded_linear]]
 lemmas summable_of_complex = bounded_linear.summable [OF bounded_clinear_of_complex[THEN bounded_clinear.bounded_linear]]
 lemmas suminf_of_complex = bounded_linear.suminf [OF bounded_clinear_of_complex[THEN bounded_clinear.bounded_linear]]
 
 lemmas sums_scaleC_left = bounded_linear.sums[OF bounded_clinear_scaleC_left[THEN bounded_clinear.bounded_linear]]
 lemmas summable_scaleC_left = bounded_linear.summable[OF bounded_clinear_scaleC_left[THEN bounded_clinear.bounded_linear]]
 lemmas suminf_scaleC_left = bounded_linear.suminf[OF bounded_clinear_scaleC_left[THEN bounded_clinear.bounded_linear]]
 
 lemmas sums_scaleC_right = bounded_linear.sums[OF bounded_clinear_scaleC_right[THEN bounded_clinear.bounded_linear]]
 lemmas summable_scaleC_right = bounded_linear.summable[OF bounded_clinear_scaleC_right[THEN bounded_clinear.bounded_linear]]
 lemmas suminf_scaleC_right = bounded_linear.suminf[OF bounded_clinear_scaleC_right[THEN bounded_clinear.bounded_linear]]
 
-lemma closed_scaleC: 
+lemma closed_scaleC:
   fixes S::\<open>'a::complex_normed_vector set\<close> and a :: complex
   assumes \<open>closed S\<close>
   shows \<open>closed ((*\<^sub>C) a ` S)\<close>
 proof (cases \<open>a = 0\<close>)
   case True
-  then show ?thesis 
+  then show ?thesis
     apply (cases \<open>S = {}\<close>)
     by (auto simp: image_constant)
 next
   case False
   then have \<open>(*\<^sub>C) a ` S = (*\<^sub>C) (inverse a) -` S\<close>
     by (auto simp add: rev_image_eqI)
   moreover have \<open>closed ((*\<^sub>C) (inverse a) -` S)\<close>
     by (simp add: assms continuous_closed_vimage)
   ultimately show ?thesis
     by simp
 qed
 
-lemma closure_scaleC: 
+lemma closure_scaleC:
   fixes S::\<open>'a::complex_normed_vector set\<close>
   shows \<open>closure ((*\<^sub>C) a ` S) = (*\<^sub>C) a ` closure S\<close>
 proof
   have \<open>closed (closure S)\<close>
     by simp
   show "closure ((*\<^sub>C) a ` S) \<subseteq> (*\<^sub>C) a ` closure S"
-    by (simp add: closed_scaleC closure_minimal closure_subset image_mono)    
+    by (simp add: closed_scaleC closure_minimal closure_subset image_mono)
 
   have "x \<in> closure ((*\<^sub>C) a ` S)"
     if "x \<in> (*\<^sub>C) a ` closure S"
     for x :: 'a
   proof-
     obtain t where \<open>x = ((*\<^sub>C) a) t\<close> and \<open>t \<in> closure S\<close>
       using \<open>x \<in> (*\<^sub>C) a ` closure S\<close> by auto
     have \<open>\<exists>s. (\<forall>n. s n \<in> S) \<and> s \<longlonglongrightarrow> t\<close>
       using \<open>t \<in> closure S\<close> Elementary_Topology.closure_sequential
       by blast
     then obtain s where \<open>\<forall>n. s n \<in> S\<close> and \<open>s \<longlonglongrightarrow> t\<close>
       by blast
     have \<open>(\<forall> n. scaleC a (s n) \<in> ((*\<^sub>C) a ` S))\<close>
       using \<open>\<forall>n. s n \<in> S\<close> by blast
     moreover have \<open>(\<lambda> n. scaleC a (s n)) \<longlonglongrightarrow> x\<close>
     proof-
       have \<open>isCont (scaleC a) t\<close>
         by simp
       thus ?thesis
         using  \<open>s \<longlonglongrightarrow> t\<close>  \<open>x = ((*\<^sub>C) a) t\<close>
         by (simp add: isCont_tendsto_compose)
     qed
-    ultimately show ?thesis using Elementary_Topology.closure_sequential 
+    ultimately show ?thesis using Elementary_Topology.closure_sequential
       by metis
   qed
   thus "(*\<^sub>C) a ` closure S \<subseteq> closure ((*\<^sub>C) a ` S)" by blast
 qed
 
 lemma onorm_scalarC:
   fixes f :: \<open>'a::complex_normed_vector \<Rightarrow> 'b::complex_normed_vector\<close>
   assumes a1: \<open>bounded_clinear f\<close>
   shows  \<open>onorm (\<lambda> x. r *\<^sub>C (f x)) = (cmod r) * onorm f\<close>
 proof-
   have \<open>(norm (f x)) / norm x \<le> onorm f\<close>
     for x
     using a1
-    by (simp add: bounded_clinear.bounded_linear le_onorm)        
+    by (simp add: bounded_clinear.bounded_linear le_onorm)
   hence t2: \<open>bdd_above {(norm (f x)) / norm x | x. True}\<close>
-    by fastforce 
+    by fastforce
   have \<open>continuous_on UNIV ( (*) w ) \<close>
     for w::real
     by simp
   hence \<open>isCont ( ((*) (cmod r)) ) x\<close>
     for x
-    by simp    
+    by simp
   hence t3: \<open>continuous (at_left (Sup {(norm (f x)) / norm x | x. True})) ((*) (cmod r))\<close>
     using Elementary_Topology.continuous_at_imp_continuous_within
     by blast
   have \<open>{(norm (f x)) / norm x | x. True} \<noteq> {}\<close>
-    by blast      
+    by blast
   moreover have \<open>mono ((*) (cmod r))\<close>
-    by (simp add: monoI ordered_comm_semiring_class.comm_mult_left_mono)      
+    by (simp add: monoI ordered_comm_semiring_class.comm_mult_left_mono)
   ultimately have \<open>Sup {((*) (cmod r)) ((norm (f x)) / norm x) | x. True}
          = ((*) (cmod r)) (Sup {(norm (f x)) / norm x | x. True})\<close>
     using t2 t3
-    by (simp add:  continuous_at_Sup_mono full_SetCompr_eq image_image)      
+    by (simp add:  continuous_at_Sup_mono full_SetCompr_eq image_image)
   hence  \<open>Sup {(cmod r) * ((norm (f x)) / norm x) | x. True}
          = (cmod r) * (Sup {(norm (f x)) / norm x | x. True})\<close>
     by blast
   moreover have \<open>Sup {(cmod r) * ((norm (f x)) / norm x) | x. True}
                 = (SUP x. cmod r * norm (f x) / norm x)\<close>
-    by (simp add: full_SetCompr_eq)            
+    by (simp add: full_SetCompr_eq)
   moreover have \<open>(Sup {(norm (f x)) / norm x | x. True})
                 = (SUP x. norm (f x) / norm x)\<close>
-    by (simp add: full_SetCompr_eq)      
-  ultimately have t1: "(SUP x. cmod r * norm (f x) / norm x) 
+    by (simp add: full_SetCompr_eq)
+  ultimately have t1: "(SUP x. cmod r * norm (f x) / norm x)
       = cmod r * (SUP x. norm (f x) / norm x)"
-    by simp 
+    by simp
   have \<open>onorm (\<lambda> x. r *\<^sub>C (f x)) = (SUP x. norm ( (\<lambda> t. r *\<^sub>C (f t)) x) / norm x)\<close>
     by (simp add: onorm_def)
   hence \<open>onorm (\<lambda> x. r *\<^sub>C (f x)) = (SUP x. (cmod r) * (norm (f x)) / norm x)\<close>
     by simp
   also have \<open>... = (cmod r) * (SUP x. (norm (f x)) / norm x)\<close>
     using t1.
   finally show ?thesis
-    by (simp add: onorm_def) 
+    by (simp add: onorm_def)
 qed
 
 lemma onorm_scaleC_left_lemma:
   fixes f :: "'a::complex_normed_vector"
   assumes r: "bounded_clinear r"
   shows "onorm (\<lambda>x. r x *\<^sub>C f) \<le> onorm r * norm f"
 proof (rule onorm_bound)
   fix x
   have "norm (r x *\<^sub>C f) = norm (r x) * norm f"
     by simp
   also have "\<dots> \<le> onorm r * norm x * norm f"
     by (simp add: bounded_clinear.bounded_linear mult.commute mult_left_mono onorm r)
   finally show "norm (r x *\<^sub>C f) \<le> onorm r * norm f * norm x"
     by (simp add: ac_simps)
   show "0 \<le> onorm r * norm f"
     by (simp add: bounded_clinear.bounded_linear onorm_pos_le r)
 qed
 
 lemma onorm_scaleC_left:
   fixes f :: "'a::complex_normed_vector"
   assumes f: "bounded_clinear r"
   shows "onorm (\<lambda>x. r x *\<^sub>C f) = onorm r * norm f"
 proof (cases "f = 0")
   assume "f \<noteq> 0"
   show ?thesis
   proof (rule order_antisym)
     show "onorm (\<lambda>x. r x *\<^sub>C f) \<le> onorm r * norm f"
       using f by (rule onorm_scaleC_left_lemma)
   next
     have bl1: "bounded_clinear (\<lambda>x. r x *\<^sub>C f)"
       by (metis bounded_clinear_scaleC_const f)
     have x1:"bounded_clinear (\<lambda>x. r x * norm f)"
       by (metis bounded_clinear_mult_const f)
 
     have "onorm r \<le> onorm (\<lambda>x. r x * complex_of_real (norm f)) / norm f"
       if "onorm r \<le> onorm (\<lambda>x. r x * complex_of_real (norm f)) * cmod (1 / complex_of_real (norm f))"
         and "f \<noteq> 0"
       using that
-      by (metis complex_of_real_cmod complex_of_real_nn_iff field_class.field_divide_inverse 
-          inverse_eq_divide nice_ordered_field_class.zero_le_divide_1_iff norm_ge_zero of_real_1 
-          of_real_divide of_real_eq_iff) 
+      by (metis complex_of_real_cmod complex_of_real_nn_iff field_class.field_divide_inverse
+          inverse_eq_divide nice_ordered_field_class.zero_le_divide_1_iff norm_ge_zero of_real_1
+          of_real_divide of_real_eq_iff)
     hence "onorm r \<le> onorm (\<lambda>x. r x * norm f) * inverse (norm f)"
       using \<open>f \<noteq> 0\<close> onorm_scaleC_left_lemma[OF x1, of "inverse (norm f)"]
       by (simp add: inverse_eq_divide)
     also have "onorm (\<lambda>x. r x * norm f) \<le> onorm (\<lambda>x. r x *\<^sub>C f)"
     proof (rule onorm_bound)
       have "bounded_linear (\<lambda>x. r x *\<^sub>C f)"
         using bl1 bounded_clinear.bounded_linear by auto
       thus "0 \<le> onorm (\<lambda>x. r x *\<^sub>C f)"
         by (rule Operator_Norm.onorm_pos_le)
       show "cmod (r x * complex_of_real (norm f)) \<le> onorm (\<lambda>x. r x *\<^sub>C f) * norm x"
         for x :: 'b
-        by (smt \<open>bounded_linear (\<lambda>x. r x *\<^sub>C f)\<close> complex_of_real_cmod complex_of_real_nn_iff 
-            complex_scaleC_def norm_ge_zero norm_scaleC of_real_eq_iff onorm)      
+        by (smt \<open>bounded_linear (\<lambda>x. r x *\<^sub>C f)\<close> complex_of_real_cmod complex_of_real_nn_iff
+            complex_scaleC_def norm_ge_zero norm_scaleC of_real_eq_iff onorm)
     qed
     finally show "onorm r * norm f \<le> onorm (\<lambda>x. r x *\<^sub>C f)"
       using \<open>f \<noteq> 0\<close>
       by (simp add: inverse_eq_divide pos_le_divide_eq mult.commute)
   qed
 qed (simp add: onorm_zero)
 
 subsection \<open>Finite dimension and canonical basis\<close>
 
 lemma vector_finitely_spanned:
   assumes \<open>z \<in> cspan T\<close>
   shows \<open>\<exists> S. finite S \<and> S \<subseteq> T \<and> z \<in> cspan S\<close>
 proof-
   have \<open>\<exists> S r. finite S \<and> S \<subseteq> T \<and> z = (\<Sum>a\<in>S. r a *\<^sub>C a)\<close>
     using complex_vector.span_explicit[where b = "T"]
       assms by auto
   then obtain S r where \<open>finite S\<close> and \<open>S \<subseteq> T\<close> and \<open>z = (\<Sum>a\<in>S. r a *\<^sub>C a)\<close>
     by blast
   thus ?thesis
-    by (meson complex_vector.span_scale complex_vector.span_sum complex_vector.span_superset subset_iff) 
+    by (meson complex_vector.span_scale complex_vector.span_sum complex_vector.span_superset subset_iff)
 qed
 
 setup \<open>Sign.add_const_constraint ("Complex_Vector_Spaces0.cindependent", SOME \<^typ>\<open>'a set \<Rightarrow> bool\<close>)\<close>
 setup \<open>Sign.add_const_constraint (\<^const_name>\<open>cdependent\<close>, SOME \<^typ>\<open>'a set \<Rightarrow> bool\<close>)\<close>
 setup \<open>Sign.add_const_constraint (\<^const_name>\<open>cspan\<close>, SOME \<^typ>\<open>'a set \<Rightarrow> 'a set\<close>)\<close>
 
 class cfinite_dim = complex_vector +
   assumes cfinitely_spanned: "\<exists>S::'a set. finite S \<and> cspan S = UNIV"
 
 class basis_enum = complex_vector +
   fixes canonical_basis :: "'a list"
-  assumes distinct_canonical_basis[simp]: 
+  assumes distinct_canonical_basis[simp]:
     "distinct canonical_basis"
     and is_cindependent_set[simp]:
     "cindependent (set canonical_basis)"
     and is_generator_set[simp]:
-    "cspan (set canonical_basis) = UNIV" 
+    "cspan (set canonical_basis) = UNIV"
 
 setup \<open>Sign.add_const_constraint ("Complex_Vector_Spaces0.cindependent", SOME \<^typ>\<open>'a::complex_vector set \<Rightarrow> bool\<close>)\<close>
 setup \<open>Sign.add_const_constraint (\<^const_name>\<open>cdependent\<close>, SOME \<^typ>\<open>'a::complex_vector set \<Rightarrow> bool\<close>)\<close>
 setup \<open>Sign.add_const_constraint (\<^const_name>\<open>cspan\<close>, SOME \<^typ>\<open>'a::complex_vector set \<Rightarrow> 'a set\<close>)\<close>
 
 lemma cdim_UNIV_basis_enum[simp]: \<open>cdim (UNIV::'a::basis_enum set) = length (canonical_basis::'a list)\<close>
   apply (subst is_generator_set[symmetric])
   apply (subst complex_vector.dim_span_eq_card_independent)
    apply (rule is_cindependent_set)
   using distinct_canonical_basis distinct_card by blast
 
 lemma finite_basis: "\<exists>basis::'a::cfinite_dim set. finite basis \<and> cindependent basis \<and> cspan basis = UNIV"
 proof -
   from cfinitely_spanned
   obtain S :: \<open>'a set\<close> where \<open>finite S\<close> and \<open>cspan S = UNIV\<close>
     by auto
   from complex_vector.maximal_independent_subset
   obtain B :: \<open>'a set\<close> where \<open>B \<subseteq> S\<close> and \<open>cindependent B\<close> and \<open>S \<subseteq> cspan B\<close>
     by metis
   moreover have \<open>finite B\<close>
     using \<open>B \<subseteq> S\<close> \<open>finite S\<close>
-    by (meson finite_subset) 
+    by (meson finite_subset)
   moreover have \<open>cspan B = UNIV\<close>
     using \<open>cspan S = UNIV\<close> \<open>S \<subseteq> cspan B\<close>
     by (metis complex_vector.span_eq top_greatest)
   ultimately show ?thesis
     by auto
 qed
 
 instance basis_enum \<subseteq> cfinite_dim
   apply intro_classes
   apply (rule exI[of _ \<open>set canonical_basis\<close>])
   using is_cindependent_set is_generator_set by auto
 
 lemma cindependent_cfinite_dim_finite:
   assumes \<open>cindependent (S::'a::cfinite_dim set)\<close>
   shows \<open>finite S\<close>
   by (metis assms cfinitely_spanned complex_vector.independent_span_bound top_greatest)
 
 lemma cfinite_dim_finite_subspace_basis:
   assumes \<open>csubspace X\<close>
   shows "\<exists>basis::'a::cfinite_dim set. finite basis \<and> cindependent basis \<and> cspan basis = X"
   by (meson assms cindependent_cfinite_dim_finite complex_vector.basis_exists complex_vector.span_subspace)
 
 
 text \<open>The following auxiliary lemma (\<open>finite_span_complete_aux\<close>) shows more or less the same as \<open>finite_span_representation_bounded\<close>,
-   \<open>finite_span_complete\<close> below (see there for an intuition about the mathematical 
+   \<open>finite_span_complete\<close> below (see there for an intuition about the mathematical
    content of the lemmas). However, there is one difference: Here we additionally assume here
    that there is a bijection rep/abs between a finite type \<^typ>\<open>'basis\<close> and the set $B$.
    This is needed to be able to use results about euclidean spaces that are formulated w.r.t.
    the type class \<^class>\<open>finite\<close>
 
    Since we anyway assume that $B$ is finite, this added assumption does not make the lemma
    weaker. However, we cannot derive the existence of \<^typ>\<open>'basis\<close> inside the proof
    (HOL does not support such reasoning). Therefore we have the type \<^typ>\<open>'basis\<close> as
    an explicit assumption and remove it using @{attribute internalize_sort} after the proof.\<close>
 
 lemma finite_span_complete_aux:
   fixes b :: "'b::real_normed_vector" and B :: "'b set"
     and  rep :: "'basis::finite \<Rightarrow> 'b" and abs :: "'b \<Rightarrow> 'basis"
   assumes t: "type_definition rep abs B"
     and t1: "finite B" and t2: "b\<in>B" and t3: "independent B"
   shows "\<exists>D>0. \<forall>\<psi>. norm (representation B \<psi> b) \<le> norm \<psi> * D"
     and "complete (span B)"
 proof -
   define repr  where "repr = real_vector.representation B"
   define repr' where "repr' \<psi> = Abs_euclidean_space (repr \<psi> o rep)" for \<psi>
   define comb  where "comb l = (\<Sum>b\<in>B. l b *\<^sub>R b)" for l
   define comb' where "comb' l = comb (Rep_euclidean_space l o abs)" for l
 
   have comb_cong: "comb x = comb y" if "\<And>z. z\<in>B \<Longrightarrow> x z = y z" for x y
     unfolding comb_def using that by auto
   have comb_repr[simp]: "comb (repr \<psi>) = \<psi>" if "\<psi> \<in> real_vector.span B" for \<psi>
-    using \<open>comb \<equiv> \<lambda>l. \<Sum>b\<in>B. l b *\<^sub>R b\<close> local.repr_def real_vector.sum_representation_eq t1 t3 that 
-    by fastforce    
+    using \<open>comb \<equiv> \<lambda>l. \<Sum>b\<in>B. l b *\<^sub>R b\<close> local.repr_def real_vector.sum_representation_eq t1 t3 that
+    by fastforce
 
   have w5:"(\<Sum>b | (b \<in> B \<longrightarrow> x b \<noteq> 0) \<and> b \<in> B. x b *\<^sub>R b) =
     (\<Sum>b\<in>B. x b *\<^sub>R b)" for x
     using \<open>finite B\<close>
     by (smt DiffD1 DiffD2 mem_Collect_eq real_vector.scale_eq_0_iff subset_eq sum.mono_neutral_left)
   have "representation B (\<Sum>b\<in>B. x b *\<^sub>R b) =  (\<lambda>b. if b \<in> B then x b else 0)"
     for x
   proof (rule real_vector.representation_eqI)
     show "independent B"
-      by (simp add: t3)      
+      by (simp add: t3)
     show "(\<Sum>b\<in>B. x b *\<^sub>R b) \<in> span B"
-      by (meson real_vector.span_scale real_vector.span_sum real_vector.span_superset subset_iff)      
+      by (meson real_vector.span_scale real_vector.span_sum real_vector.span_superset subset_iff)
     show "b \<in> B"
       if "(if b \<in> B then x b else 0) \<noteq> 0"
       for b :: 'b
       using that
-      by meson 
+      by meson
     show "finite {b. (if b \<in> B then x b else 0) \<noteq> 0}"
-      using t1 by auto      
+      using t1 by auto
     show "(\<Sum>b | (if b \<in> B then x b else 0) \<noteq> 0. (if b \<in> B then x b else 0) *\<^sub>R b) = (\<Sum>b\<in>B. x b *\<^sub>R b)"
       using w5
       by simp
   qed
   hence repr_comb[simp]: "repr (comb x) = (\<lambda>b. if b\<in>B then x b else 0)" for x
     unfolding repr_def comb_def.
   have repr_bad[simp]: "repr \<psi> = (\<lambda>_. 0)" if "\<psi> \<notin> real_vector.span B" for \<psi>
     unfolding repr_def using that
     by (simp add: real_vector.representation_def)
   have [simp]: "repr' \<psi> = 0" if "\<psi> \<notin> real_vector.span B" for \<psi>
     unfolding repr'_def repr_bad[OF that]
     apply transfer
     by auto
-  have comb'_repr'[simp]: "comb' (repr' \<psi>) = \<psi>" 
+  have comb'_repr'[simp]: "comb' (repr' \<psi>) = \<psi>"
     if "\<psi> \<in> real_vector.span B" for \<psi>
   proof -
     have x1: "(repr \<psi> \<circ> rep \<circ> abs) z = repr \<psi> z"
       if "z \<in> B"
       for z
       unfolding o_def
       using t that type_definition.Abs_inverse by fastforce
     have "comb' (repr' \<psi>) = comb ((repr \<psi> \<circ> rep) \<circ> abs)"
       unfolding comb'_def repr'_def
       by (subst Abs_euclidean_space_inverse; simp)
     also have "\<dots> = comb (repr \<psi>)"
       using x1 comb_cong by blast
     also have "\<dots> = \<psi>"
       using that by simp
     finally show ?thesis by -
   qed
 
   have t1: "Abs_euclidean_space (Rep_euclidean_space t) = t"
     if "\<And>x. rep x \<in> B"
     for t::"'a euclidean_space"
     apply (subst Rep_euclidean_space_inverse)
     by simp
   have "Abs_euclidean_space
-     (\<lambda>y. if rep y \<in> B 
+     (\<lambda>y. if rep y \<in> B
            then Rep_euclidean_space x y
            else 0) = x"
     for x
     using type_definition.Rep[OF t] apply simp
     using t1 by blast
   hence "Abs_euclidean_space
      (\<lambda>y. if rep y \<in> B
            then Rep_euclidean_space x (abs (rep y))
            else 0) = x"
     for x
     apply (subst type_definition.Rep_inverse[OF t])
     by simp
   hence repr'_comb'[simp]: "repr' (comb' x) = x" for x
     unfolding comb'_def repr'_def o_def
     by simp
   have sphere: "compact (sphere 0 d :: 'basis euclidean_space set)" for d
     using compact_sphere by blast
   have "complete (UNIV :: 'basis euclidean_space set)"
     by (simp add: complete_UNIV)
 
 
   have "(\<Sum>b\<in>B. (Rep_euclidean_space (x + y) \<circ> abs) b *\<^sub>R b) = (\<Sum>b\<in>B. (Rep_euclidean_space x \<circ> abs) b *\<^sub>R b) + (\<Sum>b\<in>B. (Rep_euclidean_space y \<circ> abs) b *\<^sub>R b)"
     for x :: "'basis euclidean_space"
       and y :: "'basis euclidean_space"
     apply (transfer fixing: abs)
     by (simp add: scaleR_add_left sum.distrib)
   moreover have "(\<Sum>b\<in>B. (Rep_euclidean_space (c *\<^sub>R x) \<circ> abs) b *\<^sub>R b) = c *\<^sub>R (\<Sum>b\<in>B. (Rep_euclidean_space x \<circ> abs) b *\<^sub>R b)"
     for c :: real
       and x :: "'basis euclidean_space"
     apply (transfer fixing: abs)
     by (simp add: real_vector.scale_sum_right)
   ultimately have blin_comb': "bounded_linear comb'"
-    unfolding comb_def comb'_def 
+    unfolding comb_def comb'_def
     by (rule bounded_linearI')
   hence "continuous_on X comb'" for X
     by (simp add: linear_continuous_on)
   hence "compact (comb' ` sphere 0 d)" for d
     using sphere
     by (rule compact_continuous_image)
   hence compact_norm_comb': "compact (norm ` comb' ` sphere 0 1)"
     using compact_continuous_image continuous_on_norm_id by blast
   have not0: "0 \<notin> norm ` comb' ` sphere 0 1"
   proof (rule ccontr, simp)
     assume "0 \<in> norm ` comb' ` sphere 0 1"
     then obtain x where nc0: "norm (comb' x) = 0" and x: "x \<in> sphere 0 1"
       by auto
     hence "comb' x = 0"
       by simp
     hence "repr' (comb' x) = 0"
       unfolding repr'_def o_def repr_def apply simp
       by (smt repr'_comb' blin_comb' dist_0_norm linear_simps(3) mem_sphere norm_zero x)
     hence "x = 0"
       by auto
     with x show False
       by simp
   qed
 
   have "closed (norm ` comb' ` sphere 0 1)"
-    using compact_imp_closed compact_norm_comb' by blast    
+    using compact_imp_closed compact_norm_comb' by blast
   moreover have "0 \<notin> norm ` comb' ` sphere 0 1"
-    by (simp add: not0)    
+    by (simp add: not0)
   ultimately have "\<exists>d>0. \<forall>x\<in>norm ` comb' ` sphere 0 1. d \<le> dist 0 x"
     by (meson separate_point_closed)
 
-  then obtain d where d: "x\<in>norm ` comb' ` sphere 0 1 \<Longrightarrow> d \<le> dist 0 x"  
+  then obtain d where d: "x\<in>norm ` comb' ` sphere 0 1 \<Longrightarrow> d \<le> dist 0 x"
     and "d > 0" for x
     by metis
   define D where "D = 1/d"
   hence "D > 0"
     using \<open>d>0\<close> unfolding D_def by auto
-  have "x \<ge> d"  
-    if "x\<in>norm ` comb' ` sphere 0 1" 
+  have "x \<ge> d"
+    if "x\<in>norm ` comb' ` sphere 0 1"
     for x
     using d that
     apply auto
     by fastforce
   hence *: "norm (comb' x) \<ge> d" if "norm x = 1" for x
     using that by auto
   have norm_comb': "norm (comb' x) \<ge> d * norm x" for x
   proof (cases "x=0")
     show "d * norm x \<le> norm (comb' x)"
       if "x = 0"
       using that
-      by simp 
+      by simp
     show "d * norm x \<le> norm (comb' x)"
       if "x \<noteq> 0"
       using that
       using *[of "(1/norm x) *\<^sub>R x"]
       unfolding linear_simps(5)[OF blin_comb']
       apply auto
       by (simp add: le_divide_eq)
   qed
 
   have *:  "norm (repr' \<psi>) \<le> norm \<psi> * D" for \<psi>
   proof (cases "\<psi> \<in> real_vector.span B")
     show "norm (repr' \<psi>) \<le> norm \<psi> * D"
       if "\<psi> \<in> span B"
       using that     unfolding D_def
       using norm_comb'[of "repr' \<psi>"] \<open>d>0\<close>
       by (simp_all add: linordered_field_class.mult_imp_le_div_pos mult.commute)
 
     show "norm (repr' \<psi>) \<le> norm \<psi> * D"
       if "\<psi> \<notin> span B"
-      using that \<open>0 < D\<close> by auto 
+      using that \<open>0 < D\<close> by auto
   qed
 
   hence "norm (Rep_euclidean_space (repr' \<psi>) (abs b)) \<le> norm \<psi> * D" for \<psi>
   proof -
     have "(Rep_euclidean_space (repr' \<psi>) (abs b)) = repr' \<psi> \<bullet> euclidean_space_basis_vector (abs b)"
       apply (transfer fixing: abs b)
       by auto
     also have "\<bar>\<dots>\<bar> \<le> norm (repr' \<psi>)"
       apply (rule Basis_le_norm)
       unfolding Basis_euclidean_space_def by simp
     also have "\<dots> \<le> norm \<psi> * D"
       using * by auto
     finally show ?thesis by simp
   qed
   hence "norm (repr \<psi> b) \<le> norm \<psi> * D" for \<psi>
     unfolding repr'_def
-    by (smt \<open>comb' \<equiv> \<lambda>l. comb (Rep_euclidean_space l \<circ> abs)\<close> 
-        \<open>repr' \<equiv> \<lambda>\<psi>. Abs_euclidean_space (repr \<psi> \<circ> rep)\<close> comb'_repr' comp_apply norm_le_zero_iff 
-        repr_bad repr_comb)     
+    by (smt \<open>comb' \<equiv> \<lambda>l. comb (Rep_euclidean_space l \<circ> abs)\<close>
+        \<open>repr' \<equiv> \<lambda>\<psi>. Abs_euclidean_space (repr \<psi> \<circ> rep)\<close> comb'_repr' comp_apply norm_le_zero_iff
+        repr_bad repr_comb)
   thus "\<exists>D>0. \<forall>\<psi>. norm (repr \<psi> b) \<le> norm \<psi> * D"
     using \<open>D>0\<close> by auto
   from \<open>d>0\<close>
   have complete_comb': "complete (comb' ` UNIV)"
   proof (rule complete_isometric_image)
     show "subspace (UNIV::'basis euclidean_space set)"
-      by simp      
+      by simp
     show "bounded_linear comb'"
-      by (simp add: blin_comb')      
+      by (simp add: blin_comb')
     show "\<forall>x\<in>UNIV. d * norm x \<le> norm (comb' x)"
-      by (simp add: norm_comb')      
+      by (simp add: norm_comb')
     show "complete (UNIV::'basis euclidean_space set)"
-      by (simp add: \<open>complete UNIV\<close>)      
+      by (simp add: \<open>complete UNIV\<close>)
   qed
 
   have range_comb': "comb' ` UNIV = real_vector.span B"
   proof (auto simp: image_def)
     show "comb' x \<in> real_vector.span B" for x
       by (metis comb'_def comb_cong comb_repr local.repr_def repr_bad repr_comb real_vector.representation_zero real_vector.span_zero)
   next
     fix \<psi> assume "\<psi> \<in> real_vector.span B"
     then obtain f where f: "comb f = \<psi>"
       apply atomize_elim
       unfolding span_finite[OF \<open>finite B\<close>] comb_def
       by auto
     define f' where "f' b = (if b\<in>B then f b else 0)" for b :: 'b
     have f': "comb f' = \<psi>"
       unfolding f[symmetric]
       apply (rule comb_cong)
       unfolding f'_def by simp
     define x :: "'basis euclidean_space" where "x = Abs_euclidean_space (f' o rep)"
     have "\<psi> = comb' x"
-      by (metis (no_types, lifting) \<open>\<psi> \<in> span B\<close> \<open>repr' \<equiv> \<lambda>\<psi>. Abs_euclidean_space (repr \<psi> \<circ> rep)\<close> 
+      by (metis (no_types, lifting) \<open>\<psi> \<in> span B\<close> \<open>repr' \<equiv> \<lambda>\<psi>. Abs_euclidean_space (repr \<psi> \<circ> rep)\<close>
           comb'_repr' f' fun.map_cong repr_comb t type_definition.Rep_range x_def)
     thus "\<exists>x. \<psi> = comb' x"
       by auto
   qed
 
   from range_comb' complete_comb'
   show "complete (real_vector.span B)"
     by simp
 qed
 
 lemma finite_span_complete[simp]:
   fixes A :: "'a::real_normed_vector set"
   assumes "finite A"
   shows "complete (span A)"
   text \<open>The span of a finite set is complete.\<close>
 proof (cases "A \<noteq> {} \<and> A \<noteq> {0}")
   case True
   obtain B where
     BT: "real_vector.span B = real_vector.span A"
-    and "independent B"  
+    and "independent B"
     and "finite B"
     by (meson True assms finite_subset real_vector.maximal_independent_subset real_vector.span_eq
         real_vector.span_superset subset_trans)
 
   have "B\<noteq>{}"
     apply (rule ccontr, simp)
     using BT True
     by (metis real_vector.span_superset real_vector.span_empty subset_singletonD)
 
 (* The following generalizes finite_span_complete_aux to hold without the assumption
      that 'basis has type class finite *)
   {
     (* The type variable 'basisT must not be the same as the one used in finite_span_complete_aux,
        otherwise "internalize_sort" below fails *)
     assume "\<exists>(Rep :: 'basisT\<Rightarrow>'a) Abs. type_definition Rep Abs B"
     then obtain rep :: "'basisT \<Rightarrow> 'a" and abs :: "'a \<Rightarrow> 'basisT" where t: "type_definition rep abs B"
       by auto
     have basisT_finite: "class.finite TYPE('basisT)"
       apply intro_classes
       using \<open>finite B\<close> t
-      by (metis (mono_tags, hide_lams) ex_new_if_finite finite_imageI image_eqI type_definition_def)
+      by (metis (mono_tags, opaque_lifting) ex_new_if_finite finite_imageI image_eqI type_definition_def)
     note finite_span_complete_aux(2)[internalize_sort "'basis::finite"]
     note this[OF basisT_finite t]
   }
   note this[cancel_type_definition, OF \<open>B\<noteq>{}\<close> \<open>finite B\<close> _ \<open>independent B\<close>]
   hence "complete (real_vector.span B)"
     using \<open>B\<noteq>{}\<close> by auto
   thus "complete (real_vector.span A)"
     unfolding BT by simp
 next
   case False
   thus ?thesis
     using complete_singleton by auto
 qed
 
 
 lemma finite_span_representation_bounded:
   fixes B :: "'a::real_normed_vector set"
   assumes "finite B" and "independent B"
   shows "\<exists>D>0. \<forall>\<psi> b. abs (representation B \<psi> b) \<le> norm \<psi> * D"
 
   text \<open>
   Assume $B$ is a finite linear independent set of vectors (in a real normed vector space).
   Let $\alpha^\psi_b$ be the coefficients of $\psi$ expressed as a linear combination over $B$.
   Then $\alpha$ is is uniformly cblinfun (i.e., $\lvert\alpha^\psi_b \leq D \lVert\psi\rVert\psi$
   for some $D$ independent of $\psi,b$).
 
   (This also holds when $b$ is not in the span of $B$ because of the way \<open>real_vector.representation\<close>
   is defined in this corner case.)\<close>
 
 proof (cases "B\<noteq>{}")
   case True
 
 (* The following generalizes finite_span_complete_aux to hold without the assumption
      that 'basis has type class finite *)
   define repr  where "repr = real_vector.representation B"
   {
     (* Step 1: Create a fake type definition by introducing a new type variable 'basis
                and then assuming the existence of the morphisms Rep/Abs to B
                This is then roughly equivalent to "typedef 'basis = B" *)
     (* The type variable 'basisT must not be the same as the one used in finite_span_complete_aux
        (I.e., we cannot call it 'basis) *)
     assume "\<exists>(Rep :: 'basisT\<Rightarrow>'a) Abs. type_definition Rep Abs B"
     then obtain rep :: "'basisT \<Rightarrow> 'a" and abs :: "'a \<Rightarrow> 'basisT" where t: "type_definition rep abs B"
       by auto
         (* Step 2: We show that our fake typedef 'basisT could be instantiated as type class finite *)
     have basisT_finite: "class.finite TYPE('basisT)"
-      apply intro_classes 
+      apply intro_classes
       using \<open>finite B\<close> t
-      by (metis (mono_tags, hide_lams) ex_new_if_finite finite_imageI image_eqI type_definition_def)
+      by (metis (mono_tags, opaque_lifting) ex_new_if_finite finite_imageI image_eqI type_definition_def)
         (* Step 3: We take the finite_span_complete_aux and remove the requirement that 'basis::finite
                (instead, a precondition "class.finite TYPE('basisT)" is introduced) *)
     note finite_span_complete_aux(1)[internalize_sort "'basis::finite"]
       (* Step 4: We instantiate the premises *)
     note this[OF basisT_finite t]
   }
     (* Now we have the desired fact, except that it still assumes that B is isomorphic to some type 'basis
      together with the assumption that there are morphisms between 'basis and B. 'basis and that premise
      are removed using cancel_type_definition
   *)
   note this[cancel_type_definition, OF True \<open>finite B\<close> _ \<open>independent B\<close>]
 
   hence d2:"\<exists>D. \<forall>\<psi>. D>0 \<and> norm (repr \<psi> b) \<le> norm \<psi> * D" if \<open>b\<in>B\<close> for b
     by (simp add: repr_def that True)
   have d1: " (\<And>b. b \<in> B \<Longrightarrow>
           \<exists>D. \<forall>\<psi>. 0 < D \<and> norm (repr \<psi> b) \<le> norm \<psi> * D) \<Longrightarrow>
     \<exists>D. \<forall>b \<psi>. b \<in> B \<longrightarrow>
                0 < D b \<and> norm (repr \<psi> b) \<le> norm \<psi> * D b"
     apply (rule choice) by auto
   then obtain D where D: "D b > 0 \<and> norm (repr \<psi> b) \<le> norm \<psi> * D b" if "b\<in>B" for b \<psi>
     apply atomize_elim
     using d2 by blast
 
-  hence Dpos: "D b > 0" and Dbound: "norm (repr \<psi> b) \<le> norm \<psi> * D b" 
+  hence Dpos: "D b > 0" and Dbound: "norm (repr \<psi> b) \<le> norm \<psi> * D b"
     if "b\<in>B" for b \<psi>
     using that by auto
   define Dall where "Dall = Max (D`B)"
   have "Dall > 0"
     unfolding Dall_def using \<open>finite B\<close> \<open>B\<noteq>{}\<close> Dpos
     by (metis (mono_tags, lifting) Max_in finite_imageI image_iff image_is_empty)
   have "Dall \<ge> D b" if "b\<in>B" for b
     unfolding Dall_def using \<open>finite B\<close> that by auto
   with Dbound
   have "norm (repr \<psi> b) \<le> norm \<psi> * Dall" if "b\<in>B" for b \<psi>
     using that
-    by (smt mult_left_mono norm_not_less_zero) 
+    by (smt mult_left_mono norm_not_less_zero)
   moreover have "norm (repr \<psi> b) \<le> norm \<psi> * Dall" if "b\<notin>B" for b \<psi>
     unfolding repr_def using real_vector.representation_ne_zero True
-    by (metis calculation empty_subsetI less_le_trans local.repr_def norm_ge_zero norm_zero not_less 
+    by (metis calculation empty_subsetI less_le_trans local.repr_def norm_ge_zero norm_zero not_less
         subsetI subset_antisym)
   ultimately show "\<exists>D>0. \<forall>\<psi> b. abs (repr \<psi> b) \<le> norm \<psi> * D"
     using \<open>Dall > 0\<close> real_norm_def by metis
 next
   case False
   thus ?thesis
     unfolding repr_def using real_vector.representation_ne_zero[of B]
     using nice_ordered_field_class.linordered_field_no_ub by fastforce
 qed
 
 hide_fact finite_span_complete_aux
 
 
-lemma finite_cspan_complete[simp]: 
+lemma finite_cspan_complete[simp]:
   fixes B :: "'a::complex_normed_vector set"
   assumes "finite B"
   shows "complete (cspan B)"
   by (simp add: assms cspan_as_span)
 
 
 lemma finite_span_closed[simp]:
   fixes B :: "'a::real_normed_vector set"
   assumes "finite B"
   shows "closed (real_vector.span B)"
   by (simp add: assms complete_imp_closed)
 
 
 lemma finite_cspan_closed[simp]:
   fixes S::\<open>'a::complex_normed_vector set\<close>
   assumes a1: \<open>finite S\<close>
-  shows \<open>closed (cspan S)\<close>  
+  shows \<open>closed (cspan S)\<close>
   by (simp add: assms complete_imp_closed)
 
 lemma closure_finite_cspan:
   fixes T::\<open>'a::complex_normed_vector set\<close>
   assumes \<open>finite T\<close>
   shows \<open>closure (cspan T)  = cspan T\<close>
   by (simp add: assms)
 
 
 lemma finite_cspan_crepresentation_bounded:
   fixes B :: "'a::complex_normed_vector set"
   assumes a1: "finite B" and a2: "cindependent B"
   shows "\<exists>D>0. \<forall>\<psi> b. norm (crepresentation B \<psi> b) \<le> norm \<psi> * D"
 proof -
   define B' where "B' = (B \<union> scaleC \<i> ` B)"
   have independent_B': "independent B'"
     using B'_def \<open>cindependent B\<close>
     by (simp add: real_independent_from_complex_independent a1)
   have "finite B'"
     unfolding B'_def using \<open>finite B\<close> by simp
-  obtain D' where "D' > 0" and D': "norm (real_vector.representation B' \<psi> b) \<le> norm \<psi> * D'" 
+  obtain D' where "D' > 0" and D': "norm (real_vector.representation B' \<psi> b) \<le> norm \<psi> * D'"
     for \<psi> b
     apply atomize_elim
     using independent_B' \<open>finite B'\<close>
     by (simp add: finite_span_representation_bounded)
 
-  define D where "D = 2*D'" 
+  define D where "D = 2*D'"
   from \<open>D' > 0\<close> have \<open>D > 0\<close>
     unfolding D_def by simp
   have "norm (crepresentation B \<psi> b) \<le> norm \<psi> * D" for \<psi> b
   proof (cases "b\<in>B")
     case True
     have d3: "norm \<i> = 1"
-      by simp          
+      by simp
 
     have "norm (\<i> *\<^sub>C complex_of_real (real_vector.representation B' \<psi> (\<i> *\<^sub>C b)))
           = norm \<i> * norm (complex_of_real (real_vector.representation B' \<psi> (\<i> *\<^sub>C b)))"
       using norm_scaleC by blast
     also have "\<dots> = norm (complex_of_real (real_vector.representation B' \<psi> (\<i> *\<^sub>C b)))"
       using d3 by simp
     finally have d2:"norm (\<i> *\<^sub>C complex_of_real (real_vector.representation B' \<psi> (\<i> *\<^sub>C b)))
           = norm (complex_of_real (real_vector.representation B' \<psi> (\<i> *\<^sub>C b)))".
     have "norm (crepresentation B \<psi> b)
         = norm (complex_of_real (real_vector.representation B' \<psi> b)
             + \<i> *\<^sub>C complex_of_real (real_vector.representation B' \<psi> (\<i> *\<^sub>C b)))"
-      by (simp add: B'_def True a1 a2 crepresentation_from_representation)      
+      by (simp add: B'_def True a1 a2 crepresentation_from_representation)
     also have "\<dots> \<le> norm (complex_of_real (real_vector.representation B' \<psi> b))
              + norm (\<i> *\<^sub>C complex_of_real (real_vector.representation B' \<psi> (\<i> *\<^sub>C b)))"
       using norm_triangle_ineq by blast
     also have "\<dots> = norm (complex_of_real (real_vector.representation B' \<psi> b))
                   + norm (complex_of_real (real_vector.representation B' \<psi> (\<i> *\<^sub>C b)))"
       using d2 by simp
     also have "\<dots> = norm (real_vector.representation B' \<psi> b)
                   + norm (real_vector.representation B' \<psi> (\<i> *\<^sub>C b))"
       by simp
     also have "\<dots> \<le> norm \<psi> * D' + norm \<psi> * D'"
       by (rule add_mono; rule D')
     also have "\<dots> \<le> norm \<psi> * D"
       unfolding D_def by linarith
     finally show ?thesis
       by auto
   next
     case False
     hence "crepresentation B \<psi> b = 0"
-      using complex_vector.representation_ne_zero by blast      
+      using complex_vector.representation_ne_zero by blast
     thus ?thesis
       by (smt \<open>0 < D\<close> norm_ge_zero norm_zero split_mult_pos_le)
   qed
   with \<open>D > 0\<close>
   show ?thesis
     by auto
 qed
 
 lemma bounded_clinear_finite_dim[simp]:
   fixes f :: \<open>'a::{cfinite_dim,complex_normed_vector} \<Rightarrow> 'b::complex_normed_vector\<close>
   assumes \<open>clinear f\<close>
   shows \<open>bounded_clinear f\<close>
 proof -
   include notation_norm
   obtain basis :: \<open>'a set\<close> where b1: "complex_vector.span basis = UNIV"
     and b2: "cindependent basis"
-    and b3:"finite basis" 
+    and b3:"finite basis"
     using finite_basis by auto
   have "\<exists>C>0. \<forall>\<psi> b. cmod (crepresentation basis \<psi> b) \<le> \<parallel>\<psi>\<parallel> * C"
     using finite_cspan_crepresentation_bounded[where B = basis] b2 b3 by blast
-  then obtain C where s1: "cmod (crepresentation basis \<psi> b) \<le> \<parallel>\<psi>\<parallel> * C" 
+  then obtain C where s1: "cmod (crepresentation basis \<psi> b) \<le> \<parallel>\<psi>\<parallel> * C"
     and s2: "C > 0"
   for \<psi> b by blast
   define M where "M = C * (\<Sum>a\<in>basis. \<parallel>f a\<parallel>)"
   have "\<parallel>f x\<parallel> \<le> \<parallel>x\<parallel> * M"
     for x
   proof-
     define r where "r b = crepresentation basis x b" for b
     have x_span: "x \<in> complex_vector.span basis"
       by (simp add: b1)
     have f0: "v \<in> basis"
       if "r v \<noteq> 0" for v
-      using complex_vector.representation_ne_zero r_def that by auto       
+      using complex_vector.representation_ne_zero r_def that by auto
     have w:"{a|a. r a \<noteq> 0} \<subseteq> basis"
       using f0 by blast
     hence f1: "finite {a|a. r a \<noteq> 0}"
-      using b3 rev_finite_subset by auto 
+      using b3 rev_finite_subset by auto
     have f2: "(\<Sum>a| r a \<noteq> 0. r a *\<^sub>C a) = x"
       unfolding r_def
       using b2 complex_vector.sum_nonzero_representation_eq x_span
         Collect_cong  by fastforce
     have g1: "(\<Sum>a\<in>basis. crepresentation basis x a *\<^sub>C a) = x"
       by (simp add: b2 b3 complex_vector.sum_representation_eq x_span)
     have f3: "(\<Sum>a\<in>basis. r a *\<^sub>C a) = x"
       unfolding r_def
-      by (simp add: g1) 
+      by (simp add: g1)
     hence "f x = f (\<Sum>a\<in>basis. r a *\<^sub>C a)"
       by simp
     also have "\<dots> = (\<Sum>a\<in>basis. r a *\<^sub>C f a)"
       by (smt (verit, ccfv_SIG) assms complex_vector.linear_scale complex_vector.linear_sum sum.cong)
     finally have "f x = (\<Sum>a\<in>basis. r a *\<^sub>C f a)".
     hence "\<parallel>f x\<parallel> = \<parallel>(\<Sum>a\<in>basis. r a *\<^sub>C f a)\<parallel>"
       by simp
     also have "\<dots> \<le> (\<Sum>a\<in>basis. \<parallel>r a *\<^sub>C f a\<parallel>)"
       by (simp add: sum_norm_le)
     also have "\<dots> \<le> (\<Sum>a\<in>basis. \<parallel>r a\<parallel> * \<parallel>f a\<parallel>)"
       by simp
-    also have "\<dots> \<le> (\<Sum>a\<in>basis. \<parallel>x\<parallel> * C * \<parallel>f a\<parallel>)"      
+    also have "\<dots> \<le> (\<Sum>a\<in>basis. \<parallel>x\<parallel> * C * \<parallel>f a\<parallel>)"
       using sum_mono s1 unfolding r_def
       by (simp add: sum_mono mult_right_mono)
     also have "\<dots> \<le> \<parallel>x\<parallel> * C * (\<Sum>a\<in>basis. \<parallel>f a\<parallel>)"
       using sum_distrib_left
       by (smt sum.cong)
     also have "\<dots> = \<parallel>x\<parallel> * M"
       unfolding M_def
-      by linarith 
+      by linarith
     finally show ?thesis .
   qed
   thus ?thesis
     using assms bounded_clinear_def bounded_clinear_axioms_def by blast
 qed
 
 subsection \<open>Closed subspaces\<close>
 
 lemma csubspace_INF[simp]: "(\<And>x. x \<in> A \<Longrightarrow> csubspace x) \<Longrightarrow> csubspace (\<Inter>A)"
   by (simp add: complex_vector.subspace_Inter)
 
 locale closed_csubspace =
   fixes A::"('a::{complex_vector,topological_space}) set"
   assumes subspace: "csubspace A"
   assumes closed: "closed A"
 
 declare closed_csubspace.subspace[simp]
 
 lemma closure_is_csubspace[simp]:
   fixes A::"('a::complex_normed_vector) set"
   assumes \<open>csubspace A\<close>
   shows \<open>csubspace (closure A)\<close>
 proof-
   have "x \<in> closure A \<Longrightarrow> y \<in> closure A \<Longrightarrow> x+y \<in> closure A" for x y
   proof-
     assume \<open>x\<in>(closure A)\<close>
     then obtain xx where \<open>\<forall> n::nat. xx n \<in> A\<close> and \<open>xx \<longlonglongrightarrow> x\<close>
       using closure_sequential by blast
     assume \<open>y\<in>(closure A)\<close>
     then obtain yy where \<open>\<forall> n::nat. yy n \<in> A\<close> and \<open>yy \<longlonglongrightarrow> y\<close>
       using closure_sequential by blast
-    have \<open>\<forall> n::nat. (xx n) + (yy n) \<in> A\<close> 
+    have \<open>\<forall> n::nat. (xx n) + (yy n) \<in> A\<close>
       using \<open>\<forall>n. xx n \<in> A\<close> \<open>\<forall>n. yy n \<in> A\<close> assms complex_vector.subspace_def
-      by (simp add: complex_vector.subspace_def)      
-    hence  \<open>(\<lambda> n. (xx n) + (yy n)) \<longlonglongrightarrow> x + y\<close> using  \<open>xx \<longlonglongrightarrow> x\<close> \<open>yy \<longlonglongrightarrow> y\<close> 
+      by (simp add: complex_vector.subspace_def)
+    hence  \<open>(\<lambda> n. (xx n) + (yy n)) \<longlonglongrightarrow> x + y\<close> using  \<open>xx \<longlonglongrightarrow> x\<close> \<open>yy \<longlonglongrightarrow> y\<close>
       by (simp add: tendsto_add)
     thus ?thesis using  \<open>\<forall> n::nat. (xx n) + (yy n) \<in> A\<close>
       by (meson closure_sequential)
   qed
   moreover have "x\<in>(closure A) \<Longrightarrow> c *\<^sub>C x \<in> (closure A)" for x c
   proof-
     assume \<open>x\<in>(closure A)\<close>
     then obtain xx where \<open>\<forall> n::nat. xx n \<in> A\<close> and \<open>xx \<longlonglongrightarrow> x\<close>
       using closure_sequential by blast
-    have \<open>\<forall> n::nat. c *\<^sub>C (xx n) \<in> A\<close> 
+    have \<open>\<forall> n::nat. c *\<^sub>C (xx n) \<in> A\<close>
       using \<open>\<forall>n. xx n \<in> A\<close> assms complex_vector.subspace_def
       by (simp add: complex_vector.subspace_def)
-    have \<open>isCont (\<lambda> t. c *\<^sub>C t) x\<close> 
+    have \<open>isCont (\<lambda> t. c *\<^sub>C t) x\<close>
       using bounded_clinear.bounded_linear bounded_clinear_scaleC_right linear_continuous_at by auto
     hence  \<open>(\<lambda> n. c *\<^sub>C (xx n)) \<longlonglongrightarrow> c *\<^sub>C x\<close> using  \<open>xx \<longlonglongrightarrow> x\<close>
       by (simp add: isCont_tendsto_compose)
-    thus ?thesis using  \<open>\<forall> n::nat. c *\<^sub>C (xx n) \<in> A\<close> 
+    thus ?thesis using  \<open>\<forall> n::nat. c *\<^sub>C (xx n) \<in> A\<close>
       by (meson closure_sequential)
   qed
   moreover have "0 \<in> (closure A)"
     using assms closure_subset complex_vector.subspace_def
-    by (metis in_mono)    
+    by (metis in_mono)
   ultimately show ?thesis
-    by (simp add: complex_vector.subspaceI) 
+    by (simp add: complex_vector.subspaceI)
 qed
 
 lemma csubspace_set_plus:
   assumes \<open>csubspace A\<close> and \<open>csubspace B\<close>
   shows \<open>csubspace (A + B)\<close>
 proof -
   define C where \<open>C = {\<psi>+\<phi>| \<psi> \<phi>. \<psi>\<in>A \<and> \<phi>\<in>B}\<close>
   have  "x\<in>C \<Longrightarrow> y\<in>C \<Longrightarrow> x+y\<in>C" for x y
     using C_def assms(1) assms(2) complex_vector.subspace_add complex_vector.subspace_sums by blast
   moreover have "c *\<^sub>C x \<in> C" if \<open>x\<in>C\<close> for x c
   proof -
     have "csubspace C"
       by (simp add: C_def assms(1) assms(2) complex_vector.subspace_sums)
     then show ?thesis
       using that by (simp add: complex_vector.subspace_def)
   qed
   moreover have  "0 \<in> C"
     using  \<open>C = {\<psi> + \<phi> |\<psi> \<phi>. \<psi> \<in> A \<and> \<phi> \<in> B}\<close> add.inverse_neutral add_uminus_conv_diff assms(1) assms(2) diff_0  mem_Collect_eq
       add.right_inverse
     by (metis (mono_tags, lifting) complex_vector.subspace_0)
   ultimately show ?thesis
     unfolding C_def complex_vector.subspace_def
-    by (smt mem_Collect_eq set_plus_elim set_plus_intro)    
+    by (smt mem_Collect_eq set_plus_elim set_plus_intro)
 qed
 
 lemma closed_csubspace_0[simp]:
   "closed_csubspace ({0} :: ('a::{complex_vector,t1_space}) set)"
 proof-
   have \<open>csubspace {0}\<close>
     using add.right_neutral complex_vector.subspace_def scaleC_right.zero
-    by blast    
+    by blast
   moreover have "closed ({0} :: 'a set)"
-    by simp 
-  ultimately show ?thesis 
+    by simp
+  ultimately show ?thesis
     by (simp add: closed_csubspace_def)
 qed
 
 lemma closed_csubspace_UNIV[simp]: "closed_csubspace (UNIV::('a::{complex_vector,topological_space}) set)"
 proof-
   have \<open>csubspace UNIV\<close>
-    by simp  
+    by simp
   moreover have \<open>closed UNIV\<close>
     by simp
-  ultimately show ?thesis 
+  ultimately show ?thesis
     unfolding closed_csubspace_def by auto
 qed
 
 lemma closed_csubspace_inter[simp]:
   assumes "closed_csubspace A" and "closed_csubspace B"
   shows "closed_csubspace (A\<inter>B)"
 proof-
   obtain C where \<open>C = A \<inter> B\<close> by blast
   have \<open>csubspace C\<close>
   proof-
     have "x\<in>C \<Longrightarrow> y\<in>C \<Longrightarrow> x+y\<in>C" for x y
       by (metis IntD1 IntD2 IntI \<open>C = A \<inter> B\<close> assms(1) assms(2) complex_vector.subspace_def closed_csubspace_def)
     moreover have "x\<in>C \<Longrightarrow> c *\<^sub>C x \<in> C" for x c
       by (metis IntD1 IntD2 IntI \<open>C = A \<inter> B\<close> assms(1) assms(2) complex_vector.subspace_def closed_csubspace_def)
-    moreover have "0 \<in> C" 
+    moreover have "0 \<in> C"
       using  \<open>C = A \<inter> B\<close> assms(1) assms(2) complex_vector.subspace_def closed_csubspace_def by fastforce
-    ultimately show ?thesis 
+    ultimately show ?thesis
       by (simp add: complex_vector.subspace_def)
   qed
   moreover have \<open>closed C\<close>
     using  \<open>C = A \<inter> B\<close>
     by (simp add: assms(1) assms(2) closed_Int closed_csubspace.closed)
   ultimately show ?thesis
     using  \<open>C = A \<inter> B\<close>
     by (simp add: closed_csubspace_def)
 qed
 
 
 lemma closed_csubspace_INF[simp]:
   assumes a1: "\<forall>A\<in>\<A>. closed_csubspace A"
   shows "closed_csubspace (\<Inter>\<A>)"
 proof-
   have \<open>csubspace (\<Inter>\<A>)\<close>
     by (simp add: assms closed_csubspace.subspace complex_vector.subspace_Inter)
   moreover have \<open>closed (\<Inter>\<A>)\<close>
     by (simp add: assms closed_Inter closed_csubspace.closed)
-  ultimately show ?thesis 
+  ultimately show ?thesis
     by (simp add: closed_csubspace.intro)
 qed
 
 
-typedef (overloaded) ('a::"{complex_vector,topological_space}") 
+typedef (overloaded) ('a::"{complex_vector,topological_space}")
   ccsubspace = \<open>{S::'a set. closed_csubspace S}\<close>
   morphisms space_as_set Abs_clinear_space
   using Complex_Vector_Spaces.closed_csubspace_UNIV by blast
 
 setup_lifting type_definition_ccsubspace
 
 lemma csubspace_space_as_set[simp]: \<open>csubspace (space_as_set S)\<close>
   by (metis closed_csubspace_def mem_Collect_eq space_as_set)
 
 instantiation ccsubspace :: (complex_normed_vector) scaleC begin
 lift_definition scaleC_ccsubspace :: "complex \<Rightarrow> 'a ccsubspace \<Rightarrow> 'a ccsubspace" is
   "\<lambda>c S. (*\<^sub>C) c ` S"
 proof
   show "csubspace ((*\<^sub>C) c ` S)"
     if "closed_csubspace S"
     for c :: complex
       and S :: "'a set"
     using that
-    by (simp add: closed_csubspace.subspace complex_vector.linear_subspace_image) 
+    by (simp add: closed_csubspace.subspace complex_vector.linear_subspace_image)
   show "closed ((*\<^sub>C) c ` S)"
     if "closed_csubspace S"
     for c :: complex
       and S :: "'a set"
     using that
-    by (simp add: closed_scaleC closed_csubspace.closed) 
+    by (simp add: closed_scaleC closed_csubspace.closed)
 qed
 
 lift_definition scaleR_ccsubspace :: "real \<Rightarrow> 'a ccsubspace \<Rightarrow> 'a ccsubspace" is
   "\<lambda>c S. (*\<^sub>R) c ` S"
 proof
   show "csubspace ((*\<^sub>R) r ` S)"
     if "closed_csubspace S"
     for r :: real
       and S :: "'a set"
     using that   using bounded_clinear_def bounded_clinear_scaleC_right scaleR_scaleC
     by (simp add: scaleR_scaleC closed_csubspace.subspace complex_vector.linear_subspace_image)
   show "closed ((*\<^sub>R) r ` S)"
     if "closed_csubspace S"
     for r :: real
       and S :: "'a set"
-    using that 
+    using that
     by (simp add: closed_scaling closed_csubspace.closed)
 qed
 
-instance 
+instance
 proof
   show "((*\<^sub>R) r::'a ccsubspace \<Rightarrow> _) = (*\<^sub>C) (complex_of_real r)" for r :: real
-    by (simp add: scaleR_scaleC scaleC_ccsubspace_def scaleR_ccsubspace_def)    
+    by (simp add: scaleR_scaleC scaleC_ccsubspace_def scaleR_ccsubspace_def)
 qed
 end
 
 instantiation ccsubspace :: ("{complex_vector,t1_space}") bot begin
 lift_definition bot_ccsubspace :: \<open>'a ccsubspace\<close> is \<open>{0}\<close>
   by simp
 instance..
 end
 
 lemma zero_cblinfun_image[simp]: "0 *\<^sub>C S = bot" for S :: "_ ccsubspace"
 proof transfer
   have "(0::'b) \<in> (\<lambda>x. 0) ` S"
     if "closed_csubspace S"
     for S::"'b set"
     using that unfolding closed_csubspace_def
-    by (simp add: complex_vector.linear_subspace_image complex_vector.module_hom_zero 
+    by (simp add: complex_vector.linear_subspace_image complex_vector.module_hom_zero
         complex_vector.subspace_0)
   thus "(*\<^sub>C) 0 ` S = {0::'b}"
     if "closed_csubspace (S::'b set)"
     for S :: "'b set"
-    using that 
+    using that
     by (auto intro !: exI [of _ 0])
 qed
 
-lemma csubspace_scaleC_invariant: 
+lemma csubspace_scaleC_invariant:
   fixes a S
   assumes \<open>a \<noteq> 0\<close> and \<open>csubspace S\<close>
   shows \<open>(*\<^sub>C) a ` S = S\<close>
 proof-
   have  \<open>x \<in> (*\<^sub>C) a ` S \<Longrightarrow> x \<in> S\<close>
     for x
-    using assms(2) complex_vector.subspace_scale by blast 
+    using assms(2) complex_vector.subspace_scale by blast
   moreover have  \<open>x \<in> S \<Longrightarrow> x \<in> (*\<^sub>C) a ` S\<close>
     for x
   proof -
     assume "x \<in> S"
     hence "\<exists>c aa. (c / a) *\<^sub>C aa \<in> S \<and> c *\<^sub>C aa = x"
       using assms(2) complex_vector.subspace_def scaleC_one by metis
     hence "\<exists>aa. aa \<in> S \<and> a *\<^sub>C aa = x"
       using assms(1) by auto
     thus ?thesis
       by (meson image_iff)
-  qed 
+  qed
   ultimately show ?thesis by blast
 qed
 
 
 lemma ccsubspace_scaleC_invariant[simp]: "a \<noteq> 0 \<Longrightarrow> a *\<^sub>C S = S" for S :: "_ ccsubspace"
   apply transfer
   by (simp add: closed_csubspace.subspace csubspace_scaleC_invariant)
 
 
 instantiation ccsubspace :: ("{complex_vector,topological_space}") "top"
 begin
 lift_definition top_ccsubspace :: \<open>'a ccsubspace\<close> is \<open>UNIV\<close>
   by simp
 
 instance ..
 end
 
-lemma ccsubspace_top_not_bot[simp]: 
+lemma ccsubspace_top_not_bot[simp]:
   "(top::'a::{complex_vector,t1_space,not_singleton} ccsubspace) \<noteq> bot"
   (* The type class t1_space is needed because the definition of bot in ccsubspace needs it *)
   by (metis UNIV_not_singleton bot_ccsubspace.rep_eq top_ccsubspace.rep_eq)
 
 lemma ccsubspace_bot_not_top[simp]:
   "(bot::'a::{complex_vector,t1_space,not_singleton} ccsubspace) \<noteq> top"
   using ccsubspace_top_not_bot by metis
 
 instantiation ccsubspace :: ("{complex_vector,topological_space}") "Inf"
 begin
 lift_definition Inf_ccsubspace::\<open>'a ccsubspace set \<Rightarrow> 'a ccsubspace\<close>
   is \<open>\<lambda> S. \<Inter> S\<close>
 proof
   fix S :: "'a set set"
   assume closed: "closed_csubspace x" if \<open>x \<in> S\<close> for x
   show "csubspace (\<Inter> S::'a set)"
-    by (simp add: closed closed_csubspace.subspace) 
+    by (simp add: closed closed_csubspace.subspace)
   show "closed (\<Inter> S::'a set)"
-    by (simp add: closed closed_csubspace.closed) 
+    by (simp add: closed closed_csubspace.closed)
 qed
 
 instance ..
 end
 
 lift_definition ccspan :: "'a::complex_normed_vector set \<Rightarrow> 'a ccsubspace"
   is "\<lambda>G. closure (cspan G)"
 proof (rule closed_csubspace.intro)
   fix S :: "'a set"
   show "csubspace (closure (cspan S))"
-    by (simp add: closure_is_csubspace)    
+    by (simp add: closure_is_csubspace)
   show "closed (closure (cspan S))"
     by simp
 qed
 
 lemma ccspan_canonical_basis[simp]: "ccspan (set canonical_basis) = top"
   using ccspan.rep_eq space_as_set_inject top_ccsubspace.rep_eq
     closure_UNIV is_generator_set
   by metis
 
 lemma ccspan_Inf_def: \<open>ccspan A = Inf {S. A \<subseteq> space_as_set S}\<close>
   for A::\<open>('a::cbanach) set\<close>
 proof-
-  have \<open>x \<in> space_as_set (ccspan A) 
+  have \<open>x \<in> space_as_set (ccspan A)
     \<Longrightarrow> x \<in> space_as_set (Inf {S. A \<subseteq> space_as_set S})\<close>
     for x::'a
   proof-
     assume \<open>x \<in> space_as_set (ccspan A)\<close>
     hence "x \<in> closure (cspan A)"
       by (simp add: ccspan.rep_eq)
     hence \<open>x \<in> closure (complex_vector.span A)\<close>
       unfolding ccspan_def
       by simp
     hence \<open>\<exists> y::nat \<Rightarrow> 'a. (\<forall> n. y n \<in> (complex_vector.span A)) \<and> y \<longlonglongrightarrow> x\<close>
       by (simp add: closure_sequential)
     then obtain y where \<open>\<forall> n. y n \<in> (complex_vector.span A)\<close> and \<open>y \<longlonglongrightarrow> x\<close>
       by blast
     have \<open>y n \<in> \<Inter> {S. (complex_vector.span A) \<subseteq> S \<and> closed_csubspace S}\<close>
       for n
       using  \<open>\<forall> n. y n \<in> (complex_vector.span A)\<close>
       by auto
 
     have \<open>closed_csubspace S \<Longrightarrow> closed S\<close>
       for S::\<open>'a set\<close>
       by (simp add: closed_csubspace.closed)
     hence \<open>closed ( \<Inter> {S. (complex_vector.span A) \<subseteq> S \<and> closed_csubspace S})\<close>
       by simp
     hence \<open>x \<in> \<Inter> {S. (complex_vector.span A) \<subseteq> S \<and> closed_csubspace S}\<close> using \<open>y \<longlonglongrightarrow> x\<close>
-      using \<open>\<And>n. y n \<in> \<Inter> {S. complex_vector.span A \<subseteq> S \<and> closed_csubspace S}\<close> closed_sequentially 
+      using \<open>\<And>n. y n \<in> \<Inter> {S. complex_vector.span A \<subseteq> S \<and> closed_csubspace S}\<close> closed_sequentially
       by blast
     moreover have \<open>{S. A \<subseteq> S \<and> closed_csubspace S} \<subseteq> {S. (complex_vector.span A) \<subseteq> S \<and> closed_csubspace S}\<close>
       using Collect_mono_iff
       by (simp add: Collect_mono_iff closed_csubspace.subspace complex_vector.span_minimal)
     ultimately have \<open>x \<in> \<Inter> {S. A \<subseteq> S \<and> closed_csubspace S}\<close>
-      by blast     
+      by blast
     moreover have "(x::'a) \<in> \<Inter> {x. A \<subseteq> x \<and> closed_csubspace x}"
       if "(x::'a) \<in> \<Inter> {S. A \<subseteq> S \<and> closed_csubspace S}"
       for x :: 'a
         and A :: "'a set"
       using that
       by simp
-    ultimately show \<open>x \<in> space_as_set (Inf {S. A \<subseteq> space_as_set S})\<close> 
+    ultimately show \<open>x \<in> space_as_set (Inf {S. A \<subseteq> space_as_set S})\<close>
       apply transfer.
   qed
   moreover have \<open>x \<in> space_as_set (Inf {S. A \<subseteq> space_as_set S})
              \<Longrightarrow> x \<in> space_as_set (ccspan A)\<close>
     for x::'a
   proof-
     assume \<open>x \<in> space_as_set (Inf {S. A \<subseteq> space_as_set S})\<close>
     hence \<open>x \<in> \<Inter> {S. A \<subseteq> S \<and> closed_csubspace S}\<close>
       apply transfer
       by blast
     moreover have \<open>{S. (complex_vector.span A) \<subseteq> S \<and> closed_csubspace S} \<subseteq> {S. A \<subseteq> S \<and> closed_csubspace S}\<close>
       using Collect_mono_iff complex_vector.span_superset by fastforce
     ultimately have \<open>x \<in> \<Inter> {S. (complex_vector.span A) \<subseteq> S \<and> closed_csubspace S}\<close>
-      by blast 
+      by blast
     thus \<open>x \<in> space_as_set (ccspan A)\<close>
-      by (metis (no_types, lifting) Inter_iff space_as_set closure_subset mem_Collect_eq ccspan.rep_eq)      
+      by (metis (no_types, lifting) Inter_iff space_as_set closure_subset mem_Collect_eq ccspan.rep_eq)
   qed
   ultimately have \<open>space_as_set (ccspan A) = space_as_set (Inf {S. A \<subseteq> space_as_set S})\<close>
     by blast
   thus ?thesis
-    using space_as_set_inject by auto 
+    using space_as_set_inject by auto
 qed
 
 lemma cspan_singleton_scaleC[simp]: "(a::complex)\<noteq>0 \<Longrightarrow> cspan { a *\<^sub>C \<psi> } = cspan {\<psi>}"
   for \<psi>::"'a::complex_vector"
-  by (smt complex_vector.dependent_single complex_vector.independent_insert 
-      complex_vector.scale_eq_0_iff complex_vector.span_base complex_vector.span_redundant 
-      complex_vector.span_scale doubleton_eq_iff insert_absorb insert_absorb2 insert_commute 
+  by (smt complex_vector.dependent_single complex_vector.independent_insert
+      complex_vector.scale_eq_0_iff complex_vector.span_base complex_vector.span_redundant
+      complex_vector.span_scale doubleton_eq_iff insert_absorb insert_absorb2 insert_commute
       singletonI)
 
 lemma closure_is_closed_csubspace[simp]:
   fixes S::\<open>'a::complex_normed_vector set\<close>
   assumes \<open>csubspace S\<close>
   shows \<open>closed_csubspace (closure S)\<close>
 proof-
   fix x y :: 'a and c :: complex
   have "x + y \<in> closure S"
     if "x \<in> closure S"
       and "y \<in> closure S"
   proof-
     have \<open>\<exists> r. (\<forall> n::nat. r n \<in> S) \<and> r \<longlonglongrightarrow> x\<close>
       using closure_sequential that(1) by auto
     then obtain r where \<open>\<forall> n::nat. r n \<in> S\<close> and \<open>r \<longlonglongrightarrow> x\<close>
       by blast
     have \<open>\<exists> s. (\<forall> n::nat. s n \<in> S) \<and> s \<longlonglongrightarrow> y\<close>
       using closure_sequential that(2) by auto
     then obtain s where \<open>\<forall> n::nat. s n \<in> S\<close> and \<open>s \<longlonglongrightarrow> y\<close>
       by blast
     have \<open>\<forall> n::nat. r n + s n \<in> S\<close>
-      using \<open>\<forall>n. r n \<in> S\<close> \<open>\<forall>n. s n \<in> S\<close> assms complex_vector.subspace_add by blast 
+      using \<open>\<forall>n. r n \<in> S\<close> \<open>\<forall>n. s n \<in> S\<close> assms complex_vector.subspace_add by blast
     moreover have \<open>(\<lambda> n. r n + s n) \<longlonglongrightarrow> x + y\<close>
       by (simp add: \<open>r \<longlonglongrightarrow> x\<close> \<open>s \<longlonglongrightarrow> y\<close> tendsto_add)
     ultimately show ?thesis
       using assms that(1) that(2)
-      by (simp add: complex_vector.subspace_add) 
+      by (simp add: complex_vector.subspace_add)
   qed
   moreover have "c *\<^sub>C x \<in> closure S"
     if "x \<in> closure S"
   proof-
     have \<open>\<exists> y. (\<forall> n::nat. y n \<in> S) \<and> y \<longlonglongrightarrow> x\<close>
       using Elementary_Topology.closure_sequential that by auto
     then obtain y where \<open>\<forall> n::nat. y n \<in> S\<close> and \<open>y \<longlonglongrightarrow> x\<close>
       by blast
     have \<open>isCont (scaleC c) x\<close>
       by simp
     hence \<open>(\<lambda> n. scaleC c (y n)) \<longlonglongrightarrow> scaleC c x\<close>
       using  \<open>y \<longlonglongrightarrow> x\<close>
-      by (simp add: isCont_tendsto_compose) 
+      by (simp add: isCont_tendsto_compose)
     from  \<open>\<forall> n::nat. y n \<in> S\<close>
     have  \<open>\<forall> n::nat. scaleC c (y n) \<in> S\<close>
       using assms complex_vector.subspace_scale by auto
     thus ?thesis
       using assms that
-      by (simp add: complex_vector.subspace_scale) 
+      by (simp add: complex_vector.subspace_scale)
   qed
   moreover have "0 \<in> closure S"
     by (simp add: assms complex_vector.subspace_0)
   moreover have "closed (closure S)"
     by auto
   ultimately show ?thesis
     by (simp add: assms closed_csubspace_def)
 qed
 
 lemma ccspan_singleton_scaleC[simp]: "(a::complex)\<noteq>0 \<Longrightarrow> ccspan {a *\<^sub>C \<psi>} = ccspan {\<psi>}"
   apply transfer by simp
 
 lemma clinear_continuous_at:
-  assumes \<open>bounded_clinear f\<close> 
+  assumes \<open>bounded_clinear f\<close>
   shows \<open>isCont f x\<close>
   by (simp add: assms bounded_clinear.bounded_linear linear_continuous_at)
 
 lemma clinear_continuous_within:
-  assumes \<open>bounded_clinear f\<close> 
+  assumes \<open>bounded_clinear f\<close>
   shows \<open>continuous (at x within s) f\<close>
   by (simp add: assms bounded_clinear.bounded_linear linear_continuous_within)
 
 lemma antilinear_continuous_at:
-  assumes \<open>bounded_antilinear f\<close> 
+  assumes \<open>bounded_antilinear f\<close>
   shows \<open>isCont f x\<close>
   by (simp add: assms bounded_antilinear.bounded_linear linear_continuous_at)
 
 lemma antilinear_continuous_within:
-  assumes \<open>bounded_antilinear f\<close> 
+  assumes \<open>bounded_antilinear f\<close>
   shows \<open>continuous (at x within s) f\<close>
   by (simp add: assms bounded_antilinear.bounded_linear linear_continuous_within)
 
 lemma bounded_clinear_eq_on:
   fixes A B :: "'a::complex_normed_vector \<Rightarrow> 'b::complex_normed_vector"
   assumes \<open>bounded_clinear A\<close> and \<open>bounded_clinear B\<close> and
     eq: \<open>\<And>x. x \<in> G \<Longrightarrow> A x = B x\<close> and t: \<open>t \<in> closure (cspan G)\<close>
   shows \<open>A t = B t\<close>
 proof -
   have eq': \<open>A t = B t\<close> if \<open>t \<in> cspan G\<close> for t
     using _ _ that eq apply (rule complex_vector.linear_eq_on)
     by (auto simp: assms bounded_clinear.clinear)
   have \<open>A t - B t = 0\<close>
     using _ _ t apply (rule continuous_constant_on_closure)
     by (auto simp add: eq' assms(1) assms(2) clinear_continuous_at continuous_at_imp_continuous_on)
   then show ?thesis
     by auto
 qed
 
 instantiation ccsubspace :: ("{complex_vector,topological_space}") "order"
 begin
 lift_definition less_eq_ccsubspace :: \<open>'a ccsubspace \<Rightarrow> 'a ccsubspace \<Rightarrow> bool\<close>
   is  \<open>(\<subseteq>)\<close>.
 declare less_eq_ccsubspace_def[code del]
 lift_definition less_ccsubspace :: \<open>'a ccsubspace \<Rightarrow> 'a ccsubspace \<Rightarrow> bool\<close>
   is \<open>(\<subset>)\<close>.
 declare less_ccsubspace_def[code del]
 instance
 proof
   fix x y z :: "'a ccsubspace"
   show "(x < y) = (x \<le> y \<and> \<not> y \<le> x)"
-    by (simp add: less_eq_ccsubspace.rep_eq less_le_not_le less_ccsubspace.rep_eq)    
+    by (simp add: less_eq_ccsubspace.rep_eq less_le_not_le less_ccsubspace.rep_eq)
   show "x \<le> x"
-    by (simp add: less_eq_ccsubspace.rep_eq)    
+    by (simp add: less_eq_ccsubspace.rep_eq)
   show "x \<le> z" if "x \<le> y" and "y \<le> z"
-    using that less_eq_ccsubspace.rep_eq by auto 
+    using that less_eq_ccsubspace.rep_eq by auto
   show "x = y" if "x \<le> y" and "y \<le> x"
-    using that by (simp add: space_as_set_inject less_eq_ccsubspace.rep_eq) 
+    using that by (simp add: space_as_set_inject less_eq_ccsubspace.rep_eq)
 qed
 end
 
 lemma ccspan_leqI:
   assumes \<open>M \<subseteq> space_as_set S\<close>
   shows \<open>ccspan M \<le> S\<close>
   using assms apply transfer
   by (simp add: closed_csubspace.closed closure_minimal complex_vector.span_minimal)
 
 lemma ccspan_mono:
   assumes \<open>A \<subseteq> B\<close>
   shows \<open>ccspan A \<le> ccspan B\<close>
   apply (transfer fixing: A B)
   by (simp add: assms closure_mono complex_vector.span_mono)
 
 lemma bounded_sesquilinear_add:
   \<open>bounded_sesquilinear (\<lambda> x y. A x y + B x y)\<close> if \<open>bounded_sesquilinear A\<close> and \<open>bounded_sesquilinear B\<close>
 proof
   fix a a' :: 'a and b b' :: 'b and r :: complex
   show "A (a + a') b + B (a + a') b = (A a b + B a b) + (A a' b + B a' b)"
     by (simp add: bounded_sesquilinear.add_left that(1) that(2))
   show \<open>A a (b + b') + B a (b + b') = (A a b + B a b) + (A a b' + B a b')\<close>
     by (simp add: bounded_sesquilinear.add_right that(1) that(2))
   show \<open>A (r *\<^sub>C a) b + B (r *\<^sub>C a) b = cnj r *\<^sub>C (A a b + B a b)\<close>
     by (simp add: bounded_sesquilinear.scaleC_left scaleC_add_right that(1) that(2))
   show \<open>A a (r *\<^sub>C b) + B a (r *\<^sub>C b) = r *\<^sub>C (A a b + B a b)\<close>
     by (simp add: bounded_sesquilinear.scaleC_right scaleC_add_right that(1) that(2))
   show \<open>\<exists>K. \<forall>a b. norm (A a b + B a b) \<le> norm a * norm b * K\<close>
   proof-
     have \<open>\<exists> KA. \<forall> a b. norm (A a b) \<le> norm a * norm b * KA\<close>
       by (simp add: bounded_sesquilinear.bounded that(1))
     then obtain KA where \<open>\<forall> a b. norm (A a b) \<le> norm a * norm b * KA\<close>
       by blast
     have \<open>\<exists> KB. \<forall> a b. norm (B a b) \<le> norm a * norm b * KB\<close>
       by (simp add: bounded_sesquilinear.bounded that(2))
     then obtain KB where \<open>\<forall> a b. norm (B a b) \<le> norm a * norm b * KB\<close>
       by blast
     have \<open>norm (A a b + B a b) \<le> norm a * norm b * (KA + KB)\<close>
       for a b
     proof-
       have \<open>norm (A a b + B a b) \<le> norm (A a b) +  norm (B a b)\<close>
         using norm_triangle_ineq by blast
       also have \<open>\<dots> \<le> norm a * norm b * KA + norm a * norm b * KB\<close>
         using  \<open>\<forall> a b. norm (A a b) \<le> norm a * norm b * KA\<close>
           \<open>\<forall> a b. norm (B a b) \<le> norm a * norm b * KB\<close>
         using add_mono by blast
       also have \<open>\<dots>=  norm a * norm b * (KA + KB)\<close>
         by (simp add: mult.commute ring_class.ring_distribs(2))
-      finally show ?thesis 
+      finally show ?thesis
         by blast
     qed
     thus ?thesis by blast
   qed
 qed
 
 lemma bounded_sesquilinear_uminus:
   \<open>bounded_sesquilinear (\<lambda> x y. - A x y)\<close> if \<open>bounded_sesquilinear A\<close>
 proof
   fix a a' :: 'a and b b' :: 'b and r :: complex
   show "- A (a + a') b = (- A a b) + (- A a' b)"
     by (simp add: bounded_sesquilinear.add_left that)
   show \<open>- A a (b + b') = (- A a b) + (- A a b')\<close>
     by (simp add: bounded_sesquilinear.add_right that)
   show \<open>- A (r *\<^sub>C a) b = cnj r *\<^sub>C (- A a b)\<close>
     by (simp add: bounded_sesquilinear.scaleC_left that)
   show \<open>- A a (r *\<^sub>C b) = r *\<^sub>C (- A a b)\<close>
     by (simp add: bounded_sesquilinear.scaleC_right that)
   show \<open>\<exists>K. \<forall>a b. norm (- A a b) \<le> norm a * norm b * K\<close>
   proof-
     have \<open>\<exists> KA. \<forall> a b. norm (A a b) \<le> norm a * norm b * KA\<close>
       by (simp add: bounded_sesquilinear.bounded that(1))
     then obtain KA where \<open>\<forall> a b. norm (A a b) \<le> norm a * norm b * KA\<close>
       by blast
     have \<open>norm (- A a b) \<le> norm a * norm b * KA\<close>
       for a b
       by (simp add: \<open>\<forall>a b. norm (A a b) \<le> norm a * norm b * KA\<close>)
     thus ?thesis by blast
   qed
 qed
 
 lemma bounded_sesquilinear_diff:
   \<open>bounded_sesquilinear (\<lambda> x y. A x y - B x y)\<close> if \<open>bounded_sesquilinear A\<close> and \<open>bounded_sesquilinear B\<close>
 proof -
   have \<open>bounded_sesquilinear (\<lambda> x y. - B x y)\<close>
     using that(2) by (rule bounded_sesquilinear_uminus)
   then have \<open>bounded_sesquilinear (\<lambda> x y. A x y + (- B x y))\<close>
     using that(1) by (rule bounded_sesquilinear_add[rotated])
   then show ?thesis
     by auto
 qed
 
 lemma ccsubspace_leI:
   assumes t1: "space_as_set A \<subseteq> space_as_set B"
   shows "A \<le> B"
   using t1 apply transfer by -
 
 lemma ccspan_of_empty[simp]: "ccspan {} = bot"
 proof transfer
   show "closure (cspan {}) = {0::'a}"
     by simp
 qed
 
 
-instantiation ccsubspace :: ("{complex_vector,topological_space}") inf begin 
-lift_definition inf_ccsubspace :: "'a ccsubspace \<Rightarrow> 'a ccsubspace \<Rightarrow> 'a ccsubspace" 
+instantiation ccsubspace :: ("{complex_vector,topological_space}") inf begin
+lift_definition inf_ccsubspace :: "'a ccsubspace \<Rightarrow> 'a ccsubspace \<Rightarrow> 'a ccsubspace"
   is "(\<inter>)" by simp
 instance .. end
 
 lemma space_as_set_inf[simp]: "space_as_set (A \<sqinter> B) = space_as_set A \<inter> space_as_set B"
   by (rule inf_ccsubspace.rep_eq)
 
 instantiation ccsubspace :: ("{complex_vector,topological_space}") order_top begin
-instance 
+instance
 proof
   show "a \<le> \<top>"
     for a :: "'a ccsubspace"
     apply transfer
     by simp
 qed
 end
 
 
 instantiation ccsubspace :: ("{complex_vector,t1_space}") order_bot begin
-instance 
+instance
 proof
   show "(\<bottom>::'a ccsubspace) \<le> a"
     for a :: "'a ccsubspace"
     apply transfer
     apply auto
     using closed_csubspace.subspace complex_vector.subspace_0 by blast
 qed
 end
 
 
 instantiation ccsubspace :: ("{complex_vector,topological_space}") semilattice_inf begin
-instance 
+instance
 proof
   fix x y z :: \<open>'a ccsubspace\<close>
   show "x \<sqinter> y \<le> x"
     apply transfer by simp
   show "x \<sqinter> y \<le> y"
     apply transfer by simp
   show "x \<le> y \<sqinter> z" if "x \<le> y" and "x \<le> z"
     using that apply transfer by simp
-qed  
+qed
 end
 
 
 instantiation ccsubspace :: ("{complex_vector,t1_space}") zero begin
 definition zero_ccsubspace :: "'a ccsubspace" where [simp]: "zero_ccsubspace = bot"
 lemma zero_ccsubspace_transfer[transfer_rule]: \<open>pcr_ccsubspace (=) {0} 0\<close>
   unfolding zero_ccsubspace_def by transfer_prover
 instance ..
 end
 
 
 subsection \<open>Closed sums\<close>
 
 definition closed_sum:: \<open>'a::{semigroup_add,topological_space} set \<Rightarrow> 'a set \<Rightarrow> 'a set\<close> where
   \<open>closed_sum A B = closure (A + B)\<close>
 
 notation closed_sum (infixl "+\<^sub>M" 65)
 
 lemma closed_sum_comm: \<open>A +\<^sub>M B = B +\<^sub>M A\<close> for A B :: "_::ab_semigroup_add"
   by (simp add: add.commute closed_sum_def)
 
 lemma closed_sum_left_subset: \<open>0 \<in> B \<Longrightarrow> A \<subseteq> A +\<^sub>M B\<close> for A B :: "_::monoid_add"
   by (metis add.right_neutral closed_sum_def closure_subset in_mono set_plus_intro subsetI)
 
 lemma closed_sum_right_subset: \<open>0 \<in> A \<Longrightarrow> B \<subseteq> A +\<^sub>M B\<close> for A B :: "_::monoid_add"
   by (metis add.left_neutral closed_sum_def closure_subset set_plus_intro subset_iff)
 
 lemma finite_cspan_closed_csubspace:
   assumes "finite (S::'a::complex_normed_vector set)"
   shows "closed_csubspace (cspan S)"
   by (simp add: assms closed_csubspace.intro)
 
 lemma closed_sum_is_sup:
   fixes A B C:: \<open>('a::{complex_vector,topological_space}) set\<close>
   assumes \<open>closed_csubspace C\<close>
   assumes \<open>A \<subseteq> C\<close> and \<open>B \<subseteq> C\<close>
   shows \<open>(A +\<^sub>M B) \<subseteq> C\<close>
 proof -
   have \<open>A + B \<subseteq> C\<close>
     using assms unfolding set_plus_def
     using closed_csubspace.subspace complex_vector.subspace_add by blast
   then show \<open>(A +\<^sub>M B) \<subseteq> C\<close>
     unfolding closed_sum_def
     using \<open>closed_csubspace C\<close>
     by (simp add: closed_csubspace.closed closure_minimal)
 qed
 
 lemma closed_subspace_closed_sum:
   fixes A B::"('a::complex_normed_vector) set"
   assumes a1: \<open>csubspace A\<close> and a2: \<open>csubspace B\<close>
   shows \<open>closed_csubspace (A +\<^sub>M B)\<close>
-  using a1 a2 closed_sum_def 
+  using a1 a2 closed_sum_def
   by (metis closure_is_closed_csubspace csubspace_set_plus)
 
 
 lemma closed_sum_assoc:
   fixes A B C::"'a::real_normed_vector set"
   shows \<open>A +\<^sub>M (B +\<^sub>M C) = (A +\<^sub>M B) +\<^sub>M C\<close>
 proof -
   have \<open>A + closure B \<subseteq> closure (A + B)\<close> for A B :: "'a set"
     by (meson closure_subset closure_sum dual_order.trans order_refl set_plus_mono2)
   then have \<open>A +\<^sub>M (B +\<^sub>M C) = closure (A + (B + C))\<close>
     unfolding closed_sum_def
     by (meson antisym_conv closed_closure closure_minimal closure_mono closure_subset equalityD1 set_plus_mono2)
-  moreover 
+  moreover
   have \<open>closure A + B \<subseteq> closure (A + B)\<close> for A B :: "'a set"
     by (meson closure_subset closure_sum dual_order.trans order_refl set_plus_mono2)
   then have \<open>(A +\<^sub>M B) +\<^sub>M C = closure ((A + B) + C)\<close>
     unfolding closed_sum_def
     by (meson closed_closure closure_minimal closure_mono closure_subset eq_iff set_plus_mono2)
   ultimately show ?thesis
     by (simp add: ab_semigroup_add_class.add_ac(1))
 qed
 
 
 lemma closed_sum_zero_left[simp]:
   fixes A :: \<open>('a::{monoid_add, topological_space}) set\<close>
   shows \<open>{0} +\<^sub>M A = closure A\<close>
   unfolding closed_sum_def
   by (metis add.left_neutral set_zero)
 
 lemma closed_sum_zero_right[simp]:
   fixes A :: \<open>('a::{monoid_add, topological_space}) set\<close>
   shows \<open>A +\<^sub>M {0} = closure A\<close>
   unfolding closed_sum_def
   by (metis add.right_neutral set_zero)
 
 lemma closed_sum_closure_right[simp]:
   fixes A B :: \<open>'a::real_normed_vector set\<close>
   shows \<open>A +\<^sub>M closure B = A +\<^sub>M B\<close>
   by (metis closed_sum_assoc closed_sum_def closed_sum_zero_right closure_closure)
 
 lemma closed_sum_closure_left[simp]:
   fixes A B :: \<open>'a::real_normed_vector set\<close>
   shows \<open>closure A +\<^sub>M B = A +\<^sub>M B\<close>
   by (simp add: closed_sum_comm)
 
 lemma closed_sum_mono_left:
   assumes \<open>A \<subseteq> B\<close>
   shows \<open>A +\<^sub>M C \<subseteq> B +\<^sub>M C\<close>
   by (simp add: assms closed_sum_def closure_mono set_plus_mono2)
 
 lemma closed_sum_mono_right:
   assumes \<open>A \<subseteq> B\<close>
   shows \<open>C +\<^sub>M A \<subseteq> C +\<^sub>M B\<close>
   by (simp add: assms closed_sum_def closure_mono set_plus_mono2)
 
 instantiation ccsubspace :: (complex_normed_vector) sup begin
-lift_definition sup_ccsubspace :: "'a ccsubspace \<Rightarrow> 'a ccsubspace \<Rightarrow> 'a ccsubspace" 
+lift_definition sup_ccsubspace :: "'a ccsubspace \<Rightarrow> 'a ccsubspace \<Rightarrow> 'a ccsubspace"
   \<comment> \<open>Note that \<^term>\<open>A+B\<close> would not be a closed subspace, we need the closure. See, e.g., \<^url>\<open>https://math.stackexchange.com/a/1786792/403528\<close>.\<close>
   is "\<lambda>A B::'a set. A +\<^sub>M B"
-  by (simp add: closed_subspace_closed_sum) 
-instance .. 
+  by (simp add: closed_subspace_closed_sum)
+instance ..
 end
 
 lemma closed_sum_cspan[simp]:
   shows \<open>cspan X +\<^sub>M cspan Y = closure (cspan (X \<union> Y))\<close>
   by (smt (verit, best) Collect_cong closed_sum_def complex_vector.span_Un set_plus_def)
 
-lemma closure_image_closed_sum: 
+lemma closure_image_closed_sum:
   assumes \<open>bounded_linear U\<close>
   shows \<open>closure (U ` (A +\<^sub>M B)) = closure (U ` A) +\<^sub>M closure (U ` B)\<close>
 proof -
   have \<open>closure (U ` (A +\<^sub>M B)) = closure (U ` closure (closure A + closure B))\<close>
     unfolding closed_sum_def
     by (smt (verit, best) closed_closure closure_minimal closure_mono closure_subset closure_sum set_plus_mono2 subset_antisym)
   also have \<open>\<dots> = closure (U ` (closure A + closure B))\<close>
     using assms closure_bounded_linear_image_subset_eq by blast
   also have \<open>\<dots> = closure (U ` closure A + U ` closure B)\<close>
     apply (subst image_set_plus)
     by (simp_all add: assms bounded_linear.linear)
   also have \<open>\<dots> = closure (closure (U ` A) + closure (U ` B))\<close>
     by (smt (verit, ccfv_SIG) assms closed_closure closure_bounded_linear_image_subset closure_bounded_linear_image_subset_eq closure_minimal closure_mono closure_sum dual_order.eq_iff set_plus_mono2)
   also have \<open>\<dots> = closure (U ` A) +\<^sub>M closure (U ` B)\<close>
     using closed_sum_def by blast
   finally show ?thesis
     by -
 qed
 
 
 
 lemma ccspan_union: "ccspan A \<squnion> ccspan B = ccspan (A \<union> B)"
   apply transfer by simp
 
 instantiation ccsubspace :: (complex_normed_vector) "Sup"
 begin
 lift_definition Sup_ccsubspace::\<open>'a ccsubspace set \<Rightarrow> 'a ccsubspace\<close>
   is \<open>\<lambda>S. closure (complex_vector.span (Union S))\<close>
 proof
   show "csubspace (closure (complex_vector.span (\<Union> S::'a set)))"
     if "\<And>x::'a set. x \<in> S \<Longrightarrow> closed_csubspace x"
     for S :: "'a set set"
     using that
-    by (simp add: closure_is_closed_csubspace) 
+    by (simp add: closure_is_closed_csubspace)
   show "closed (closure (complex_vector.span (\<Union> S::'a set)))"
     if "\<And>x. (x::'a set) \<in> S \<Longrightarrow> closed_csubspace x"
     for S :: "'a set set"
     using that
-    by simp 
+    by simp
 qed
 
 instance..
 end
 
 
 instance ccsubspace :: ("{complex_normed_vector}") semilattice_sup
 proof
   fix x y z :: \<open>'a ccsubspace\<close>
   show \<open>x \<le> sup x y\<close>
     apply transfer
     by (simp add: closed_csubspace_def closed_sum_left_subset complex_vector.subspace_0)
 
   show "y \<le> sup x y"
     apply transfer
     by (simp add: closed_csubspace_def closed_sum_right_subset complex_vector.subspace_0)
 
   show "sup x y \<le> z" if "x \<le> z" and "y \<le> z"
     using that apply transfer
     apply (rule closed_sum_is_sup) by auto
 qed
 
 instance ccsubspace :: ("{complex_normed_vector}") complete_lattice
 proof
   show "Inf A \<le> x"
     if "x \<in> A"
     for x :: "'a ccsubspace"
       and A :: "'a ccsubspace set"
-    using that 
+    using that
     apply transfer
     by auto
 
   have b1: "z \<subseteq> \<Inter> A"
     if "Ball A closed_csubspace" and
       "closed_csubspace z" and
       "(\<And>x. closed_csubspace x \<Longrightarrow> x \<in> A \<Longrightarrow> z \<subseteq> x)"
     for z::"'a set" and A
     using that
-    by auto 
+    by auto
   show "z \<le> Inf A"
     if "\<And>x::'a ccsubspace. x \<in> A \<Longrightarrow> z \<le> x"
     for A :: "'a ccsubspace set"
       and z :: "'a ccsubspace"
-    using that 
+    using that
     apply transfer
     using b1 by blast
 
   show "x \<le> Sup A"
     if "x \<in> A"
     for x :: "'a ccsubspace"
       and A :: "'a ccsubspace set"
-    using that 
+    using that
     apply transfer
-    by (meson Union_upper closure_subset complex_vector.span_superset dual_order.trans)  
+    by (meson Union_upper closure_subset complex_vector.span_superset dual_order.trans)
 
   show "Sup A \<le> z"
     if "\<And>x::'a ccsubspace. x \<in> A \<Longrightarrow> x \<le> z"
     for A :: "'a ccsubspace set"
       and z :: "'a ccsubspace"
     using that apply transfer
   proof -
     fix A :: "'a set set" and z :: "'a set"
     assume A_closed: "Ball A closed_csubspace"
     assume "closed_csubspace z"
     assume in_z: "\<And>x. closed_csubspace x \<Longrightarrow> x \<in> A \<Longrightarrow> x \<subseteq> z"
     from A_closed in_z
     have \<open>V \<subseteq> z\<close> if \<open>V \<in> A\<close> for V
       by (simp add: that)
     then have \<open>\<Union> A \<subseteq> z\<close>
       by (simp add: Sup_le_iff)
     with \<open>closed_csubspace z\<close>
     show "closure (cspan (\<Union> A)) \<subseteq> z"
       by (simp add: closed_csubspace_def closure_minimal complex_vector.span_def subset_hull)
   qed
 
   show "Inf {} = (top::'a ccsubspace)"
     using \<open>\<And>z A. (\<And>x. x \<in> A \<Longrightarrow> z \<le> x) \<Longrightarrow> z \<le> Inf A\<close> top.extremum_uniqueI by auto
 
   show "Sup {} = (bot::'a ccsubspace)"
-    using \<open>\<And>z A. (\<And>x. x \<in> A \<Longrightarrow> x \<le> z) \<Longrightarrow> Sup A \<le> z\<close> bot.extremum_uniqueI by auto 
+    using \<open>\<And>z A. (\<And>x. x \<in> A \<Longrightarrow> x \<le> z) \<Longrightarrow> Sup A \<le> z\<close> bot.extremum_uniqueI by auto
 qed
 
 instantiation ccsubspace :: (complex_normed_vector) comm_monoid_add begin
 definition plus_ccsubspace :: "'a ccsubspace \<Rightarrow> _ \<Rightarrow> _"
   where [simp]: "plus_ccsubspace = sup"
-instance 
+instance
 proof
   fix a b c :: \<open>'a ccsubspace\<close>
   show "a + b + c = a + (b + c)"
-    using sup.assoc by auto    
+    using sup.assoc by auto
   show "a + b = b + a"
-    by (simp add: sup.commute)    
+    by (simp add: sup.commute)
   show "0 + a = a"
     by (simp add: zero_ccsubspace_def)
 qed
 end
 
-lemma ccsubspace_plus_sup: "y \<le> x \<Longrightarrow> z \<le> x \<Longrightarrow> y + z \<le> x" 
+lemma ccsubspace_plus_sup: "y \<le> x \<Longrightarrow> z \<le> x \<Longrightarrow> y + z \<le> x"
   for x y z :: "'a::complex_normed_vector ccsubspace"
   unfolding plus_ccsubspace_def by auto
 
 lemma ccsubspace_Sup_empty: "Sup {} = (0::_ ccsubspace)"
   unfolding zero_ccsubspace_def by auto
 
 lemma ccsubspace_add_right_incr[simp]: "a \<le> a + c" for a::"_ ccsubspace"
   by (simp add: add_increasing2)
 
 lemma ccsubspace_add_left_incr[simp]: "a \<le> c + a" for a::"_ ccsubspace"
   by (simp add: add_increasing)
 
 subsection \<open>Conjugate space\<close>
 
 typedef 'a conjugate_space = "UNIV :: 'a set"
   morphisms from_conjugate_space to_conjugate_space ..
 setup_lifting type_definition_conjugate_space
 
 instantiation conjugate_space :: (complex_vector) complex_vector begin
 lift_definition scaleC_conjugate_space :: \<open>complex \<Rightarrow> 'a conjugate_space \<Rightarrow> 'a conjugate_space\<close> is \<open>\<lambda>c x. cnj c *\<^sub>C x\<close>.
 lift_definition scaleR_conjugate_space :: \<open>real \<Rightarrow> 'a conjugate_space \<Rightarrow> 'a conjugate_space\<close> is \<open>\<lambda>r x. r *\<^sub>R x\<close>.
 lift_definition plus_conjugate_space :: "'a conjugate_space \<Rightarrow> 'a conjugate_space \<Rightarrow> 'a conjugate_space" is "(+)".
 lift_definition uminus_conjugate_space :: "'a conjugate_space \<Rightarrow> 'a conjugate_space" is \<open>\<lambda>x. -x\<close>.
 lift_definition zero_conjugate_space :: "'a conjugate_space" is 0.
 lift_definition minus_conjugate_space :: "'a conjugate_space \<Rightarrow> 'a conjugate_space \<Rightarrow> 'a conjugate_space" is "(-)".
 instance
   apply (intro_classes; transfer)
   by (simp_all add: scaleR_scaleC scaleC_add_right scaleC_left.add)
 end
 
 instantiation conjugate_space :: (complex_normed_vector) complex_normed_vector begin
 lift_definition sgn_conjugate_space :: "'a conjugate_space \<Rightarrow> 'a conjugate_space" is "sgn".
 lift_definition norm_conjugate_space :: "'a conjugate_space \<Rightarrow> real" is norm.
 lift_definition dist_conjugate_space :: "'a conjugate_space \<Rightarrow> 'a conjugate_space \<Rightarrow> real" is dist.
 lift_definition uniformity_conjugate_space :: "('a conjugate_space \<times> 'a conjugate_space) filter" is uniformity.
 lift_definition  open_conjugate_space :: "'a conjugate_space set \<Rightarrow> bool" is "open".
-instance 
+instance
   apply (intro_classes; transfer)
   by (simp_all add: dist_norm sgn_div_norm open_uniformity uniformity_dist norm_triangle_ineq)
 end
 
 instantiation conjugate_space :: (cbanach) cbanach begin
-instance 
+instance
   apply intro_classes
   unfolding Cauchy_def convergent_def LIMSEQ_def apply transfer
   using Cauchy_convergent unfolding Cauchy_def convergent_def LIMSEQ_def by metis
 end
 
 lemma bounded_antilinear_to_conjugate_space[simp]: \<open>bounded_antilinear to_conjugate_space\<close>
   by (rule bounded_antilinear_intro[where K=1]; transfer; auto)
 
 lemma bounded_antilinear_from_conjugate_space[simp]: \<open>bounded_antilinear from_conjugate_space\<close>
   by (rule bounded_antilinear_intro[where K=1]; transfer; auto)
 
 lemma antilinear_to_conjugate_space[simp]: \<open>antilinear to_conjugate_space\<close>
   by (rule antilinearI; transfer, auto)
 
 lemma antilinear_from_conjugate_space[simp]: \<open>antilinear from_conjugate_space\<close>
   by (rule antilinearI; transfer, auto)
 
 lemma cspan_to_conjugate_space[simp]: "cspan (to_conjugate_space ` X) = to_conjugate_space ` cspan X"
   unfolding complex_vector.span_def complex_vector.subspace_def hull_def
   apply transfer
   apply simp
-  by (metis (no_types, hide_lams) complex_cnj_cnj)
+  by (metis (no_types, opaque_lifting) complex_cnj_cnj)
 
 lemma surj_to_conjugate_space[simp]: "surj to_conjugate_space"
   by (meson surj_def to_conjugate_space_cases)
 
 lemmas has_derivative_scaleC[simp, derivative_intros] =
   bounded_bilinear.FDERIV[OF bounded_cbilinear_scaleC[THEN bounded_cbilinear.bounded_bilinear]]
 
 lemma norm_to_conjugate_space[simp]: \<open>norm (to_conjugate_space x) = norm x\<close>
   by (fact norm_conjugate_space.abs_eq)
 
 lemma norm_from_conjugate_space[simp]: \<open>norm (from_conjugate_space x) = norm x\<close>
   by (simp add: norm_conjugate_space.rep_eq)
 
 lemma closure_to_conjugate_space: \<open>closure (to_conjugate_space ` X) = to_conjugate_space ` closure X\<close>
 proof -
   have 1: \<open>to_conjugate_space ` closure X \<subseteq> closure (to_conjugate_space ` X)\<close>
     apply (rule closure_bounded_linear_image_subset)
     by (simp add: bounded_antilinear.bounded_linear)
   have \<open>\<dots> = to_conjugate_space ` from_conjugate_space ` closure (to_conjugate_space ` X)\<close>
     by (simp add: from_conjugate_space_inverse image_image)
   also have \<open>\<dots> \<subseteq> to_conjugate_space ` closure (from_conjugate_space ` to_conjugate_space ` X)\<close>
     apply (rule image_mono)
     apply (rule closure_bounded_linear_image_subset)
     by (simp add: bounded_antilinear.bounded_linear)
   also have \<open>\<dots> = to_conjugate_space ` closure X\<close>
     by (simp add: to_conjugate_space_inverse image_image)
   finally show ?thesis
     using 1 by simp
 qed
 
 lemma closure_from_conjugate_space: \<open>closure (from_conjugate_space ` X) = from_conjugate_space ` closure X\<close>
 proof -
   have 1: \<open>from_conjugate_space ` closure X \<subseteq> closure (from_conjugate_space ` X)\<close>
     apply (rule closure_bounded_linear_image_subset)
     by (simp add: bounded_antilinear.bounded_linear)
   have \<open>\<dots> = from_conjugate_space ` to_conjugate_space ` closure (from_conjugate_space ` X)\<close>
     by (simp add: to_conjugate_space_inverse image_image)
   also have \<open>\<dots> \<subseteq> from_conjugate_space ` closure (to_conjugate_space ` from_conjugate_space ` X)\<close>
     apply (rule image_mono)
     apply (rule closure_bounded_linear_image_subset)
     by (simp add: bounded_antilinear.bounded_linear)
   also have \<open>\<dots> = from_conjugate_space ` closure X\<close>
     by (simp add: from_conjugate_space_inverse image_image)
   finally show ?thesis
     using 1 by simp
 qed
 
 lemma bounded_antilinear_eq_on:
   fixes A B :: "'a::complex_normed_vector \<Rightarrow> 'b::complex_normed_vector"
   assumes \<open>bounded_antilinear A\<close> and \<open>bounded_antilinear B\<close> and
     eq: \<open>\<And>x. x \<in> G \<Longrightarrow> A x = B x\<close> and t: \<open>t \<in> closure (cspan G)\<close>
   shows \<open>A t = B t\<close>
 proof -
   let ?A = \<open>\<lambda>x. A (from_conjugate_space x)\<close> and ?B = \<open>\<lambda>x. B (from_conjugate_space x)\<close>
     and ?G = \<open>to_conjugate_space ` G\<close> and ?t = \<open>to_conjugate_space t\<close>
   have \<open>bounded_clinear ?A\<close> and \<open>bounded_clinear ?B\<close>
     by (auto intro!: bounded_antilinear_o_bounded_antilinear[OF \<open>bounded_antilinear A\<close>]
         bounded_antilinear_o_bounded_antilinear[OF \<open>bounded_antilinear B\<close>])
   moreover from eq have \<open>\<And>x. x \<in> ?G \<Longrightarrow> ?A x = ?B x\<close>
     by (metis image_iff iso_tuple_UNIV_I to_conjugate_space_inverse)
   moreover from t have \<open>?t \<in> closure (cspan ?G)\<close>
     by (metis bounded_antilinear.bounded_linear bounded_antilinear_to_conjugate_space closure_bounded_linear_image_subset cspan_to_conjugate_space imageI subsetD)
   ultimately have \<open>?A ?t = ?B ?t\<close>
     by (rule bounded_clinear_eq_on)
   then show \<open>A t = B t\<close>
     by (simp add: to_conjugate_space_inverse)
 qed
 
 instantiation complex :: basis_enum begin
 definition "canonical_basis = [1::complex]"
 instance
 proof
   show "distinct (canonical_basis::complex list)"
-    by (simp add: canonical_basis_complex_def)    
+    by (simp add: canonical_basis_complex_def)
   show "cindependent (set (canonical_basis::complex list))"
     unfolding canonical_basis_complex_def
     by auto
   show "cspan (set (canonical_basis::complex list)) = UNIV"
-    unfolding canonical_basis_complex_def 
+    unfolding canonical_basis_complex_def
     apply (auto simp add: cspan_raw_def vector_space_over_itself.span_Basis)
     by (metis complex_scaleC_def complex_vector.span_base complex_vector.span_scale cspan_raw_def insertI1 mult.right_neutral)
 qed
 end
 
 lemma csubspace_is_convex[simp]:
   assumes a1: "csubspace M"
   shows "convex M"
 proof-
   have \<open>\<forall>x\<in>M. \<forall>y\<in> M. \<forall>u. \<forall>v. u *\<^sub>C x + v *\<^sub>C y \<in>  M\<close>
     using a1
     by (simp add:  complex_vector.subspace_def)
   hence \<open>\<forall>x\<in>M. \<forall>y\<in>M. \<forall>u::real. \<forall>v::real. u *\<^sub>R x + v *\<^sub>R y \<in> M\<close>
     by (simp add: scaleR_scaleC)
   hence \<open>\<forall>x\<in>M. \<forall>y\<in>M. \<forall>u\<ge>0. \<forall>v\<ge>0. u + v = 1 \<longrightarrow> u *\<^sub>R x + v *\<^sub>R y \<in>M\<close>
     by blast
   thus ?thesis using convex_def by blast
 qed
 
 lemma kernel_is_csubspace[simp]:
   assumes a1: "clinear f"
   shows "csubspace  (f -` {0})"
 proof-
-  have w3: \<open>t *\<^sub>C x \<in> {x. f x = 0}\<close> 
+  have w3: \<open>t *\<^sub>C x \<in> {x. f x = 0}\<close>
     if b1: "x \<in> {x. f x = 0}"
     for x t
     by (metis assms complex_vector.linear_subspace_kernel complex_vector.subspace_def that)
   have \<open>f 0 = 0\<close>
     by (simp add: assms complex_vector.linear_0)
   hence s2: \<open>0 \<in> {x. f x = 0}\<close>
     by blast
 
   have w4: "x + y \<in> {x. f x = 0}"
     if c1: "x \<in> {x. f x = 0}" and c2: "y \<in> {x. f x = 0}"
     for x y
     using assms c1 c2 complex_vector.linear_add by fastforce
-  have s4: \<open>c *\<^sub>C t \<in> {x. f x = 0}\<close> 
+  have s4: \<open>c *\<^sub>C t \<in> {x. f x = 0}\<close>
     if "t \<in> {x. f x = 0}"
     for t c
     using that w3 by auto
   have s5: "u + v \<in> {x. f x = 0}"
     if "u \<in> {x. f x = 0}" and "v \<in> {x. f x = 0}"
     for u v
-    using w4 that(1) that(2) by auto    
+    using w4 that(1) that(2) by auto
   have f3: "f -` {b. b = 0 \<or> b \<in> {}} = {a. f a = 0}"
     by blast
   have "csubspace {a. f a = 0}"
     by (metis complex_vector.subspace_def s2 s4 s5)
   thus ?thesis
     using f3 by auto
 qed
 
 
 lemma kernel_is_closed_csubspace[simp]:
   assumes a1: "bounded_clinear f"
   shows "closed_csubspace (f -` {0})"
 proof-
   have \<open>csubspace (f -` {0})\<close>
     using assms bounded_clinear.clinear complex_vector.linear_subspace_vimage complex_vector.subspace_single_0 by blast
   have "L \<in> {x. f x = 0}"
     if "r \<longlonglongrightarrow> L" and "\<forall> n. r n \<in> {x. f x = 0}"
-    for r and  L 
+    for r and  L
   proof-
     have d1: \<open>\<forall> n. f (r n) = 0\<close>
       using that(2) by auto
     have \<open>(\<lambda> n. f (r n)) \<longlonglongrightarrow> f L\<close>
-      using assms clinear_continuous_at continuous_within_tendsto_compose' that(1) 
+      using assms clinear_continuous_at continuous_within_tendsto_compose' that(1)
       by fastforce
     hence \<open>(\<lambda> n. 0) \<longlonglongrightarrow> f L\<close>
-      using d1 by simp        
+      using d1 by simp
     hence \<open>f L = 0\<close>
       using limI by fastforce
     thus ?thesis by blast
   qed
   then have s3: \<open>closed (f -` {0})\<close>
     using closed_sequential_limits by force
   with \<open>csubspace (f -` {0})\<close>
   show ?thesis
     using closed_csubspace.intro by blast
 qed
 
 lemma range_is_clinear[simp]:
   assumes a1: "clinear f"
   shows "csubspace (range f)"
   using assms complex_vector.linear_subspace_image complex_vector.subspace_UNIV by blast
 
 lemma ccspan_superset:
-  \<open>A \<subseteq> space_as_set (ccspan A)\<close> 
+  \<open>A \<subseteq> space_as_set (ccspan A)\<close>
   for A :: \<open>'a::complex_normed_vector set\<close>
   apply transfer
   by (meson closure_subset complex_vector.span_superset subset_trans)
 
 
 subsection \<open>Product is a Complex Vector Space\<close>
 
 (* Follows closely Product_Vector.thy *)
 
 instantiation prod :: (complex_vector, complex_vector) complex_vector
 begin
 
 definition scaleC_prod_def:
   "scaleC r A = (scaleC r (fst A), scaleC r (snd A))"
 
 lemma fst_scaleC [simp]: "fst (scaleC r A) = scaleC r (fst A)"
   unfolding scaleC_prod_def by simp
 
 lemma snd_scaleC [simp]: "snd (scaleC r A) = scaleC r (snd A)"
   unfolding scaleC_prod_def by simp
 
 proposition scaleC_Pair [simp]: "scaleC r (a, b) = (scaleC r a, scaleC r b)"
   unfolding scaleC_prod_def by simp
 
 instance
 proof
   fix a b :: complex and x y :: "'a \<times> 'b"
   show "scaleC a (x + y) = scaleC a x + scaleC a y"
     by (simp add: scaleC_add_right scaleC_prod_def)
   show "scaleC (a + b) x = scaleC a x + scaleC b x"
     by (simp add: Complex_Vector_Spaces.scaleC_prod_def scaleC_left.add)
   show "scaleC a (scaleC b x) = scaleC (a * b) x"
     by (simp add: prod_eq_iff)
   show "scaleC 1 x = x"
     by (simp add: prod_eq_iff)
   show \<open>(scaleR :: _ \<Rightarrow> _ \<Rightarrow> 'a*'b) r = (*\<^sub>C) (complex_of_real r)\<close> for r
     by (auto intro!: ext simp: scaleR_scaleC scaleC_prod_def scaleR_prod_def)
 qed
 
 end
 
 lemma module_prod_scale_eq_scaleC: "module_prod.scale (*\<^sub>C) (*\<^sub>C) = scaleC"
   apply (rule ext) apply (rule ext)
   apply (subst module_prod.scale_def)
   subgoal by unfold_locales
   by (simp add: scaleC_prod_def)
 
 interpretation complex_vector?: vector_space_prod "scaleC::_\<Rightarrow>_\<Rightarrow>'a::complex_vector" "scaleC::_\<Rightarrow>_\<Rightarrow>'b::complex_vector"
   rewrites "scale = ((*\<^sub>C)::_\<Rightarrow>_\<Rightarrow>('a \<times> 'b))"
     and "module.dependent (*\<^sub>C) = cdependent"
     and "module.representation (*\<^sub>C) = crepresentation"
     and "module.subspace (*\<^sub>C) = csubspace"
     and "module.span (*\<^sub>C) = cspan"
     and "vector_space.extend_basis (*\<^sub>C) = cextend_basis"
     and "vector_space.dim (*\<^sub>C) = cdim"
     and "Vector_Spaces.linear (*\<^sub>C) (*\<^sub>C) = clinear"
   subgoal by unfold_locales
   subgoal by (fact module_prod_scale_eq_scaleC)
   unfolding cdependent_raw_def crepresentation_raw_def csubspace_raw_def cspan_raw_def
     cextend_basis_raw_def cdim_raw_def clinear_def
   by (rule refl)+
 
 
 subsection \<open>Copying existing theorems into sublocales\<close>
 
 context bounded_clinear begin
 interpretation bounded_linear f by (rule bounded_linear)
 lemmas continuous = continuous
 lemmas uniform_limit = uniform_limit
 lemmas Cauchy = Cauchy
 end
 
 context bounded_antilinear begin
 interpretation bounded_linear f by (rule bounded_linear)
 lemmas continuous = continuous
 lemmas uniform_limit = uniform_limit
 end
 
 
 context bounded_cbilinear begin
 interpretation bounded_bilinear prod by simp
 lemmas tendsto = tendsto
 lemmas isCont = isCont
 end
 
 context bounded_sesquilinear begin
 interpretation bounded_bilinear prod by simp
 lemmas tendsto = tendsto
 lemmas isCont = isCont
 end
 
 lemmas tendsto_scaleC [tendsto_intros] =
   bounded_cbilinear.tendsto [OF bounded_cbilinear_scaleC]
 
 end
diff --git a/thys/Complex_Bounded_Operators/Complex_Vector_Spaces0.thy b/thys/Complex_Bounded_Operators/Complex_Vector_Spaces0.thy
--- a/thys/Complex_Bounded_Operators/Complex_Vector_Spaces0.thy
+++ b/thys/Complex_Bounded_Operators/Complex_Vector_Spaces0.thy
@@ -1,1573 +1,1573 @@
 (*  Based on HOL/Real_Vector_Spaces.thy by Brian Huffman, Johannes Hölzl
     Adapted to the complex case by Dominique Unruh *)
 
 section \<open>\<open>Complex_Vector_Spaces0\<close> -- Vector Spaces and Algebras over the Complex Numbers\<close>
 
 theory Complex_Vector_Spaces0
   imports HOL.Real_Vector_Spaces HOL.Topological_Spaces HOL.Vector_Spaces
     Complex_Main Jordan_Normal_Form.Conjugate
-begin                                   
+begin
 
 (* Jordan_Normal_Form.Conjugate declares these as simps. Seems too aggressive to me. *)
 declare less_complex_def[simp del]
 declare less_eq_complex_def[simp del]
 
 subsection \<open>Complex vector spaces\<close>
 
 class scaleC = scaleR +
   fixes scaleC :: "complex \<Rightarrow> 'a \<Rightarrow> 'a" (infixr "*\<^sub>C" 75)
   assumes scaleR_scaleC: "scaleR r = scaleC (complex_of_real r)"
 begin
 
 abbreviation divideC :: "'a \<Rightarrow> complex \<Rightarrow> 'a"  (infixl "'/\<^sub>C" 70)
   where "x /\<^sub>C c \<equiv> inverse c *\<^sub>C x"
 
 end
 
 class complex_vector = scaleC + ab_group_add +
   assumes scaleC_add_right: "a *\<^sub>C (x + y) = (a *\<^sub>C x) + (a *\<^sub>C y)"
     and scaleC_add_left: "(a + b) *\<^sub>C x = (a *\<^sub>C x) + (b *\<^sub>C x)"
     and scaleC_scaleC[simp]: "a *\<^sub>C (b *\<^sub>C x) =  (a * b) *\<^sub>C x"
     and scaleC_one[simp]: "1 *\<^sub>C x = x"
 
 (* Not present in Real_Vector_Spaces *)
 subclass (in complex_vector) real_vector
   by (standard, simp_all add: scaleR_scaleC scaleC_add_right scaleC_add_left)
 
 class complex_algebra = complex_vector + ring +
   assumes mult_scaleC_left [simp]: "a *\<^sub>C x * y = a *\<^sub>C (x * y)"
     and mult_scaleC_right [simp]: "x * a *\<^sub>C y = a *\<^sub>C (x * y)"
 
 (* Not present in Real_Vector_Spaces *)
 subclass (in complex_algebra) real_algebra
   by (standard, simp_all add: scaleR_scaleC)
 
 class complex_algebra_1 = complex_algebra + ring_1
 
 (* Not present in Real_Vector_Spaces *)
 subclass (in complex_algebra_1) real_algebra_1 ..
 
 class complex_div_algebra = complex_algebra_1 + division_ring
 
 (* Not present in Real_Vector_Spaces *)
 subclass (in complex_div_algebra) real_div_algebra ..
 
 class complex_field = complex_div_algebra + field
 
 (* Not present in Real_Vector_Spaces *)
 subclass (in complex_field) real_field ..
 
 instantiation complex :: complex_field
 begin
 
 definition complex_scaleC_def [simp]: "scaleC a x = a * x"
 
 instance
 proof intro_classes
   fix r :: real and a b x y :: complex
   show "((*\<^sub>R) r::complex \<Rightarrow> _) = (*\<^sub>C) (complex_of_real r)"
     by (auto simp add: scaleR_conv_of_real)
   show "a *\<^sub>C (x + y) = a *\<^sub>C x + a *\<^sub>C y"
     by (simp add: ring_class.ring_distribs(1))
   show "(a + b) *\<^sub>C x = a *\<^sub>C x + b *\<^sub>C x"
     by (simp add: algebra_simps)
   show "a *\<^sub>C b *\<^sub>C x = (a * b) *\<^sub>C x"
     by simp
   show "1 *\<^sub>C x = x"
     by simp
   show "a *\<^sub>C (x::complex) * y = a *\<^sub>C (x * y)"
     by simp
   show "(x::complex) * a *\<^sub>C y = a *\<^sub>C (x * y)"
     by simp
 qed
 
 end
 
 locale clinear = Vector_Spaces.linear "scaleC::_\<Rightarrow>_\<Rightarrow>'a::complex_vector" "scaleC::_\<Rightarrow>_\<Rightarrow>'b::complex_vector"
 begin
 
 lemmas scaleC = scale
 
 end
 
 global_interpretation complex_vector: vector_space "scaleC :: complex \<Rightarrow> 'a \<Rightarrow> 'a :: complex_vector"
   rewrites "Vector_Spaces.linear (*\<^sub>C) (*\<^sub>C) = clinear"
     and "Vector_Spaces.linear (*) (*\<^sub>C) = clinear"
   defines cdependent_raw_def: cdependent = complex_vector.dependent
     and crepresentation_raw_def: crepresentation = complex_vector.representation
     and csubspace_raw_def: csubspace = complex_vector.subspace
     and cspan_raw_def: cspan = complex_vector.span
     and cextend_basis_raw_def: cextend_basis = complex_vector.extend_basis
     and cdim_raw_def: cdim = complex_vector.dim
 proof unfold_locales
   show "Vector_Spaces.linear (*\<^sub>C) (*\<^sub>C) = clinear" "Vector_Spaces.linear (*) (*\<^sub>C) = clinear"
     by (force simp: clinear_def complex_scaleC_def[abs_def])+
 qed (use scaleC_add_right scaleC_add_left in auto)
 
 
 (* Not needed since we did the global_interpretation with mandatory complex_vector-prefix:
 hide_const (open)\<comment> \<open>locale constants\<close>
   complex_vector.dependent
   complex_vector.independent
   complex_vector.representation
   complex_vector.subspace
   complex_vector.span
   complex_vector.extend_basis
   complex_vector.dim *)
 
 abbreviation "cindependent x \<equiv> \<not> cdependent x"
 
 global_interpretation complex_vector: vector_space_pair "scaleC::_\<Rightarrow>_\<Rightarrow>'a::complex_vector" "scaleC::_\<Rightarrow>_\<Rightarrow>'b::complex_vector"
   rewrites  "Vector_Spaces.linear (*\<^sub>C) (*\<^sub>C) = clinear"
     and "Vector_Spaces.linear (*) (*\<^sub>C) = clinear"
   defines cconstruct_raw_def: cconstruct = complex_vector.construct
 proof unfold_locales
   show "Vector_Spaces.linear (*) (*\<^sub>C) = clinear"
     unfolding clinear_def complex_scaleC_def by auto
 qed (auto simp: clinear_def)
 
 (* Not needed since we did the global_interpretation with mandatory complex_vector-prefix:
 hide_const (open)\<comment> \<open>locale constants\<close>
   complex_vector.construct *)
 
 lemma clinear_compose: "clinear f \<Longrightarrow> clinear g \<Longrightarrow> clinear (g \<circ> f)"
   unfolding clinear_def by (rule Vector_Spaces.linear_compose)
 
 text \<open>Recover original theorem names\<close>
 
 lemmas scaleC_left_commute = complex_vector.scale_left_commute
 lemmas scaleC_zero_left = complex_vector.scale_zero_left
 lemmas scaleC_minus_left = complex_vector.scale_minus_left
 lemmas scaleC_diff_left = complex_vector.scale_left_diff_distrib
 lemmas scaleC_sum_left = complex_vector.scale_sum_left
 lemmas scaleC_zero_right = complex_vector.scale_zero_right
 lemmas scaleC_minus_right = complex_vector.scale_minus_right
 lemmas scaleC_diff_right = complex_vector.scale_right_diff_distrib
 lemmas scaleC_sum_right = complex_vector.scale_sum_right
 lemmas scaleC_eq_0_iff = complex_vector.scale_eq_0_iff
 lemmas scaleC_left_imp_eq = complex_vector.scale_left_imp_eq
 lemmas scaleC_right_imp_eq = complex_vector.scale_right_imp_eq
 lemmas scaleC_cancel_left = complex_vector.scale_cancel_left
 lemmas scaleC_cancel_right = complex_vector.scale_cancel_right
 
 lemma divideC_field_simps[field_simps]: (* In Real_Vector_Spaces, these lemmas are unnamed *)
   "c \<noteq> 0 \<Longrightarrow> a = b /\<^sub>C c \<longleftrightarrow> c *\<^sub>C a = b"
   "c \<noteq> 0 \<Longrightarrow> b /\<^sub>C c = a \<longleftrightarrow> b = c *\<^sub>C a"
   "c \<noteq> 0 \<Longrightarrow> a + b /\<^sub>C c = (c *\<^sub>C a + b) /\<^sub>C c"
   "c \<noteq> 0 \<Longrightarrow> a /\<^sub>C c + b = (a + c *\<^sub>C b) /\<^sub>C c"
   "c \<noteq> 0 \<Longrightarrow> a - b /\<^sub>C c = (c *\<^sub>C a - b) /\<^sub>C c"
   "c \<noteq> 0 \<Longrightarrow> a /\<^sub>C c - b = (a - c *\<^sub>C b) /\<^sub>C c"
   "c \<noteq> 0 \<Longrightarrow> - (a /\<^sub>C c) + b = (- a + c *\<^sub>C b) /\<^sub>C c"
   "c \<noteq> 0 \<Longrightarrow> - (a /\<^sub>C c) - b = (- a - c *\<^sub>C b) /\<^sub>C c"
   for a b :: "'a :: complex_vector"
   by (auto simp add: scaleC_add_right scaleC_add_left scaleC_diff_right scaleC_diff_left)
 
 
 text \<open>Legacy names -- omitted\<close>
 
 (* lemmas scaleC_left_distrib = scaleC_add_left
 lemmas scaleC_right_distrib = scaleC_add_right
 lemmas scaleC_left_diff_distrib = scaleC_diff_left
 lemmas scaleC_right_diff_distrib = scaleC_diff_right *)
 
 lemmas clinear_injective_0 = linear_inj_iff_eq_0
   and clinear_injective_on_subspace_0 = linear_inj_on_iff_eq_0
   and clinear_cmul = linear_scale
   and clinear_scaleC = linear_scale_self
   and csubspace_mul = subspace_scale
   and cspan_linear_image = linear_span_image
   and cspan_0 = span_zero
   and cspan_mul = span_scale
   and injective_scaleC = injective_scale
 
 lemma scaleC_minus1_left [simp]: "scaleC (-1) x = - x"
   for x :: "'a::complex_vector"
   using scaleC_minus_left [of 1 x] by simp
 
 lemma scaleC_2:
   fixes x :: "'a::complex_vector"
   shows "scaleC 2 x = x + x"
   unfolding one_add_one [symmetric] scaleC_add_left by simp
 
 lemma scaleC_half_double [simp]:
   fixes a :: "'a::complex_vector"
   shows "(1 / 2) *\<^sub>C (a + a) = a"
 proof -
   have "\<And>r. r *\<^sub>C (a + a) = (r * 2) *\<^sub>C a"
     by (metis scaleC_2 scaleC_scaleC)
   thus ?thesis
     by simp
 qed
 
 lemma clinear_scale_complex:
   fixes c::complex shows "clinear f \<Longrightarrow> f (c * b) = c * f b"
   using complex_vector.linear_scale by fastforce
 
 
 interpretation scaleC_left: additive "(\<lambda>a. scaleC a x :: 'a::complex_vector)"
   by standard (rule scaleC_add_left)
 
 interpretation scaleC_right: additive "(\<lambda>x. scaleC a x :: 'a::complex_vector)"
   by standard (rule scaleC_add_right)
 
 lemma nonzero_inverse_scaleC_distrib:
   "a \<noteq> 0 \<Longrightarrow> x \<noteq> 0 \<Longrightarrow> inverse (scaleC a x) = scaleC (inverse a) (inverse x)"
   for x :: "'a::complex_div_algebra"
   by (rule inverse_unique) simp
 
 lemma inverse_scaleC_distrib: "inverse (scaleC a x) = scaleC (inverse a) (inverse x)"
   for x :: "'a::{complex_div_algebra,division_ring}"
   by (metis inverse_zero nonzero_inverse_scaleC_distrib complex_vector.scale_eq_0_iff)
 
 (* lemmas sum_constant_scaleC = real_vector.sum_constant_scale\<comment> \<open>legacy name\<close> *)
 
 (* Defined in Real_Vector_Spaces:
 named_theorems vector_add_divide_simps "to simplify sums of scaled vectors" *)
 
 lemma complex_add_divide_simps[vector_add_divide_simps]:  (* In Real_Vector_Spaces, these lemmas are unnamed *)
   "v + (b / z) *\<^sub>C w = (if z = 0 then v else (z *\<^sub>C v + b *\<^sub>C w) /\<^sub>C z)"
   "a *\<^sub>C v + (b / z) *\<^sub>C w = (if z = 0 then a *\<^sub>C v else ((a * z) *\<^sub>C v + b *\<^sub>C w) /\<^sub>C z)"
   "(a / z) *\<^sub>C v + w = (if z = 0 then w else (a *\<^sub>C v + z *\<^sub>C w) /\<^sub>C z)"
   "(a / z) *\<^sub>C v + b *\<^sub>C w = (if z = 0 then b *\<^sub>C w else (a *\<^sub>C v + (b * z) *\<^sub>C w) /\<^sub>C z)"
   "v - (b / z) *\<^sub>C w = (if z = 0 then v else (z *\<^sub>C v - b *\<^sub>C w) /\<^sub>C z)"
   "a *\<^sub>C v - (b / z) *\<^sub>C w = (if z = 0 then a *\<^sub>C v else ((a * z) *\<^sub>C v - b *\<^sub>C w) /\<^sub>C z)"
   "(a / z) *\<^sub>C v - w = (if z = 0 then -w else (a *\<^sub>C v - z *\<^sub>C w) /\<^sub>C z)"
   "(a / z) *\<^sub>C v - b *\<^sub>C w = (if z = 0 then -b *\<^sub>C w else (a *\<^sub>C v - (b * z) *\<^sub>C w) /\<^sub>C z)"
   for v :: "'a :: complex_vector"
   by (simp_all add: divide_inverse_commute scaleC_add_right scaleC_diff_right)
 
 lemma ceq_vector_fraction_iff [vector_add_divide_simps]:
   fixes x :: "'a :: complex_vector"
   shows "(x = (u / v) *\<^sub>C a) \<longleftrightarrow> (if v=0 then x = 0 else v *\<^sub>C x = u *\<^sub>C a)"
   by auto (metis (no_types) divide_eq_1_iff divide_inverse_commute scaleC_one scaleC_scaleC)
 
 lemma cvector_fraction_eq_iff [vector_add_divide_simps]:
   fixes x :: "'a :: complex_vector"
   shows "((u / v) *\<^sub>C a = x) \<longleftrightarrow> (if v=0 then x = 0 else u *\<^sub>C a = v *\<^sub>C x)"
   by (metis ceq_vector_fraction_iff)
 
 lemma complex_vector_affinity_eq:
   fixes x :: "'a :: complex_vector"
   assumes m0: "m \<noteq> 0"
   shows "m *\<^sub>C x + c = y \<longleftrightarrow> x = inverse m *\<^sub>C y - (inverse m *\<^sub>C c)"
     (is "?lhs \<longleftrightarrow> ?rhs")
 proof
   assume ?lhs
   hence "m *\<^sub>C x = y - c" by (simp add: field_simps)
   hence "inverse m *\<^sub>C (m *\<^sub>C x) = inverse m *\<^sub>C (y - c)" by simp
   thus "x = inverse m *\<^sub>C y - (inverse m *\<^sub>C c)"
     using m0
     by (simp add: complex_vector.scale_right_diff_distrib)
 next
   assume ?rhs
   with m0 show "m *\<^sub>C x + c = y"
     by (simp add: complex_vector.scale_right_diff_distrib)
 qed
 
 lemma complex_vector_eq_affinity: "m \<noteq> 0 \<Longrightarrow> y = m *\<^sub>C x + c \<longleftrightarrow> inverse m *\<^sub>C y - (inverse m *\<^sub>C c) = x"
   for x :: "'a::complex_vector"
   using complex_vector_affinity_eq[where m=m and x=x and y=y and c=c]
   by metis
 
 lemma scaleC_eq_iff [simp]: "b + u *\<^sub>C a = a + u *\<^sub>C b \<longleftrightarrow> a = b \<or> u = 1"
   for a :: "'a::complex_vector"
 proof (cases "u = 1")
   case True
   thus ?thesis by auto
 next
   case False
   have "a = b" if "b + u *\<^sub>C a = a + u *\<^sub>C b"
   proof -
     from that have "(u - 1) *\<^sub>C a = (u - 1) *\<^sub>C b"
       by (simp add: algebra_simps)
     with False show ?thesis
       by auto
   qed
   thus ?thesis by auto
 qed
 
 lemma scaleC_collapse [simp]: "(1 - u) *\<^sub>C a + u *\<^sub>C a = a"
   for a :: "'a::complex_vector"
   by (simp add: algebra_simps)
 
 subsection \<open>Embedding of the Complex Numbers into any \<open>complex_algebra_1\<close>: \<open>of_complex\<close>\<close>
 
 
 definition of_complex :: "complex \<Rightarrow> 'a::complex_algebra_1"
   where "of_complex c = scaleC c 1"
 
 
 lemma scaleC_conv_of_complex: "scaleC r x = of_complex r * x"
   by (simp add: of_complex_def)
 
 lemma of_complex_0 [simp]: "of_complex 0 = 0"
   by (simp add: of_complex_def)
 
 lemma of_complex_1 [simp]: "of_complex 1 = 1"
   by (simp add: of_complex_def)
 
 lemma of_complex_add [simp]: "of_complex (x + y) = of_complex x + of_complex y"
   by (simp add: of_complex_def scaleC_add_left)
 
 lemma of_complex_minus [simp]: "of_complex (- x) = - of_complex x"
   by (simp add: of_complex_def)
 
 lemma of_complex_diff [simp]: "of_complex (x - y) = of_complex x - of_complex y"
   by (simp add: of_complex_def scaleC_diff_left)
 
 lemma of_complex_mult [simp]: "of_complex (x * y) = of_complex x * of_complex y"
   by (simp add: of_complex_def mult.commute)
 
 lemma of_complex_sum[simp]: "of_complex (sum f s) = (\<Sum>x\<in>s. of_complex (f x))"
   by (induct s rule: infinite_finite_induct) auto
 
 lemma of_complex_prod[simp]: "of_complex (prod f s) = (\<Prod>x\<in>s. of_complex (f x))"
   by (induct s rule: infinite_finite_induct) auto
 
 lemma nonzero_of_complex_inverse:
   "x \<noteq> 0 \<Longrightarrow> of_complex (inverse x) = inverse (of_complex x :: 'a::complex_div_algebra)"
   by (simp add: of_complex_def nonzero_inverse_scaleC_distrib)
 
 lemma of_complex_inverse [simp]:
   "of_complex (inverse x) = inverse (of_complex x :: 'a::{complex_div_algebra,division_ring})"
   by (simp add: of_complex_def inverse_scaleC_distrib)
 
 lemma nonzero_of_complex_divide:
   "y \<noteq> 0 \<Longrightarrow> of_complex (x / y) = (of_complex x / of_complex y :: 'a::complex_field)"
   by (simp add: divide_inverse nonzero_of_complex_inverse)
 
 lemma of_complex_divide [simp]:
   "of_complex (x / y) = (of_complex x / of_complex y :: 'a::complex_div_algebra)"
   by (simp add: divide_inverse)
 
 lemma of_complex_power [simp]:
   "of_complex (x ^ n) = (of_complex x :: 'a::{complex_algebra_1}) ^ n"
   by (induct n) simp_all
 
 lemma of_complex_power_int [simp]:
   "of_complex (power_int x n) = power_int (of_complex x :: 'a :: {complex_div_algebra,division_ring}) n"
   by (auto simp: power_int_def)
 
 lemma of_complex_eq_iff [simp]: "of_complex x = of_complex y \<longleftrightarrow> x = y"
   by (simp add: of_complex_def)
 
 lemma inj_of_complex: "inj of_complex"
   by (auto intro: injI)
 
 lemmas of_complex_eq_0_iff [simp] = of_complex_eq_iff [of _ 0, simplified]
 lemmas of_complex_eq_1_iff [simp] = of_complex_eq_iff [of _ 1, simplified]
 
 lemma minus_of_complex_eq_of_complex_iff [simp]: "-of_complex x = of_complex y \<longleftrightarrow> -x = y"
   using of_complex_eq_iff[of "-x" y] by (simp only: of_complex_minus)
 
 lemma of_complex_eq_minus_of_complex_iff [simp]: "of_complex x = -of_complex y \<longleftrightarrow> x = -y"
   using of_complex_eq_iff[of x "-y"] by (simp only: of_complex_minus)
 
 lemma of_complex_eq_id [simp]: "of_complex = (id :: complex \<Rightarrow> complex)"
   by (rule ext) (simp add: of_complex_def)
 
 text \<open>Collapse nested embeddings.\<close>
 lemma of_complex_of_nat_eq [simp]: "of_complex (of_nat n) = of_nat n"
   by (induct n) auto
 
 lemma of_complex_of_int_eq [simp]: "of_complex (of_int z) = of_int z"
   by (cases z rule: int_diff_cases) simp
 
 lemma of_complex_numeral [simp]: "of_complex (numeral w) = numeral w"
   using of_complex_of_int_eq [of "numeral w"] by simp
 
 lemma of_complex_neg_numeral [simp]: "of_complex (- numeral w) = - numeral w"
   using of_complex_of_int_eq [of "- numeral w"] by simp
 
 lemma numeral_power_int_eq_of_complex_cancel_iff [simp]:
   "power_int (numeral x) n = (of_complex y :: 'a :: {complex_div_algebra, division_ring}) \<longleftrightarrow>
      power_int (numeral x) n = y"
 proof -
   have "power_int (numeral x) n = (of_complex (power_int (numeral x) n) :: 'a)"
     by simp
   also have "\<dots> = of_complex y \<longleftrightarrow> power_int (numeral x) n = y"
     by (subst of_complex_eq_iff) auto
   finally show ?thesis .
 qed
 
 lemma of_complex_eq_numeral_power_int_cancel_iff [simp]:
   "(of_complex y :: 'a :: {complex_div_algebra, division_ring}) = power_int (numeral x) n \<longleftrightarrow>
      y = power_int (numeral x) n"
   by (subst (1 2) eq_commute) simp
 
 lemma of_complex_eq_of_complex_power_int_cancel_iff [simp]:
   "power_int (of_complex b :: 'a :: {complex_div_algebra, division_ring}) w = of_complex x \<longleftrightarrow>
      power_int b w = x"
   by (metis of_complex_power_int of_complex_eq_iff)
 
 lemma of_complex_in_Ints_iff [simp]: "of_complex x \<in> \<int> \<longleftrightarrow> x \<in> \<int>"
 proof safe
   fix x assume "(of_complex x :: 'a) \<in> \<int>"
   then obtain n where "(of_complex x :: 'a) = of_int n"
     by (auto simp: Ints_def)
   also have "of_int n = of_complex (of_int n)"
     by simp
   finally have "x = of_int n"
     by (subst (asm) of_complex_eq_iff)
   thus "x \<in> \<int>"
     by auto
 qed (auto simp: Ints_def)
 
 lemma Ints_of_complex [intro]: "x \<in> \<int> \<Longrightarrow> of_complex x \<in> \<int>"
   by simp
 
 
 text \<open>Every complex algebra has characteristic zero.\<close>
 
 (* Inherited from real_algebra_1 *)
 (* instance complex_algebra_1 < ring_char_0 .. *)
 
 lemma fraction_scaleC_times [simp]:
   fixes a :: "'a::complex_algebra_1"
   shows "(numeral u / numeral v) *\<^sub>C (numeral w * a) = (numeral u * numeral w / numeral v) *\<^sub>C a"
   by (metis (no_types, lifting) of_complex_numeral scaleC_conv_of_complex scaleC_scaleC times_divide_eq_left)
 
 lemma inverse_scaleC_times [simp]:
   fixes a :: "'a::complex_algebra_1"
   shows "(1 / numeral v) *\<^sub>C (numeral w * a) = (numeral w / numeral v) *\<^sub>C a"
   by (metis divide_inverse_commute inverse_eq_divide of_complex_numeral scaleC_conv_of_complex scaleC_scaleC)
 
 lemma scaleC_times [simp]:
   fixes a :: "'a::complex_algebra_1"
   shows "(numeral u) *\<^sub>C (numeral w * a) = (numeral u * numeral w) *\<^sub>C a"
   by (simp add: scaleC_conv_of_complex)
 
 (* Inherited from real_field *)
 (* instance complex_field < field_char_0 .. *)
 
 
 subsection \<open>The Set of Real Numbers\<close>
 
 definition Complexs :: "'a::complex_algebra_1 set"  ("\<complex>")
   where "\<complex> = range of_complex"
 
 lemma Complexs_of_complex [simp]: "of_complex r \<in> \<complex>"
   by (simp add: Complexs_def)
 
 lemma Complexs_of_int [simp]: "of_int z \<in> \<complex>"
   by (subst of_complex_of_int_eq [symmetric], rule Complexs_of_complex)
 
 lemma Complexs_of_nat [simp]: "of_nat n \<in> \<complex>"
   by (subst of_complex_of_nat_eq [symmetric], rule Complexs_of_complex)
 
 lemma Complexs_numeral [simp]: "numeral w \<in> \<complex>"
   by (subst of_complex_numeral [symmetric], rule Complexs_of_complex)
 
 lemma Complexs_0 [simp]: "0 \<in> \<complex>" and Complexs_1 [simp]: "1 \<in> \<complex>"
   by (simp_all add: Complexs_def)
 
 lemma Complexs_add [simp]: "a \<in> \<complex> \<Longrightarrow> b \<in> \<complex> \<Longrightarrow> a + b \<in> \<complex>"
   apply (auto simp add: Complexs_def)
-  by (metis of_complex_add range_eqI) 
+  by (metis of_complex_add range_eqI)
 
 lemma Complexs_minus [simp]: "a \<in> \<complex> \<Longrightarrow> - a \<in> \<complex>"
   by (auto simp: Complexs_def)
 
 lemma Complexs_minus_iff [simp]: "- a \<in> \<complex> \<longleftrightarrow> a \<in> \<complex>"
   using Complexs_minus by fastforce
 
 lemma Complexs_diff [simp]: "a \<in> \<complex> \<Longrightarrow> b \<in> \<complex> \<Longrightarrow> a - b \<in> \<complex>"
   by (metis Complexs_add Complexs_minus_iff add_uminus_conv_diff)
 
 lemma Complexs_mult [simp]: "a \<in> \<complex> \<Longrightarrow> b \<in> \<complex> \<Longrightarrow> a * b \<in> \<complex>"
   apply (auto simp add: Complexs_def)
   by (metis of_complex_mult rangeI)
 
 lemma nonzero_Complexs_inverse: "a \<in> \<complex> \<Longrightarrow> a \<noteq> 0 \<Longrightarrow> inverse a \<in> \<complex>"
   for a :: "'a::complex_div_algebra"
   apply (auto simp add: Complexs_def)
-  by (metis of_complex_inverse range_eqI) 
+  by (metis of_complex_inverse range_eqI)
 
 lemma Complexs_inverse: "a \<in> \<complex> \<Longrightarrow> inverse a \<in> \<complex>"
   for a :: "'a::{complex_div_algebra,division_ring}"
   using nonzero_Complexs_inverse by fastforce
 
 lemma Complexs_inverse_iff [simp]: "inverse x \<in> \<complex> \<longleftrightarrow> x \<in> \<complex>"
   for x :: "'a::{complex_div_algebra,division_ring}"
   by (metis Complexs_inverse inverse_inverse_eq)
 
 lemma nonzero_Complexs_divide: "a \<in> \<complex> \<Longrightarrow> b \<in> \<complex> \<Longrightarrow> b \<noteq> 0 \<Longrightarrow> a / b \<in> \<complex>"
   for a b :: "'a::complex_field"
   by (simp add: divide_inverse)
 
 lemma Complexs_divide [simp]: "a \<in> \<complex> \<Longrightarrow> b \<in> \<complex> \<Longrightarrow> a / b \<in> \<complex>"
   for a b :: "'a::{complex_field,field}"
   using nonzero_Complexs_divide by fastforce
 
 lemma Complexs_power [simp]: "a \<in> \<complex> \<Longrightarrow> a ^ n \<in> \<complex>"
   for a :: "'a::complex_algebra_1"
   apply (auto simp add: Complexs_def)
   by (metis range_eqI of_complex_power[symmetric])
 
 lemma Complexs_cases [cases set: Complexs]:
   assumes "q \<in> \<complex>"
   obtains (of_complex) c where "q = of_complex c"
   unfolding Complexs_def
 proof -
   from \<open>q \<in> \<complex>\<close> have "q \<in> range of_complex" unfolding Complexs_def .
   then obtain c where "q = of_complex c" ..
   then show thesis ..
 qed
 
 lemma sum_in_Complexs [intro,simp]: "(\<And>i. i \<in> s \<Longrightarrow> f i \<in> \<complex>) \<Longrightarrow> sum f s \<in> \<complex>"
 proof (induct s rule: infinite_finite_induct)
   case infinite
   then show ?case by (metis Complexs_0 sum.infinite)
 qed simp_all
 
 lemma prod_in_Complexs [intro,simp]: "(\<And>i. i \<in> s \<Longrightarrow> f i \<in> \<complex>) \<Longrightarrow> prod f s \<in> \<complex>"
 proof (induct s rule: infinite_finite_induct)
   case infinite
   then show ?case by (metis Complexs_1 prod.infinite)
 qed simp_all
 
 lemma Complexs_induct [case_names of_complex, induct set: Complexs]:
   "q \<in> \<complex> \<Longrightarrow> (\<And>r. P (of_complex r)) \<Longrightarrow> P q"
   by (rule Complexs_cases) auto
 
 
 
 subsection \<open>Ordered complex vector spaces\<close>
 
 class ordered_complex_vector = complex_vector + ordered_ab_group_add +
   assumes scaleC_left_mono: "x \<le> y \<Longrightarrow> 0 \<le> a \<Longrightarrow> a *\<^sub>C x \<le> a *\<^sub>C y"
     and scaleC_right_mono: "a \<le> b \<Longrightarrow> 0 \<le> x \<Longrightarrow> a *\<^sub>C x \<le> b *\<^sub>C x"
 begin
 
 subclass (in ordered_complex_vector) ordered_real_vector
   apply standard
   by (auto simp add: less_eq_complex_def scaleC_left_mono scaleC_right_mono scaleR_scaleC)
 
 lemma scaleC_mono:
   "a \<le> b \<Longrightarrow> x \<le> y \<Longrightarrow> 0 \<le> b \<Longrightarrow> 0 \<le> x \<Longrightarrow> a *\<^sub>C x \<le> b *\<^sub>C y"
   by (meson order_trans scaleC_left_mono scaleC_right_mono)
 
 lemma scaleC_mono':
   "a \<le> b \<Longrightarrow> c \<le> d \<Longrightarrow> 0 \<le> a \<Longrightarrow> 0 \<le> c \<Longrightarrow> a *\<^sub>C c \<le> b *\<^sub>C d"
   by (rule scaleC_mono) (auto intro: order.trans)
 
 lemma pos_le_divideC_eq [field_simps]:
   "a \<le> b /\<^sub>C c \<longleftrightarrow> c *\<^sub>C a \<le> b" (is "?P \<longleftrightarrow> ?Q") if "0 < c"
 proof
   assume ?P
   with scaleC_left_mono that have "c *\<^sub>C a \<le> c *\<^sub>C (b /\<^sub>C c)"
     using preorder_class.less_imp_le by blast
   with that show ?Q
     by auto
 next
   assume ?Q
   with scaleC_left_mono that have "c *\<^sub>C a /\<^sub>C c \<le> b /\<^sub>C c"
     using less_complex_def less_eq_complex_def by fastforce
   with that show ?P
     by auto
 qed
 
 lemma pos_less_divideC_eq [field_simps]:
   "a < b /\<^sub>C c \<longleftrightarrow> c *\<^sub>C a < b" if "c > 0"
   using that pos_le_divideC_eq [of c a b]
   by (auto simp add: le_less)
 
 lemma pos_divideC_le_eq [field_simps]:
   "b /\<^sub>C c \<le> a \<longleftrightarrow> b \<le> c *\<^sub>C a" if "c > 0"
   using that pos_le_divideC_eq [of "inverse c" b a]
     less_complex_def by auto
 
 lemma pos_divideC_less_eq [field_simps]:
   "b /\<^sub>C c < a \<longleftrightarrow> b < c *\<^sub>C a" if "c > 0"
   using that pos_less_divideC_eq [of "inverse c" b a]
   by (simp add: local.less_le_not_le local.pos_divideC_le_eq local.pos_le_divideC_eq)
 
 lemma pos_le_minus_divideC_eq [field_simps]:
   "a \<le> - (b /\<^sub>C c) \<longleftrightarrow> c *\<^sub>C a \<le> - b" if "c > 0"
   using that
   by (metis local.ab_left_minus local.add.inverse_unique local.add.right_inverse local.add_minus_cancel local.le_minus_iff local.pos_divideC_le_eq local.scaleC_add_right local.scaleC_one local.scaleC_scaleC)
 
 lemma pos_less_minus_divideC_eq [field_simps]:
   "a < - (b /\<^sub>C c) \<longleftrightarrow> c *\<^sub>C a < - b" if "c > 0"
   using that
   by (metis le_less less_le_not_le pos_divideC_le_eq pos_divideC_less_eq pos_le_minus_divideC_eq)
 
 lemma pos_minus_divideC_le_eq [field_simps]:
   "- (b /\<^sub>C c) \<le> a \<longleftrightarrow> - b \<le> c *\<^sub>C a" if "c > 0"
   using that
   by (metis local.add_minus_cancel local.left_minus local.pos_divideC_le_eq local.scaleC_add_right)
 
 lemma pos_minus_divideC_less_eq [field_simps]:
   "- (b /\<^sub>C c) < a \<longleftrightarrow> - b < c *\<^sub>C a" if "c > 0"
-  using that by (simp add: less_le_not_le pos_le_minus_divideC_eq pos_minus_divideC_le_eq) 
+  using that by (simp add: less_le_not_le pos_le_minus_divideC_eq pos_minus_divideC_le_eq)
 
 lemma scaleC_image_atLeastAtMost: "c > 0 \<Longrightarrow> scaleC c ` {x..y} = {c *\<^sub>C x..c *\<^sub>C y}"
   apply (auto intro!: scaleC_left_mono simp: image_iff Bex_def)
-  by (meson local.eq_iff pos_divideC_le_eq pos_le_divideC_eq)
+  by (meson order.eq_iff pos_divideC_le_eq pos_le_divideC_eq)
 
 end (* class ordered_complex_vector *)
 
 lemma neg_le_divideC_eq [field_simps]:
   "a \<le> b /\<^sub>C c \<longleftrightarrow> b \<le> c *\<^sub>C a" (is "?P \<longleftrightarrow> ?Q") if "c < 0"
     for a b :: "'a :: ordered_complex_vector"
   using that pos_le_divideC_eq [of "- c" a "- b"]
   by (simp add: less_complex_def)
 
 lemma neg_less_divideC_eq [field_simps]:
   "a < b /\<^sub>C c \<longleftrightarrow> b < c *\<^sub>C a" if "c < 0"
     for a b :: "'a :: ordered_complex_vector"
   using that neg_le_divideC_eq [of c a b]
   by (smt (verit, ccfv_SIG) neg_le_divideC_eq antisym_conv2 complex_vector.scale_minus_right dual_order.strict_implies_order le_less_trans neg_le_iff_le scaleC_scaleC)
 
 lemma neg_divideC_le_eq [field_simps]:
   "b /\<^sub>C c \<le> a \<longleftrightarrow> c *\<^sub>C a \<le> b" if "c < 0"
     for a b :: "'a :: ordered_complex_vector"
   using that pos_divideC_le_eq [of "- c" "- b" a]
   by (simp add: less_complex_def)
 
 lemma neg_divideC_less_eq [field_simps]:
   "b /\<^sub>C c < a \<longleftrightarrow> c *\<^sub>C a < b" if "c < 0"
     for a b :: "'a :: ordered_complex_vector"
   using that neg_divideC_le_eq [of c b a]
   by (meson neg_le_divideC_eq less_le_not_le)
 
 lemma neg_le_minus_divideC_eq [field_simps]:
   "a \<le> - (b /\<^sub>C c) \<longleftrightarrow> - b \<le> c *\<^sub>C a" if "c < 0"
     for a b :: "'a :: ordered_complex_vector"
   using that pos_le_minus_divideC_eq [of "- c" a "- b"]
   by (metis neg_le_divideC_eq complex_vector.scale_minus_right)
 
 lemma neg_less_minus_divideC_eq [field_simps]:
   "a < - (b /\<^sub>C c) \<longleftrightarrow> - b < c *\<^sub>C a" if "c < 0"
     for a b :: "'a :: ordered_complex_vector"
 proof -
   have *: "- b = c *\<^sub>C a \<longleftrightarrow> b = - (c *\<^sub>C a)"
     by (metis add.inverse_inverse)
   from that neg_le_minus_divideC_eq [of c a b]
   show ?thesis by (auto simp add: le_less *)
 qed
 
 lemma neg_minus_divideC_le_eq [field_simps]:
   "- (b /\<^sub>C c) \<le> a \<longleftrightarrow> c *\<^sub>C a \<le> - b" if "c < 0"
 for a b :: "'a :: ordered_complex_vector"
   using that pos_minus_divideC_le_eq [of "- c" "- b" a]
   by (metis Complex_Vector_Spaces0.neg_divideC_le_eq complex_vector.scale_minus_right)
 
 lemma neg_minus_divideC_less_eq [field_simps]:
   "- (b /\<^sub>C c) < a \<longleftrightarrow> c *\<^sub>C a < - b" if "c < 0"
 for a b :: "'a :: ordered_complex_vector"
   using that by (simp add: less_le_not_le neg_le_minus_divideC_eq neg_minus_divideC_le_eq)
 
 lemma divideC_field_splits_simps_1 [field_split_simps]: (* In Real_Vector_Spaces, these lemmas are unnamed *)
   "a = b /\<^sub>C c \<longleftrightarrow> (if c = 0 then a = 0 else c *\<^sub>C a = b)"
   "b /\<^sub>C c = a \<longleftrightarrow> (if c = 0 then a = 0 else b = c *\<^sub>C a)"
   "a + b /\<^sub>C c = (if c = 0 then a else (c *\<^sub>C a + b) /\<^sub>C c)"
   "a /\<^sub>C c + b = (if c = 0 then b else (a + c *\<^sub>C b) /\<^sub>C c)"
   "a - b /\<^sub>C c = (if c = 0 then a else (c *\<^sub>C a - b) /\<^sub>C c)"
   "a /\<^sub>C c - b = (if c = 0 then - b else (a - c *\<^sub>C b) /\<^sub>C c)"
   "- (a /\<^sub>C c) + b = (if c = 0 then b else (- a + c *\<^sub>C b) /\<^sub>C c)"
   "- (a /\<^sub>C c) - b = (if c = 0 then - b else (- a - c *\<^sub>C b) /\<^sub>C c)"
   for a b :: "'a :: complex_vector"
   by (auto simp add: field_simps)
 
 lemma divideC_field_splits_simps_2 [field_split_simps]: (* In Real_Vector_Spaces, these lemmas are unnamed *)
   "0 < c \<Longrightarrow> a \<le> b /\<^sub>C c \<longleftrightarrow> (if c > 0 then c *\<^sub>C a \<le> b else if c < 0 then b \<le> c *\<^sub>C a else a \<le> 0)"
   "0 < c \<Longrightarrow> a < b /\<^sub>C c \<longleftrightarrow> (if c > 0 then c *\<^sub>C a < b else if c < 0 then b < c *\<^sub>C a else a < 0)"
   "0 < c \<Longrightarrow> b /\<^sub>C c \<le> a \<longleftrightarrow> (if c > 0 then b \<le> c *\<^sub>C a else if c < 0 then c *\<^sub>C a \<le> b else a \<ge> 0)"
   "0 < c \<Longrightarrow> b /\<^sub>C c < a \<longleftrightarrow> (if c > 0 then b < c *\<^sub>C a else if c < 0 then c *\<^sub>C a < b else a > 0)"
   "0 < c \<Longrightarrow> a \<le> - (b /\<^sub>C c) \<longleftrightarrow> (if c > 0 then c *\<^sub>C a \<le> - b else if c < 0 then - b \<le> c *\<^sub>C a else a \<le> 0)"
   "0 < c \<Longrightarrow> a < - (b /\<^sub>C c) \<longleftrightarrow> (if c > 0 then c *\<^sub>C a < - b else if c < 0 then - b < c *\<^sub>C a else a < 0)"
   "0 < c \<Longrightarrow> - (b /\<^sub>C c) \<le> a \<longleftrightarrow> (if c > 0 then - b \<le> c *\<^sub>C a else if c < 0 then c *\<^sub>C a \<le> - b else a \<ge> 0)"
   "0 < c \<Longrightarrow> - (b /\<^sub>C c) < a \<longleftrightarrow> (if c > 0 then - b < c *\<^sub>C a else if c < 0 then c *\<^sub>C a < - b else a > 0)"
   for a b :: "'a :: ordered_complex_vector"
   by (clarsimp intro!: field_simps)+
 
 lemma scaleC_nonneg_nonneg: "0 \<le> a \<Longrightarrow> 0 \<le> x \<Longrightarrow> 0 \<le> a *\<^sub>C x"
   for x :: "'a::ordered_complex_vector"
   using scaleC_left_mono [of 0 x a] by simp
 
 lemma scaleC_nonneg_nonpos: "0 \<le> a \<Longrightarrow> x \<le> 0 \<Longrightarrow> a *\<^sub>C x \<le> 0"
   for x :: "'a::ordered_complex_vector"
   using scaleC_left_mono [of x 0 a] by simp
 
 lemma scaleC_nonpos_nonneg: "a \<le> 0 \<Longrightarrow> 0 \<le> x \<Longrightarrow> a *\<^sub>C x \<le> 0"
   for x :: "'a::ordered_complex_vector"
   using scaleC_right_mono [of a 0 x] by simp
 
 lemma split_scaleC_neg_le: "(0 \<le> a \<and> x \<le> 0) \<or> (a \<le> 0 \<and> 0 \<le> x) \<Longrightarrow> a *\<^sub>C x \<le> 0"
   for x :: "'a::ordered_complex_vector"
   by (auto simp: scaleC_nonneg_nonpos scaleC_nonpos_nonneg)
 
 lemma cle_add_iff1: "a *\<^sub>C e + c \<le> b *\<^sub>C e + d \<longleftrightarrow> (a - b) *\<^sub>C e + c \<le> d"
   for c d e :: "'a::ordered_complex_vector"
   by (simp add: algebra_simps)
 
 lemma cle_add_iff2: "a *\<^sub>C e + c \<le> b *\<^sub>C e + d \<longleftrightarrow> c \<le> (b - a) *\<^sub>C e + d"
   for c d e :: "'a::ordered_complex_vector"
   by (simp add: algebra_simps)
 
 lemma scaleC_left_mono_neg: "b \<le> a \<Longrightarrow> c \<le> 0 \<Longrightarrow> c *\<^sub>C a \<le> c *\<^sub>C b"
   for a b :: "'a::ordered_complex_vector"
   by (drule scaleC_left_mono [of _ _ "- c"], simp_all add: less_eq_complex_def)
 
 lemma scaleC_right_mono_neg: "b \<le> a \<Longrightarrow> c \<le> 0 \<Longrightarrow> a *\<^sub>C c \<le> b *\<^sub>C c"
   for c :: "'a::ordered_complex_vector"
   by (drule scaleC_right_mono [of _ _ "- c"], simp_all)
 
 lemma scaleC_nonpos_nonpos: "a \<le> 0 \<Longrightarrow> b \<le> 0 \<Longrightarrow> 0 \<le> a *\<^sub>C b"
   for b :: "'a::ordered_complex_vector"
   using scaleC_right_mono_neg [of a 0 b] by simp
 
 lemma split_scaleC_pos_le: "(0 \<le> a \<and> 0 \<le> b) \<or> (a \<le> 0 \<and> b \<le> 0) \<Longrightarrow> 0 \<le> a *\<^sub>C b"
   for b :: "'a::ordered_complex_vector"
   by (auto simp: scaleC_nonneg_nonneg scaleC_nonpos_nonpos)
 
 lemma zero_le_scaleC_iff:
   fixes b :: "'a::ordered_complex_vector"
   assumes "a \<in> \<real>" (* Not present in Real_Vector_Spaces.thy *)
   shows "0 \<le> a *\<^sub>C b \<longleftrightarrow> 0 < a \<and> 0 \<le> b \<or> a < 0 \<and> b \<le> 0 \<or> a = 0"
     (is "?lhs = ?rhs")
 proof (cases "a = 0")
   case True
   then show ?thesis by simp
 next
   case False
   show ?thesis
   proof
     assume ?lhs
     from \<open>a \<noteq> 0\<close> consider "a > 0" | "a < 0"
       by (metis assms complex_is_Real_iff less_complex_def less_eq_complex_def not_le order.not_eq_order_implies_strict that(1) zero_complex.sel(2))
     then show ?rhs
     proof cases
       case 1
       with \<open>?lhs\<close> have "inverse a *\<^sub>C 0 \<le> inverse a *\<^sub>C (a *\<^sub>C b)"
         by (metis complex_vector.scale_zero_right ordered_complex_vector_class.pos_le_divideC_eq)
       with 1 show ?thesis
         by simp
     next
       case 2
       with \<open>?lhs\<close> have "- inverse a *\<^sub>C 0 \<le> - inverse a *\<^sub>C (a *\<^sub>C b)"
         by (metis Complex_Vector_Spaces0.neg_le_minus_divideC_eq complex_vector.scale_zero_right neg_le_0_iff_le scaleC_left.minus)
       with 2 show ?thesis
         by simp
     qed
   next
     assume ?rhs
     then show ?lhs
       using less_imp_le split_scaleC_pos_le by auto
   qed
 qed
 
 lemma scaleC_le_0_iff:
   "a *\<^sub>C b \<le> 0 \<longleftrightarrow> 0 < a \<and> b \<le> 0 \<or> a < 0 \<and> 0 \<le> b \<or> a = 0"
   if "a \<in> \<real>" (* Not present in Real_Vector_Spaces *)
   for b::"'a::ordered_complex_vector"
   apply (insert zero_le_scaleC_iff [of "-a" b])
   using less_complex_def that by force
 
 
 lemma scaleC_le_cancel_left: "c *\<^sub>C a \<le> c *\<^sub>C b \<longleftrightarrow> (0 < c \<longrightarrow> a \<le> b) \<and> (c < 0 \<longrightarrow> b \<le> a)"
   if "c \<in> \<real>" (* Not present in Real_Vector_Spaces *)
   for b :: "'a::ordered_complex_vector"
   by (smt (verit, ccfv_threshold) Complex_Vector_Spaces0.neg_divideC_le_eq complex_vector.scale_cancel_left complex_vector.scale_zero_right dual_order.eq_iff dual_order.trans ordered_complex_vector_class.pos_le_divideC_eq that zero_le_scaleC_iff)
 
 lemma scaleC_le_cancel_left_pos: "0 < c \<Longrightarrow> c *\<^sub>C a \<le> c *\<^sub>C b \<longleftrightarrow> a \<le> b"
   for b :: "'a::ordered_complex_vector"
   by (simp add: complex_is_Real_iff less_complex_def scaleC_le_cancel_left)
 
 lemma scaleC_le_cancel_left_neg: "c < 0 \<Longrightarrow> c *\<^sub>C a \<le> c *\<^sub>C b \<longleftrightarrow> b \<le> a"
   for b :: "'a::ordered_complex_vector"
   by (simp add: complex_is_Real_iff less_complex_def scaleC_le_cancel_left)
 
 lemma scaleC_left_le_one_le: "0 \<le> x \<Longrightarrow> a \<le> 1 \<Longrightarrow> a *\<^sub>C x \<le> x"
   for x :: "'a::ordered_complex_vector" and a :: complex
   using scaleC_right_mono[of a 1 x] by simp
 
 subsection \<open>Complex normed vector spaces\<close>
 
 (* Classes dist, norm, sgn_div_norm, dist_norm, uniformity_dist
    defined in Real_Vector_Spaces are unchanged in the complex setting.
    No need to define them here. *)
 
 class complex_normed_vector = complex_vector + sgn_div_norm + dist_norm + uniformity_dist + open_uniformity +
   real_normed_vector + (* Not present in Real_Normed_Vector *)
   assumes norm_scaleC [simp]: "norm (scaleC a x) = cmod a * norm x"
 begin
 (* lemma norm_ge_zero [simp]: "0 \<le> norm x" *) (* Not needed, included from real_normed_vector *)
 end
 
 class complex_normed_algebra = complex_algebra + complex_normed_vector +
   real_normed_algebra (* Not present in Real_Normed_Vector *)
   (* assumes norm_mult_ineq: "norm (x * y) \<le> norm x * norm y" *) (* Not needed, included from real_normed_algebra *)
 
 class complex_normed_algebra_1 = complex_algebra_1 + complex_normed_algebra +
   real_normed_algebra_1 (* Not present in Real_Normed_Vector *)
   (* assumes norm_one [simp]: "norm 1 = 1" *) (* Not needed, included from real_normed_algebra_1 *)
 
 lemma (in complex_normed_algebra_1) scaleC_power [simp]: "(scaleC x y) ^ n = scaleC (x^n) (y^n)"
   by (induct n) (simp_all add: mult_ac)
 
 class complex_normed_div_algebra = complex_div_algebra + complex_normed_vector +
   real_normed_div_algebra (* Not present in Real_Normed_Vector *)
   (* assumes norm_mult: "norm (x * y) = norm x * norm y" *) (* Not needed, included from real_normed_div_algebra *)
 
 class complex_normed_field = complex_field + complex_normed_div_algebra
 
 subclass (in complex_normed_field) real_normed_field ..
 
 instance complex_normed_div_algebra < complex_normed_algebra_1 ..
 
 context complex_normed_vector begin
 (* Inherited from real_normed_vector:
 lemma norm_zero [simp]: "norm (0::'a) = 0"
 lemma zero_less_norm_iff [simp]: "norm x > 0 \<longleftrightarrow> x \<noteq> 0"
 lemma norm_not_less_zero [simp]: "\<not> norm x < 0"
 lemma norm_le_zero_iff [simp]: "norm x \<le> 0 \<longleftrightarrow> x = 0"
 lemma norm_minus_cancel [simp]: "norm (- x) = norm x"
 lemma norm_minus_commute: "norm (a - b) = norm (b - a)"
 lemma dist_add_cancel [simp]: "dist (a + b) (a + c) = dist b c"
 lemma dist_add_cancel2 [simp]: "dist (b + a) (c + a) = dist b c"
 lemma norm_uminus_minus: "norm (- x - y) = norm (x + y)"
 lemma norm_triangle_ineq2: "norm a - norm b \<le> norm (a - b)"
 lemma norm_triangle_ineq3: "\<bar>norm a - norm b\<bar> \<le> norm (a - b)"
 lemma norm_triangle_ineq4: "norm (a - b) \<le> norm a + norm b"
 lemma norm_triangle_le_diff: "norm x + norm y \<le> e \<Longrightarrow> norm (x - y) \<le> e"
 lemma norm_diff_ineq: "norm a - norm b \<le> norm (a + b)"
 lemma norm_triangle_sub: "norm x \<le> norm y + norm (x - y)"
 lemma norm_triangle_le: "norm x + norm y \<le> e \<Longrightarrow> norm (x + y) \<le> e"
 lemma norm_triangle_lt: "norm x + norm y < e \<Longrightarrow> norm (x + y) < e"
 lemma norm_add_leD: "norm (a + b) \<le> c \<Longrightarrow> norm b \<le> norm a + c"
 lemma norm_diff_triangle_ineq: "norm ((a + b) - (c + d)) \<le> norm (a - c) + norm (b - d)"
 lemma norm_diff_triangle_le: "norm (x - z) \<le> e1 + e2"
   if "norm (x - y) \<le> e1"  "norm (y - z) \<le> e2"
 lemma norm_diff_triangle_less: "norm (x - z) < e1 + e2"
   if "norm (x - y) < e1"  "norm (y - z) < e2"
 lemma norm_triangle_mono:
   "norm a \<le> r \<Longrightarrow> norm b \<le> s \<Longrightarrow> norm (a + b) \<le> r + s"
 lemma norm_sum: "norm (sum f A) \<le> (\<Sum>i\<in>A. norm (f i))"
   for f::"'b \<Rightarrow> 'a"
 lemma sum_norm_le: "norm (sum f S) \<le> sum g S"
   if "\<And>x. x \<in> S \<Longrightarrow> norm (f x) \<le> g x"
   for f::"'b \<Rightarrow> 'a"
 lemma abs_norm_cancel [simp]: "\<bar>norm a\<bar> = norm a"
 lemma sum_norm_bound:
   "norm (sum f S) \<le> of_nat (card S)*K"
   if "\<And>x. x \<in> S \<Longrightarrow> norm (f x) \<le> K"
   for f :: "'b \<Rightarrow> 'a"
 lemma norm_add_less: "norm x < r \<Longrightarrow> norm y < s \<Longrightarrow> norm (x + y) < r + s"
 *)
 end
 
 lemma dist_scaleC [simp]: "dist (x *\<^sub>C a) (y *\<^sub>C a) = \<bar>x - y\<bar> * norm a"
   for a :: "'a::complex_normed_vector"
   by (metis dist_scaleR scaleR_scaleC)
 
 (* Inherited from real_normed_vector *)
 (* lemma norm_mult_less: "norm x < r \<Longrightarrow> norm y < s \<Longrightarrow> norm (x * y) < r * s"
   for x y :: "'a::complex_normed_algebra" *)
 
 lemma norm_of_complex [simp]: "norm (of_complex c :: 'a::complex_normed_algebra_1) = cmod c"
   by (simp add: of_complex_def)
 
 (* Inherited from real_normed_vector:
 lemma norm_numeral [simp]: "norm (numeral w::'a::complex_normed_algebra_1) = numeral w"
 lemma norm_neg_numeral [simp]: "norm (- numeral w::'a::complex_normed_algebra_1) = numeral w"
 lemma norm_of_complex_add1 [simp]: "norm (of_real x + 1 :: 'a :: complex_normed_div_algebra) = \<bar>x + 1\<bar>"
 lemma norm_of_complex_addn [simp]:
   "norm (of_real x + numeral b :: 'a :: complex_normed_div_algebra) = \<bar>x + numeral b\<bar>"
 lemma norm_of_int [simp]: "norm (of_int z::'a::complex_normed_algebra_1) = \<bar>of_int z\<bar>"
 lemma norm_of_nat [simp]: "norm (of_nat n::'a::complex_normed_algebra_1) = of_nat n"
 lemma nonzero_norm_inverse: "a \<noteq> 0 \<Longrightarrow> norm (inverse a) = inverse (norm a)"
   for a :: "'a::complex_normed_div_algebra"
 lemma norm_inverse: "norm (inverse a) = inverse (norm a)"
   for a :: "'a::{complex_normed_div_algebra,division_ring}"
 lemma nonzero_norm_divide: "b \<noteq> 0 \<Longrightarrow> norm (a / b) = norm a / norm b"
   for a b :: "'a::complex_normed_field"
 lemma norm_divide: "norm (a / b) = norm a / norm b"
   for a b :: "'a::{complex_normed_field,field}"
 lemma norm_inverse_le_norm:
   fixes x :: "'a::complex_normed_div_algebra"
   shows "r \<le> norm x \<Longrightarrow> 0 < r \<Longrightarrow> norm (inverse x) \<le> inverse r"
 lemma norm_power_ineq: "norm (x ^ n) \<le> norm x ^ n"
   for x :: "'a::complex_normed_algebra_1"
 lemma norm_power: "norm (x ^ n) = norm x ^ n"
   for x :: "'a::complex_normed_div_algebra"
 lemma norm_power_int: "norm (power_int x n) = power_int (norm x) n"
   for x :: "'a::complex_normed_div_algebra"
 lemma power_eq_imp_eq_norm:
   fixes w :: "'a::complex_normed_div_algebra"
   assumes eq: "w ^ n = z ^ n" and "n > 0"
     shows "norm w = norm z"
 lemma power_eq_1_iff:
   fixes w :: "'a::complex_normed_div_algebra"
   shows "w ^ n = 1 \<Longrightarrow> norm w = 1 \<or> n = 0"
 lemma norm_mult_numeral1 [simp]: "norm (numeral w * a) = numeral w * norm a"
   for a b :: "'a::{complex_normed_field,field}"
 lemma norm_mult_numeral2 [simp]: "norm (a * numeral w) = norm a * numeral w"
   for a b :: "'a::{complex_normed_field,field}"
 lemma norm_divide_numeral [simp]: "norm (a / numeral w) = norm a / numeral w"
   for a b :: "'a::{complex_normed_field,field}"
 lemma square_norm_one:
   fixes x :: "'a::complex_normed_div_algebra"
   assumes "x\<^sup>2 = 1"
   shows "norm x = 1"
 lemma norm_less_p1: "norm x < norm (of_real (norm x) + 1 :: 'a)"
   for x :: "'a::complex_normed_algebra_1"
 lemma prod_norm: "prod (\<lambda>x. norm (f x)) A = norm (prod f A)"
   for f :: "'a \<Rightarrow> 'b::{comm_semiring_1,complex_normed_div_algebra}"
 lemma norm_prod_le:
   "norm (prod f A) \<le> (\<Prod>a\<in>A. norm (f a :: 'a :: {complex_normed_algebra_1,comm_monoid_mult}))"
 lemma norm_prod_diff:
   fixes z w :: "'i \<Rightarrow> 'a::{complex_normed_algebra_1, comm_monoid_mult}"
   shows "(\<And>i. i \<in> I \<Longrightarrow> norm (z i) \<le> 1) \<Longrightarrow> (\<And>i. i \<in> I \<Longrightarrow> norm (w i) \<le> 1) \<Longrightarrow>
     norm ((\<Prod>i\<in>I. z i) - (\<Prod>i\<in>I. w i)) \<le> (\<Sum>i\<in>I. norm (z i - w i))"
 lemma norm_power_diff:
   fixes z w :: "'a::{complex_normed_algebra_1, comm_monoid_mult}"
   assumes "norm z \<le> 1" "norm w \<le> 1"
   shows "norm (z^m - w^m) \<le> m * norm (z - w)"
 *)
 
 lemma norm_of_complex_add1 [simp]: "norm (of_complex x + 1 :: 'a :: complex_normed_div_algebra) = cmod (x + 1)"
   by (metis norm_of_complex of_complex_1 of_complex_add)
 
 lemma norm_of_complex_addn [simp]:
   "norm (of_complex x + numeral b :: 'a :: complex_normed_div_algebra) = cmod (x + numeral b)"
   by (metis norm_of_complex of_complex_add of_complex_numeral)
 
 lemma norm_of_complex_diff [simp]:
   "norm (of_complex b - of_complex a :: 'a::complex_normed_algebra_1) \<le> cmod (b - a)"
   by (metis norm_of_complex of_complex_diff order_refl)
 
 subsection \<open>Metric spaces\<close>
 
 (* Class metric_space is already defined in Real_Vector_Spaces and does not need changing here *)
 
 text \<open>Every normed vector space is a metric space.\<close>
 (* Already follows from complex_normed_vector < real_normed_vector < metric_space *)
 (* instance complex_normed_vector < metric_space *)
 
 subsection \<open>Class instances for complex numbers\<close>
 
 instantiation complex :: complex_normed_field
 begin
 
 instance
   apply intro_classes
   by (simp add: norm_mult)
 
 end
 
 declare uniformity_Abort[where 'a=complex, code]
 
 lemma dist_of_complex [simp]: "dist (of_complex x :: 'a) (of_complex y) = dist x y"
   for a :: "'a::complex_normed_div_algebra"
   by (metis dist_norm norm_of_complex of_complex_diff)
 
 declare [[code abort: "open :: complex set \<Rightarrow> bool"]]
 
 (* As far as I can tell, there is no analogue to this for complex:
 instance real :: order_topology
 instance real :: linear_continuum_topology ..
 
 lemmas open_complex_greaterThan = open_greaterThan[where 'a=complex]
 lemmas open_complex_lessThan = open_lessThan[where 'a=complex]
 lemmas open_complex_greaterThanLessThan = open_greaterThanLessThan[where 'a=complex]
 *)
 
 lemma closed_complex_atMost: \<open>closed {..a::complex}\<close>
 proof -
   have \<open>{..a} = Im -` {Im a} \<inter> Re -` {..Re a}\<close>
     by (auto simp: less_eq_complex_def)
   also have \<open>closed \<dots>\<close>
     by (auto intro!: closed_Int closed_vimage continuous_on_Im continuous_on_Re)
   finally show ?thesis
     by -
 qed
 
 lemma closed_complex_atLeast: \<open>closed {a::complex..}\<close>
 proof -
   have \<open>{a..} = Im -` {Im a} \<inter> Re -` {Re a..}\<close>
     by (auto simp: less_eq_complex_def)
   also have \<open>closed \<dots>\<close>
     by (auto intro!: closed_Int closed_vimage continuous_on_Im continuous_on_Re)
   finally show ?thesis
     by -
 qed
 
 lemma closed_complex_atLeastAtMost: \<open>closed {a::complex .. b}\<close>
 proof (cases \<open>Im a = Im b\<close>)
   case True
   have \<open>{a..b} = Im -` {Im a} \<inter> Re -` {Re a..Re b}\<close>
     by (auto simp add: less_eq_complex_def intro!: True)
   also have \<open>closed \<dots>\<close>
     by (auto intro!: closed_Int closed_vimage continuous_on_Im continuous_on_Re)
   finally show ?thesis
     by -
 next
   case False
   then have *: \<open>{a..b} = {}\<close>
     using less_eq_complex_def by auto
   show ?thesis
-    by (simp add: *)  
+    by (simp add: *)
 qed
 
 (* As far as I can tell, there is no analogue to this for complex:
 instance real :: ordered_real_vector
   by standard (auto intro: mult_left_mono mult_right_mono)
 *)
 
 (* subsection \<open>Extra type constraints\<close> *)
 (* Everything is commented out, so we comment out the heading, too. *)
 
 (* These are already configured in Real_Vector_Spaces:
 
 text \<open>Only allow \<^term>\<open>open\<close> in class \<open>topological_space\<close>.\<close>
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>open\<close>, SOME \<^typ>\<open>'a::topological_space set \<Rightarrow> bool\<close>)\<close>
 
 text \<open>Only allow \<^term>\<open>uniformity\<close> in class \<open>uniform_space\<close>.\<close>
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>uniformity\<close>, SOME \<^typ>\<open>('a::uniformity \<times> 'a) filter\<close>)\<close>
 
 text \<open>Only allow \<^term>\<open>dist\<close> in class \<open>metric_space\<close>.\<close>
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>dist\<close>, SOME \<^typ>\<open>'a::metric_space \<Rightarrow> 'a \<Rightarrow> real\<close>)\<close>
 
 text \<open>Only allow \<^term>\<open>norm\<close> in class \<open>complex_normed_vector\<close>.\<close>
 setup \<open>Sign.add_const_constraint
   (\<^const_name>\<open>norm\<close>, SOME \<^typ>\<open>'a::complex_normed_vector \<Rightarrow> real\<close>)\<close>
 *)
 
 subsection \<open>Sign function\<close>
 
-(* Inherited from real_normed_vector: 
+(* Inherited from real_normed_vector:
 lemma norm_sgn: "norm (sgn x) = (if x = 0 then 0 else 1)"
   for x :: "'a::complex_normed_vector"
 lemma sgn_zero [simp]: "sgn (0::'a::complex_normed_vector) = 0"
 lemma sgn_zero_iff: "sgn x = 0 \<longleftrightarrow> x = 0"
   for x :: "'a::complex_normed_vector"
 lemma sgn_minus: "sgn (- x) = - sgn x"
   for x :: "'a::complex_normed_vector"
 lemma sgn_one [simp]: "sgn (1::'a::complex_normed_algebra_1) = 1"
 lemma sgn_mult: "sgn (x * y) = sgn x * sgn y"
   for x y :: "'a::complex_normed_div_algebra"
 hide_fact (open) sgn_mult
 lemma norm_conv_dist: "norm x = dist x 0"
 declare norm_conv_dist [symmetric, simp]
 lemma dist_0_norm [simp]: "dist 0 x = norm x"
   for x :: "'a::complex_normed_vector"
 lemma dist_diff [simp]: "dist a (a - b) = norm b"  "dist (a - b) a = norm b"
 lemma dist_of_int: "dist (of_int m) (of_int n :: 'a :: complex_normed_algebra_1) = of_int \<bar>m - n\<bar>"
 lemma dist_of_nat:
   "dist (of_nat m) (of_nat n :: 'a :: complex_normed_algebra_1) = of_int \<bar>int m - int n\<bar>"
 *)
 
 lemma sgn_scaleC: "sgn (scaleC r x) = scaleC (sgn r) (sgn x)"
   for x :: "'a::complex_normed_vector"
   by (simp add: scaleR_scaleC sgn_div_norm ac_simps)
 
 lemma sgn_of_complex: "sgn (of_complex r :: 'a::complex_normed_algebra_1) = of_complex (sgn r)"
   unfolding of_complex_def by (simp only: sgn_scaleC sgn_one)
 
 lemma complex_sgn_eq: "sgn x = x / \<bar>x\<bar>"
   for x :: complex
   by (simp add: abs_complex_def scaleR_scaleC sgn_div_norm divide_inverse)
 
 lemma czero_le_sgn_iff [simp]: "0 \<le> sgn x \<longleftrightarrow> 0 \<le> x"
   for x :: complex
   using cmod_eq_Re divide_eq_0_iff less_eq_complex_def by auto
 
 lemma csgn_le_0_iff [simp]: "sgn x \<le> 0 \<longleftrightarrow> x \<le> 0"
   for x :: complex
   by (smt (verit, best) czero_le_sgn_iff Im_sgn Re_sgn divide_eq_0_iff dual_order.eq_iff less_eq_complex_def sgn_zero_iff zero_complex.sel(1) zero_complex.sel(2))
 
 
 subsection \<open>Bounded Linear and Bilinear Operators\<close>
 
 lemma clinearI: "clinear f"
   if "\<And>b1 b2. f (b1 + b2) = f b1 + f b2"
     "\<And>r b. f (r *\<^sub>C b) = r *\<^sub>C f b"
   using that
   by unfold_locales (auto simp: algebra_simps)
 
 lemma clinear_iff:
   "clinear f \<longleftrightarrow> (\<forall>x y. f (x + y) = f x + f y) \<and> (\<forall>c x. f (c *\<^sub>C x) = c *\<^sub>C f x)"
   (is "clinear f \<longleftrightarrow> ?rhs")
 proof
   assume "clinear f"
   then interpret f: clinear f .
   show "?rhs"
     by (simp add: f.add f.scale complex_vector.linear_scale f.clinear_axioms)
 next
   assume "?rhs"
   then show "clinear f" by (intro clinearI) auto
 qed
 
 lemmas clinear_scaleC_left = complex_vector.linear_scale_left
 lemmas clinear_imp_scaleC = complex_vector.linear_imp_scale
 
 corollary complex_clinearD:
   fixes f :: "complex \<Rightarrow> complex"
   assumes "clinear f" obtains c where "f = (*) c"
   by (rule clinear_imp_scaleC [OF assms]) (force simp: scaleC_conv_of_complex)
 
 lemma clinear_times_of_complex: "clinear (\<lambda>x. a * of_complex x)"
   by (auto intro!: clinearI simp: distrib_left)
     (metis mult_scaleC_right scaleC_conv_of_complex)
 
 locale bounded_clinear = clinear f for f :: "'a::complex_normed_vector \<Rightarrow> 'b::complex_normed_vector" +
   assumes bounded: "\<exists>K. \<forall>x. norm (f x) \<le> norm x * K"
 begin
 
 (* Not present in Real_Vector_Spaces *)
 lemma bounded_linear: "bounded_linear f"
   apply standard
   by (simp_all add: add scaleC scaleR_scaleC bounded)
 
 lemma pos_bounded: "\<exists>K>0. \<forall>x. norm (f x) \<le> norm x * K"
 proof -
   obtain K where K: "\<And>x. norm (f x) \<le> norm x * K"
     using bounded by blast
   show ?thesis
   proof (intro exI impI conjI allI)
     show "0 < max 1 K"
       by (rule order_less_le_trans [OF zero_less_one max.cobounded1])
   next
     fix x
     have "norm (f x) \<le> norm x * K" using K .
     also have "\<dots> \<le> norm x * max 1 K"
       by (rule mult_left_mono [OF max.cobounded2 norm_ge_zero])
     finally show "norm (f x) \<le> norm x * max 1 K" .
   qed
 qed
 
 (* Inherited from bounded_linear *)
 lemma nonneg_bounded: "\<exists>K\<ge>0. \<forall>x. norm (f x) \<le> norm x * K"
   by (meson less_imp_le pos_bounded)
 
 lemma clinear: "clinear f"
   by (fact local.clinear_axioms)
 
 end
 
 lemma bounded_clinear_intro:
   assumes "\<And>x y. f (x + y) = f x + f y"
     and "\<And>r x. f (scaleC r x) = scaleC r (f x)"
     and "\<And>x. norm (f x) \<le> norm x * K"
   shows "bounded_clinear f"
   by standard (blast intro: assms)+
 
 locale bounded_cbilinear =
   fixes prod :: "'a::complex_normed_vector \<Rightarrow> 'b::complex_normed_vector \<Rightarrow> 'c::complex_normed_vector"
     (infixl "**" 70)
   assumes add_left: "prod (a + a') b = prod a b + prod a' b"
     and add_right: "prod a (b + b') = prod a b + prod a b'"
     and scaleC_left: "prod (scaleC r a) b = scaleC r (prod a b)"
     and scaleC_right: "prod a (scaleC r b) = scaleC r (prod a b)"
     and bounded: "\<exists>K. \<forall>a b. norm (prod a b) \<le> norm a * norm b * K"
 begin
 
 (* Not present in Real_Vector_Spaces *)
 lemma bounded_bilinear[simp]: "bounded_bilinear prod"
   apply standard
   by (auto simp add: add_left add_right scaleR_scaleC scaleC_left scaleC_right bounded)
 
 (* Not present in Real_Vector_Spaces. Has only temporary effect (until "end") *)
 interpretation bounded_bilinear prod
   by simp
 
 lemmas pos_bounded = pos_bounded (* "\<exists>K>0. \<forall>a b. norm (a ** b) \<le> norm a * norm b * K" *)
 lemmas nonneg_bounded = nonneg_bounded (* "\<exists>K\<ge>0. \<forall>a b. norm (a ** b) \<le> norm a * norm b * K" *)
 lemmas additive_right = additive_right (* "additive (\<lambda>b. prod a b)" *)
 lemmas additive_left = additive_left (* "additive (\<lambda>a. prod a b)" *)
 lemmas zero_left = zero_left (* "prod 0 b = 0" *)
 lemmas zero_right = zero_right (* "prod a 0 = 0" *)
 lemmas minus_left = minus_left (* "prod (- a) b = - prod a b" *)
 lemmas minus_right = minus_right (* "prod a (- b) = - prod a b" *)
 lemmas diff_left = diff_left (* "prod (a - a') b = prod a b - prod a' b" *)
 lemmas diff_right = diff_right (* "prod a (b - b') = prod a b - prod a b'" *)
 lemmas sum_left = sum_left (* "prod (sum g S) x = sum ((\<lambda>i. prod (g i) x)) S" *)
 lemmas sum_right = sum_right (* "prod x (sum g S) = sum ((\<lambda>i. (prod x (g i)))) S" *)
 lemmas prod_diff_prod = prod_diff_prod (* "(x ** y - a ** b) = (x - a) ** (y - b) + (x - a) ** b + a ** (y - b)" *)
 
 lemma bounded_clinear_left: "bounded_clinear (\<lambda>a. a ** b)"
 proof -
   obtain K where "\<And>a b. norm (a ** b) \<le> norm a * norm b * K"
     using pos_bounded by blast
   then show ?thesis
     by (rule_tac K="norm b * K" in bounded_clinear_intro) (auto simp: algebra_simps scaleC_left add_left)
 qed
 
 lemma bounded_clinear_right: "bounded_clinear (\<lambda>b. a ** b)"
 proof -
   obtain K where "\<And>a b. norm (a ** b) \<le> norm a * norm b * K"
     using pos_bounded by blast
   then show ?thesis
     by (rule_tac K="norm a * K" in bounded_clinear_intro) (auto simp: algebra_simps scaleC_right add_right)
 qed
 
 lemma flip: "bounded_cbilinear (\<lambda>x y. y ** x)"
 proof
   show "\<exists>K. \<forall>a b. norm (b ** a) \<le> norm a * norm b * K"
     by (metis bounded mult.commute)
 qed (simp_all add: add_right add_left scaleC_right scaleC_left)
 
 lemma comp1:
   assumes "bounded_clinear g"
   shows "bounded_cbilinear (\<lambda>x. (**) (g x))"
 proof
   interpret g: bounded_clinear g by fact
   show "\<And>a a' b. g (a + a') ** b = g a ** b + g a' ** b"
     "\<And>a b b'. g a ** (b + b') = g a ** b + g a ** b'"
     "\<And>r a b. g (r *\<^sub>C a) ** b = r *\<^sub>C (g a ** b)"
     "\<And>a r b. g a ** (r *\<^sub>C b) = r *\<^sub>C (g a ** b)"
     by (auto simp: g.add add_left add_right g.scaleC scaleC_left scaleC_right)
   have "bounded_bilinear (\<lambda>a b. g a ** b)"
     using g.bounded_linear by (rule comp1)
   then show "\<exists>K. \<forall>a b. norm (g a ** b) \<le> norm a * norm b * K"
     by (rule bounded_bilinear.bounded)
 qed
 
 lemma comp: "bounded_clinear f \<Longrightarrow> bounded_clinear g \<Longrightarrow> bounded_cbilinear (\<lambda>x y. f x ** g y)"
   by (rule bounded_cbilinear.flip[OF bounded_cbilinear.comp1[OF bounded_cbilinear.flip[OF comp1]]])
 
 end (* locale bounded_cbilinear *)
 
 lemma bounded_clinear_ident[simp]: "bounded_clinear (\<lambda>x. x)"
   by standard (auto intro!: exI[of _ 1])
 
 lemma bounded_clinear_zero[simp]: "bounded_clinear (\<lambda>x. 0)"
   by standard (auto intro!: exI[of _ 1])
 
 lemma bounded_clinear_add:
   assumes "bounded_clinear f"
     and "bounded_clinear g"
   shows "bounded_clinear (\<lambda>x. f x + g x)"
 proof -
   interpret f: bounded_clinear f by fact
   interpret g: bounded_clinear g by fact
   show ?thesis
   proof
     from f.bounded obtain Kf where Kf: "norm (f x) \<le> norm x * Kf" for x
       by blast
     from g.bounded obtain Kg where Kg: "norm (g x) \<le> norm x * Kg" for x
       by blast
     show "\<exists>K. \<forall>x. norm (f x + g x) \<le> norm x * K"
       using add_mono[OF Kf Kg]
       by (intro exI[of _ "Kf + Kg"]) (auto simp: field_simps intro: norm_triangle_ineq order_trans)
   qed (simp_all add: f.add g.add f.scaleC g.scaleC scaleC_add_right)
 qed
 
 lemma bounded_clinear_minus:
   assumes "bounded_clinear f"
   shows "bounded_clinear (\<lambda>x. - f x)"
 proof -
   interpret f: bounded_clinear f by fact
   show ?thesis
     by unfold_locales (simp_all add: f.add f.scaleC f.bounded)
 qed
 
 lemma bounded_clinear_sub: "bounded_clinear f \<Longrightarrow> bounded_clinear g \<Longrightarrow> bounded_clinear (\<lambda>x. f x - g x)"
   using bounded_clinear_add[of f "\<lambda>x. - g x"] bounded_clinear_minus[of g]
   by (auto simp: algebra_simps)
 
 lemma bounded_clinear_sum:
   fixes f :: "'i \<Rightarrow> 'a::complex_normed_vector \<Rightarrow> 'b::complex_normed_vector"
   shows "(\<And>i. i \<in> I \<Longrightarrow> bounded_clinear (f i)) \<Longrightarrow> bounded_clinear (\<lambda>x. \<Sum>i\<in>I. f i x)"
   by (induct I rule: infinite_finite_induct) (auto intro!: bounded_clinear_add)
 
 lemma bounded_clinear_compose:
   assumes "bounded_clinear f"
     and "bounded_clinear g"
   shows "bounded_clinear (\<lambda>x. f (g x))"
 proof
   interpret f: bounded_clinear f by fact
   interpret g: bounded_clinear g by fact
   show "f (g (x + y)) = f (g x) + f (g y)" for x y
     by (simp only: f.add g.add)
   show "f (g (scaleC r x)) = scaleC r (f (g x))" for r x
     by (simp only: f.scaleC g.scaleC)
   from f.pos_bounded obtain Kf where f: "\<And>x. norm (f x) \<le> norm x * Kf" and Kf: "0 < Kf"
     by blast
   from g.pos_bounded obtain Kg where g: "\<And>x. norm (g x) \<le> norm x * Kg"
     by blast
   show "\<exists>K. \<forall>x. norm (f (g x)) \<le> norm x * K"
   proof (intro exI allI)
     fix x
     have "norm (f (g x)) \<le> norm (g x) * Kf"
       using f .
     also have "\<dots> \<le> (norm x * Kg) * Kf"
       using g Kf [THEN order_less_imp_le] by (rule mult_right_mono)
     also have "(norm x * Kg) * Kf = norm x * (Kg * Kf)"
       by (rule mult.assoc)
     finally show "norm (f (g x)) \<le> norm x * (Kg * Kf)" .
   qed
 qed
 
 lemma bounded_cbilinear_mult: "bounded_cbilinear ((*) :: 'a \<Rightarrow> 'a \<Rightarrow> 'a::complex_normed_algebra)"
 proof (rule bounded_cbilinear.intro)
   show "\<exists>K. \<forall>a b::'a. norm (a * b) \<le> norm a * norm b * K"
     by (rule_tac x=1 in exI) (simp add: norm_mult_ineq)
 qed (auto simp: algebra_simps)
 
 lemma bounded_clinear_mult_left: "bounded_clinear (\<lambda>x::'a::complex_normed_algebra. x * y)"
   using bounded_cbilinear_mult
   by (rule bounded_cbilinear.bounded_clinear_left)
 
 lemma bounded_clinear_mult_right: "bounded_clinear (\<lambda>y::'a::complex_normed_algebra. x * y)"
   using bounded_cbilinear_mult
   by (rule bounded_cbilinear.bounded_clinear_right)
 
 lemmas bounded_clinear_mult_const =
   bounded_clinear_mult_left [THEN bounded_clinear_compose]
 
 lemmas bounded_clinear_const_mult =
   bounded_clinear_mult_right [THEN bounded_clinear_compose]
 
 lemma bounded_clinear_divide: "bounded_clinear (\<lambda>x. x / y)"
   for y :: "'a::complex_normed_field"
   unfolding divide_inverse by (rule bounded_clinear_mult_left)
 
 lemma bounded_cbilinear_scaleC: "bounded_cbilinear scaleC"
 proof (rule bounded_cbilinear.intro)
   obtain K where K: \<open>\<forall>a (b::'a). norm b \<le> norm b * K\<close>
     using less_eq_real_def by auto
   show "\<exists>K. \<forall>a (b::'a). norm (a *\<^sub>C b) \<le> norm a * norm b * K"
     apply (rule exI[where x=K]) using K
     by (metis norm_scaleC)
 qed (auto simp: algebra_simps)
 
 lemma bounded_clinear_scaleC_left: "bounded_clinear (\<lambda>c. scaleC c x)"
   using bounded_cbilinear_scaleC
   by (rule bounded_cbilinear.bounded_clinear_left)
 
 lemma bounded_clinear_scaleC_right: "bounded_clinear (\<lambda>x. scaleC c x)"
   using bounded_cbilinear_scaleC
   by (rule bounded_cbilinear.bounded_clinear_right)
 
 lemmas bounded_clinear_scaleC_const =
   bounded_clinear_scaleC_left[THEN bounded_clinear_compose]
 
 lemmas bounded_clinear_const_scaleC =
   bounded_clinear_scaleC_right[THEN bounded_clinear_compose]
 
 lemma bounded_clinear_of_complex: "bounded_clinear (\<lambda>r. of_complex r)"
   unfolding of_complex_def by (rule bounded_clinear_scaleC_left)
 
 lemma complex_bounded_clinear: "bounded_clinear f \<longleftrightarrow> (\<exists>c::complex. f = (\<lambda>x. x * c))"
   for f :: "complex \<Rightarrow> complex"
 proof -
   {
     fix x
     assume "bounded_clinear f"
     then interpret bounded_clinear f .
     from scaleC[of x 1] have "f x = x * f 1"
       by simp
   }
   then show ?thesis
     by (auto intro: exI[of _ "f 1"] bounded_clinear_mult_left)
 qed
 
 (* Inherited from real_normed_algebra_1 *)
 (* instance complex_normed_algebra_1 \<subseteq> perfect_space *)
 
 (* subsection \<open>Filters and Limits on Metric Space\<close> *)
 (* Everything is commented out, so we comment out the heading, too. *)
 
 (* Not specific to real/complex *)
 (* lemma (in metric_space) nhds_metric: "nhds x = (INF e\<in>{0 <..}. principal {y. dist y x < e})" *)
 (* lemma (in metric_space) tendsto_iff: "(f \<longlongrightarrow> l) F \<longleftrightarrow> (\<forall>e>0. eventually (\<lambda>x. dist (f x) l < e) F)" *)
 (* lemma tendsto_dist_iff: "((f \<longlongrightarrow> l) F) \<longleftrightarrow> (((\<lambda>x. dist (f x) l) \<longlongrightarrow> 0) F)" *)
 (* lemma (in metric_space) tendstoI [intro?]:
   "(\<And>e. 0 < e \<Longrightarrow> eventually (\<lambda>x. dist (f x) l < e) F) \<Longrightarrow> (f \<longlongrightarrow> l) F" *)
 (* lemma (in metric_space) tendstoD: "(f \<longlongrightarrow> l) F \<Longrightarrow> 0 < e \<Longrightarrow> eventually (\<lambda>x. dist (f x) l < e) F" *)
 (* lemma (in metric_space) eventually_nhds_metric:
   "eventually P (nhds a) \<longleftrightarrow> (\<exists>d>0. \<forall>x. dist x a < d \<longrightarrow> P x)" *)
 (* lemma eventually_at: "eventually P (at a within S) \<longleftrightarrow> (\<exists>d>0. \<forall>x\<in>S. x \<noteq> a \<and> dist x a < d \<longrightarrow> P x)"
   for a :: "'a :: metric_space" *)
 (* lemma frequently_at: "frequently P (at a within S) \<longleftrightarrow> (\<forall>d>0. \<exists>x\<in>S. x \<noteq> a \<and> dist x a < d \<and> P x)"
   for a :: "'a :: metric_space" *)
 (* lemma eventually_at_le: "eventually P (at a within S) \<longleftrightarrow> (\<exists>d>0. \<forall>x\<in>S. x \<noteq> a \<and> dist x a \<le> d \<longrightarrow> P x)"
   for a :: "'a::metric_space" *)
 
 (* Does not work in complex case because it needs complex :: order_toplogy *)
 (* lemma eventually_at_left_real: "a > (b :: real) \<Longrightarrow> eventually (\<lambda>x. x \<in> {b<..<a}) (at_left a)" *)
 (* lemma eventually_at_right_real: "a < (b :: real) \<Longrightarrow> eventually (\<lambda>x. x \<in> {a<..<b}) (at_right a)" *)
 
 (* Not specific to real/complex *)
 (* lemma metric_tendsto_imp_tendsto:
   fixes a :: "'a :: metric_space"
     and b :: "'b :: metric_space"
   assumes f: "(f \<longlongrightarrow> a) F"
     and le: "eventually (\<lambda>x. dist (g x) b \<le> dist (f x) a) F"
   shows "(g \<longlongrightarrow> b) F" *)
 
 (* Not sure if this makes sense in the complex case *)
 (* lemma filterlim_complex_sequentially: "LIM x sequentially. (of_nat x :: complex) :> at_top" *)
 
 (* Not specific to real/complex *)
 (* lemma filterlim_nat_sequentially: "filterlim nat sequentially at_top" *)
 (* lemma filterlim_floor_sequentially: "filterlim floor at_top at_top" *)
 
 (* Not sure if this makes sense in the complex case *)
 (* lemma filterlim_sequentially_iff_filterlim_real:
   "filterlim f sequentially F \<longleftrightarrow> filterlim (\<lambda>x. real (f x)) at_top F" (is "?lhs = ?rhs") *)
 
 
 subsubsection \<open>Limits of Sequences\<close>
 
 (* Not specific to real/complex *)
 (* lemma lim_sequentially: "X \<longlonglongrightarrow> L \<longleftrightarrow> (\<forall>r>0. \<exists>no. \<forall>n\<ge>no. dist (X n) L < r)"
   for L :: "'a::metric_space" *)
 (* lemmas LIMSEQ_def = lim_sequentially  (*legacy binding*) *)
 (* lemma LIMSEQ_iff_nz: "X \<longlonglongrightarrow> L \<longleftrightarrow> (\<forall>r>0. \<exists>no>0. \<forall>n\<ge>no. dist (X n) L < r)"
   for L :: "'a::metric_space" *)
 (* lemma metric_LIMSEQ_I: "(\<And>r. 0 < r \<Longrightarrow> \<exists>no. \<forall>n\<ge>no. dist (X n) L < r) \<Longrightarrow> X \<longlonglongrightarrow> L"
   for L :: "'a::metric_space" *)
 (* lemma metric_LIMSEQ_D: "X \<longlonglongrightarrow> L \<Longrightarrow> 0 < r \<Longrightarrow> \<exists>no. \<forall>n\<ge>no. dist (X n) L < r"
   for L :: "'a::metric_space" *)
 (* lemma LIMSEQ_norm_0:
   assumes  "\<And>n::nat. norm (f n) < 1 / real (Suc n)"
   shows "f \<longlonglongrightarrow> 0" *)
 
 (* subsubsection \<open>Limits of Functions\<close> *)
 (* Everything is commented out, so we comment out the heading, too. *)
 
 (* Not specific to real/complex *)
 (* lemma LIM_def: "f \<midarrow>a\<rightarrow> L \<longleftrightarrow> (\<forall>r > 0. \<exists>s > 0. \<forall>x. x \<noteq> a \<and> dist x a < s \<longrightarrow> dist (f x) L < r)"
   for a :: "'a::metric_space" and L :: "'b::metric_space" *)
 (* lemma metric_LIM_I:
   "(\<And>r. 0 < r \<Longrightarrow> \<exists>s>0. \<forall>x. x \<noteq> a \<and> dist x a < s \<longrightarrow> dist (f x) L < r) \<Longrightarrow> f \<midarrow>a\<rightarrow> L"
   for a :: "'a::metric_space" and L :: "'b::metric_space" *)
 (* lemma metric_LIM_D: "f \<midarrow>a\<rightarrow> L \<Longrightarrow> 0 < r \<Longrightarrow> \<exists>s>0. \<forall>x. x \<noteq> a \<and> dist x a < s \<longrightarrow> dist (f x) L < r"
   for a :: "'a::metric_space" and L :: "'b::metric_space" *)
 (* lemma metric_LIM_imp_LIM:
   fixes l :: "'a::metric_space"
     and m :: "'b::metric_space"
   assumes f: "f \<midarrow>a\<rightarrow> l"
     and le: "\<And>x. x \<noteq> a \<Longrightarrow> dist (g x) m \<le> dist (f x) l"
   shows "g \<midarrow>a\<rightarrow> m" *)
 (* lemma metric_LIM_equal2:
   fixes a :: "'a::metric_space"
   assumes "g \<midarrow>a\<rightarrow> l" "0 < R"
     and "\<And>x. x \<noteq> a \<Longrightarrow> dist x a < R \<Longrightarrow> f x = g x"
   shows "f \<midarrow>a\<rightarrow> l" *)
 (* lemma metric_LIM_compose2:
   fixes a :: "'a::metric_space"
   assumes f: "f \<midarrow>a\<rightarrow> b"
     and g: "g \<midarrow>b\<rightarrow> c"
     and inj: "\<exists>d>0. \<forall>x. x \<noteq> a \<and> dist x a < d \<longrightarrow> f x \<noteq> b"
   shows "(\<lambda>x. g (f x)) \<midarrow>a\<rightarrow> c" *)
 (* lemma metric_isCont_LIM_compose2:
   fixes f :: "'a :: metric_space \<Rightarrow> _"
   assumes f [unfolded isCont_def]: "isCont f a"
     and g: "g \<midarrow>f a\<rightarrow> l"
     and inj: "\<exists>d>0. \<forall>x. x \<noteq> a \<and> dist x a < d \<longrightarrow> f x \<noteq> f a"
   shows "(\<lambda>x. g (f x)) \<midarrow>a\<rightarrow> l" *)
 
 
 (* subsection \<open>Complete metric spaces\<close> *)
 (* Everything is commented out, so we comment out the heading, too. *)
 
 subsection \<open>Cauchy sequences\<close>
 
 (* Not specific to real/complex *)
 (* lemma (in metric_space) Cauchy_def: "Cauchy X = (\<forall>e>0. \<exists>M. \<forall>m\<ge>M. \<forall>n\<ge>M. dist (X m) (X n) < e)" *)
 (* lemma (in metric_space) Cauchy_altdef: "Cauchy f \<longleftrightarrow> (\<forall>e>0. \<exists>M. \<forall>m\<ge>M. \<forall>n>m. dist (f m) (f n) < e)" *)
 (* lemma (in metric_space) Cauchy_altdef2: "Cauchy s \<longleftrightarrow> (\<forall>e>0. \<exists>N::nat. \<forall>n\<ge>N. dist(s n)(s N) < e)" (is "?lhs = ?rhs") *)
 (* lemma (in metric_space) metric_CauchyI:
   "(\<And>e. 0 < e \<Longrightarrow> \<exists>M. \<forall>m\<ge>M. \<forall>n\<ge>M. dist (X m) (X n) < e) \<Longrightarrow> Cauchy X" *)
 (* lemma (in metric_space) CauchyI':
   "(\<And>e. 0 < e \<Longrightarrow> \<exists>M. \<forall>m\<ge>M. \<forall>n>m. dist (X m) (X n) < e) \<Longrightarrow> Cauchy X" *)
 (* lemma (in metric_space) metric_CauchyD:
   "Cauchy X \<Longrightarrow> 0 < e \<Longrightarrow> \<exists>M. \<forall>m\<ge>M. \<forall>n\<ge>M. dist (X m) (X n) < e" *)
 (* lemma (in metric_space) metric_Cauchy_iff2:
   "Cauchy X = (\<forall>j. (\<exists>M. \<forall>m \<ge> M. \<forall>n \<ge> M. dist (X m) (X n) < inverse(real (Suc j))))" *)
 
 lemma cCauchy_iff2: "Cauchy X \<longleftrightarrow> (\<forall>j. (\<exists>M. \<forall>m \<ge> M. \<forall>n \<ge> M. cmod (X m - X n) < inverse (real (Suc j))))"
   by (simp only: metric_Cauchy_iff2 dist_complex_def)
 
 (* Not specific to real/complex *)
 (* lemma lim_1_over_n [tendsto_intros]: "((\<lambda>n. 1 / of_nat n) \<longlongrightarrow> (0::'a::complex_normed_field)) sequentially" *)
 (* lemma (in metric_space) complete_def:
   shows "complete S = (\<forall>f. (\<forall>n. f n \<in> S) \<and> Cauchy f \<longrightarrow> (\<exists>l\<in>S. f \<longlonglongrightarrow> l))" *)
 (* lemma (in metric_space) totally_bounded_metric:
   "totally_bounded S \<longleftrightarrow> (\<forall>e>0. \<exists>k. finite k \<and> S \<subseteq> (\<Union>x\<in>k. {y. dist x y < e}))" *)
 
 (* subsubsection \<open>Cauchy Sequences are Convergent\<close> *)
 (* Everything is commented out, so we comment out the heading, too. *)
 
 (* Not specific to real/complex *)
 (* class complete_space *)
 (* lemma Cauchy_convergent_iff: "Cauchy X \<longleftrightarrow> convergent X"
   for X :: "nat \<Rightarrow> 'a::complete_space" *)
 
 (* text \<open>To prove that a Cauchy sequence converges, it suffices to show that a subsequence converges.\<close> *)
 
 (* Not specific to real/complex *)
 (* lemma Cauchy_converges_subseq:
   fixes u::"nat \<Rightarrow> 'a::metric_space"
   assumes "Cauchy u"
     "strict_mono r"
     "(u \<circ> r) \<longlonglongrightarrow> l"
   shows "u \<longlonglongrightarrow> l" *)
 
 subsection \<open>The set of real numbers is a complete metric space\<close>
 
 text \<open>
   Proof that Cauchy sequences converge based on the one from
   \<^url>\<open>http://pirate.shu.edu/~wachsmut/ira/numseq/proofs/cauconv.html\<close>
 \<close>
 
 text \<open>
   If sequence \<^term>\<open>X\<close> is Cauchy, then its limit is the lub of
   \<^term>\<open>{r::real. \<exists>N. \<forall>n\<ge>N. r < X n}\<close>
 \<close>
 
 lemma complex_increasing_LIMSEQ:
   fixes f :: "nat \<Rightarrow> complex"
   assumes inc: "\<And>n. f n \<le> f (Suc n)"
     and bdd: "\<And>n. f n \<le> l"
     and en: "\<And>e. 0 < e \<Longrightarrow> \<exists>n. l \<le> f n + e"
   shows "f \<longlonglongrightarrow> l"
 proof -
   have \<open>(\<lambda>n. Re (f n)) \<longlonglongrightarrow> Re l\<close>
     apply (rule increasing_LIMSEQ)
     using assms apply (auto simp: less_eq_complex_def less_complex_def)
     by (metis Im_complex_of_real Re_complex_of_real)
   moreover have \<open>Im (f n) = Im l\<close> for n
     using bdd by (auto simp: less_eq_complex_def)
   then have \<open>(\<lambda>n. Im (f n)) \<longlonglongrightarrow> Im l\<close>
     by auto
   ultimately show \<open>f \<longlonglongrightarrow> l\<close>
     by (simp add: tendsto_complex_iff)
 qed
 
 lemma complex_Cauchy_convergent:
   fixes X :: "nat \<Rightarrow> complex"
   assumes X: "Cauchy X"
   shows "convergent X"
   using assms by (rule Cauchy_convergent)
 
 instance complex :: complete_space
   by intro_classes (rule complex_Cauchy_convergent)
 
 class cbanach = complex_normed_vector + complete_space
 
 (* Not present in Real_Vector_Spaces *)
 subclass (in cbanach) banach ..
 
 instance complex :: banach ..
 
 (* Don't know if this holds in the complex case *)
 (* lemma tendsto_at_topI_sequentially:
   fixes f :: "complex \<Rightarrow> 'b::first_countable_topology"
   assumes *: "\<And>X. filterlim X at_top sequentially \<Longrightarrow> (\<lambda>n. f (X n)) \<longlonglongrightarrow> y"
   shows "(f \<longlongrightarrow> y) at_top" *)
 (* lemma tendsto_at_topI_sequentially_real:
   fixes f :: "real \<Rightarrow> real"
   assumes mono: "mono f"
     and limseq: "(\<lambda>n. f (real n)) \<longlonglongrightarrow> y"
   shows "(f \<longlongrightarrow> y) at_top" *)
 
 end
diff --git a/thys/Complex_Bounded_Operators/ROOT b/thys/Complex_Bounded_Operators/ROOT
--- a/thys/Complex_Bounded_Operators/ROOT
+++ b/thys/Complex_Bounded_Operators/ROOT
@@ -1,18 +1,19 @@
 chapter AFP
 
 session Complex_Bounded_Operators(AFP) = "HOL-Analysis" +
   options [timeout = 1200]
-  sessions 
-    "HOL-Types_To_Sets" 
-    Jordan_Normal_Form 
+  sessions
+    "HOL-Examples"
+    "HOL-Types_To_Sets"
+    Jordan_Normal_Form
     Banach_Steinhaus
     Real_Impl
-  directories 
+  directories
     extra
   theories
     Complex_L2
     Cblinfun_Code
     Cblinfun_Code_Examples
-  document_files 
+  document_files
     root.tex
     root.bib
diff --git a/thys/Complex_Bounded_Operators/extra/Extra_Infinite_Set_Sum.thy b/thys/Complex_Bounded_Operators/extra/Extra_Infinite_Set_Sum.thy
--- a/thys/Complex_Bounded_Operators/extra/Extra_Infinite_Set_Sum.thy
+++ b/thys/Complex_Bounded_Operators/extra/Extra_Infinite_Set_Sum.thy
@@ -1,2284 +1,2283 @@
 theory Extra_Infinite_Set_Sum
   imports "HOL-Analysis.Infinite_Set_Sum"
     Jordan_Normal_Form.Conjugate
     \<comment> \<open>\<^theory>\<open>Jordan_Normal_Form.Conjugate\<close> contains the instantiation \<open>complex :: ord\<close>.
                If we define our own instantiation, it would be impossible to load both
                \<^session>\<open>Jordan_Normal_Form\<close> and this theory.\<close>
 
     Extra_General
 begin
 
 
 subsection\<open>Infinite Set Sum Missing\<close>
 
 definition infsetsum'_converges :: "('a \<Rightarrow> 'b::{comm_monoid_add,t2_space}) \<Rightarrow> 'a set \<Rightarrow> bool" where
   "infsetsum'_converges f A = (\<exists>x. (sum f \<longlongrightarrow> x) (finite_subsets_at_top A))"
 
 definition infsetsum' :: "('a \<Rightarrow> 'b::{comm_monoid_add,t2_space}) \<Rightarrow> 'a set \<Rightarrow> 'b" where
   "infsetsum' f A = (if infsetsum'_converges f A then Lim (finite_subsets_at_top A) (sum f) else 0)"
 
 
-lemma infsetsum'_converges_cong: 
+lemma infsetsum'_converges_cong:
   assumes t1: "\<And>x. x\<in>A \<Longrightarrow> f x = g x"
   shows "infsetsum'_converges f A = infsetsum'_converges g A"
 proof-
   have "sum f X = sum g X"
     if "finite X" and "X \<subseteq> A"
     for X
-    by (meson Finite_Cartesian_Product.sum_cong_aux subsetD t1 that(2))    
+    by (meson Finite_Cartesian_Product.sum_cong_aux subsetD t1 that(2))
   hence "\<forall>\<^sub>F x in finite_subsets_at_top A. sum f x = sum g x"
     by (simp add: eventually_finite_subsets_at_top_weakI)
   hence  "(sum f \<longlongrightarrow> x) (finite_subsets_at_top A) =
          (sum g \<longlongrightarrow> x) (finite_subsets_at_top A)"
     for x
     by (simp add: filterlim_cong)
   thus ?thesis
     by (simp add: infsetsum'_converges_def)
 qed
 
 lemma infsetsum'_cong:
   assumes "\<And>x. x\<in>A \<Longrightarrow> f x = g x"
   shows "infsetsum' f A = infsetsum' g A"
 proof-
   have "sum f X = sum g X"
     if "finite X" and "X \<subseteq> A"
     for X
-    by (meson Finite_Cartesian_Product.sum_cong_aux assms in_mono that(2))    
+    by (meson Finite_Cartesian_Product.sum_cong_aux assms in_mono that(2))
   hence "\<forall>\<^sub>F x in finite_subsets_at_top A. sum f x = sum g x"
     by (rule eventually_finite_subsets_at_top_weakI)
-  hence "(sum f \<longlongrightarrow> x) (finite_subsets_at_top A) \<longleftrightarrow> (sum g \<longlongrightarrow> x) (finite_subsets_at_top A)" 
+  hence "(sum f \<longlongrightarrow> x) (finite_subsets_at_top A) \<longleftrightarrow> (sum g \<longlongrightarrow> x) (finite_subsets_at_top A)"
     for x
     by (rule tendsto_cong)
   hence "Lim (finite_subsets_at_top A) (sum f) = Lim (finite_subsets_at_top A) (sum g)"
     unfolding Topological_Spaces.Lim_def[abs_def]
     by auto
   thus ?thesis
     unfolding infsetsum'_def
     using assms infsetsum'_converges_cong by auto
 qed
 
 lemma abs_summable_finiteI0:
   assumes "\<And>F. finite F \<Longrightarrow> F\<subseteq>S \<Longrightarrow> sum (\<lambda>x. norm (f x)) F \<le> B"
     and "B \<ge> 0"
   shows "f abs_summable_on S" and "infsetsum (\<lambda>x. norm (f x)) S \<le> B"
 proof-
   have t1: "f abs_summable_on S \<and> infsetsum (\<lambda>x. norm (f x)) S \<le> B"
   proof(cases "S = {}")
     case True
     thus ?thesis
-      by (simp add: assms(2)) 
+      by (simp add: assms(2))
   next
     case False
     define M normf where "M = count_space S" and "normf x = ennreal (norm (f x))" for x
     have "sum normf F \<le> ennreal B"
       if "finite F" and "F \<subseteq> S" and
         "\<And>F. finite F \<Longrightarrow> F \<subseteq> S \<Longrightarrow> (\<Sum>i\<in>F. ennreal (norm (f i))) \<le> ennreal B" and
         "ennreal 0 \<le> ennreal B"
       for F
-      using that unfolding normf_def[symmetric] by simp    
+      using that unfolding normf_def[symmetric] by simp
     hence normf_B: "finite F \<Longrightarrow> F\<subseteq>S \<Longrightarrow> sum normf F \<le> ennreal B" for F
-      using assms[THEN ennreal_leI] 
+      using assms[THEN ennreal_leI]
       by auto
-    have "integral\<^sup>S M g \<le> B" if "simple_function M g" and "g \<le> normf" for g 
+    have "integral\<^sup>S M g \<le> B" if "simple_function M g" and "g \<le> normf" for g
     proof -
       define gS where "gS = g ` S"
       have "finite gS"
         using that unfolding gS_def M_def simple_function_count_space by simp
       have "gS \<noteq> {}" unfolding gS_def False
-        by (simp add: False) 
+        by (simp add: False)
       define part where "part r = g -` {r} \<inter> S" for r
-      have r_finite: "r < \<infinity>" if "r : gS" for r 
+      have r_finite: "r < \<infinity>" if "r : gS" for r
         using \<open>g \<le> normf\<close> that unfolding gS_def le_fun_def normf_def apply auto
         using ennreal_less_top neq_top_trans top.not_eq_extremum by blast
       define B' where "B' r = (SUP F\<in>{F. finite F \<and> F\<subseteq>part r}. sum normf F)" for r
       have B'fin: "B' r < \<infinity>" for r
       proof -
         have "B' r \<le> (SUP F\<in>{F. finite F \<and> F\<subseteq>part r}. sum normf F)"
           unfolding B'_def
           by (metis (mono_tags, lifting) SUP_least SUP_upper)
         also have "\<dots> \<le> B"
           using normf_B unfolding part_def
           by (metis (no_types, lifting) Int_subset_iff SUP_least mem_Collect_eq)
         also have "\<dots> < \<infinity>"
           by simp
         finally show ?thesis by simp
       qed
       have sumB': "sum B' gS \<le> ennreal B + \<epsilon>" if "\<epsilon>>0" for \<epsilon>
       proof -
         define N \<epsilon>N where "N = card gS" and "\<epsilon>N = \<epsilon> / N"
-        have "N > 0" 
+        have "N > 0"
           unfolding N_def using \<open>gS\<noteq>{}\<close> \<open>finite gS\<close>
           by (simp add: card_gt_0_iff)
         from \<epsilon>N_def that have "\<epsilon>N > 0"
           by (simp add: ennreal_of_nat_eq_real_of_nat ennreal_zero_less_divide)
         have c1: "\<exists>y. B' r \<le> sum normf y + \<epsilon>N \<and>
              finite y \<and> y \<subseteq> part r"
           if "B' r = 0"
           for r
           using that by auto
         have c2: "\<exists>y. B' r \<le> sum normf y + \<epsilon>N \<and>
              finite y \<and> y \<subseteq> part r"
           if "B' r \<noteq> 0"
           for r
         proof-
           have "B' r - \<epsilon>N < B' r"
             using B'fin \<open>0 < \<epsilon>N\<close> ennreal_between that by fastforce
           have "B' r - \<epsilon>N < Sup (sum normf ` {F. finite F \<and> F \<subseteq> part r}) \<Longrightarrow>
                \<exists>F. B' r - \<epsilon>N \<le> sum normf F \<and> finite F \<and> F \<subseteq> part r"
             by (metis (no_types, lifting) leD le_cases less_SUP_iff mem_Collect_eq)
           hence "B' r - \<epsilon>N < B' r \<Longrightarrow>
                 \<exists>F. B' r - \<epsilon>N \<le> sum normf F \<and>
                 finite F \<and> F \<subseteq> part r"
             by (subst (asm) (2) B'_def)
           then obtain F where "B' r - \<epsilon>N \<le> sum normf F" and "finite F" and "F \<subseteq> part r"
-            using \<open>B' r - \<epsilon>N < B' r\<close> by auto  
+            using \<open>B' r - \<epsilon>N < B' r\<close> by auto
           thus "\<exists>F. B' r \<le> sum normf F + \<epsilon>N \<and> finite F \<and> F \<subseteq> part r"
             by (metis add.commute ennreal_minus_le_iff)
         qed
         have "\<forall>x. \<exists>y. B' x \<le> sum normf y + \<epsilon>N \<and>
             finite y \<and> y \<subseteq> part x"
           using c1 c2
-          by blast 
+          by blast
         hence "\<exists>F. \<forall>x. B' x \<le> sum normf (F x) + \<epsilon>N \<and> finite (F x) \<and> F x \<subseteq> part x"
-          by metis 
+          by metis
         then obtain F where F: "sum normf (F r) + \<epsilon>N \<ge> B' r" and Ffin: "finite (F r)" and Fpartr: "F r \<subseteq> part r" for r
           using atomize_elim by auto
         have w1: "finite gS"
-          by (simp add: \<open>finite gS\<close>)          
+          by (simp add: \<open>finite gS\<close>)
         have w2: "\<forall>i\<in>gS. finite (F i)"
-          by (simp add: Ffin)          
+          by (simp add: Ffin)
         have False
           if "\<And>r. F r \<subseteq> g -` {r} \<and> F r \<subseteq> S"
             and "i \<in> gS" and "j \<in> gS" and "i \<noteq> j" and "x \<in> F i" and "x \<in> F j"
           for i j x
-          by (metis subsetD that(1) that(4) that(5) that(6) vimage_singleton_eq)          
+          by (metis subsetD that(1) that(4) that(5) that(6) vimage_singleton_eq)
         hence w3: "\<forall>i\<in>gS. \<forall>j\<in>gS. i \<noteq> j \<longrightarrow> F i \<inter> F j = {}"
-          using Fpartr[unfolded part_def] by auto          
+          using Fpartr[unfolded part_def] by auto
         have w4: "sum normf (\<Union> (F ` gS)) + \<epsilon> = sum normf (\<Union> (F ` gS)) + \<epsilon>"
           by simp
         have "sum B' gS \<le> (\<Sum>r\<in>gS. sum normf (F r) + \<epsilon>N)"
           using F by (simp add: sum_mono)
         also have "\<dots> = (\<Sum>r\<in>gS. sum normf (F r)) + (\<Sum>r\<in>gS. \<epsilon>N)"
           by (simp add: sum.distrib)
         also have "\<dots> = (\<Sum>r\<in>gS. sum normf (F r)) + (card gS * \<epsilon>N)"
           by auto
         also have "\<dots> = (\<Sum>r\<in>gS. sum normf (F r)) + \<epsilon>"
-          unfolding \<epsilon>N_def N_def[symmetric] using \<open>N>0\<close> 
+          unfolding \<epsilon>N_def N_def[symmetric] using \<open>N>0\<close>
           by (simp add: ennreal_times_divide mult.commute mult_divide_eq_ennreal)
-        also have "\<dots> = sum normf (\<Union> (F ` gS)) + \<epsilon>" 
+        also have "\<dots> = sum normf (\<Union> (F ` gS)) + \<epsilon>"
           using w1 w2 w3 w4
           by (subst sum.UNION_disjoint[symmetric])
         also have "\<dots> \<le> B + \<epsilon>"
           using \<open>finite gS\<close> normf_B add_right_mono Ffin Fpartr unfolding part_def
-          by (simp add: \<open>gS \<noteq> {}\<close> cSUP_least)          
+          by (simp add: \<open>gS \<noteq> {}\<close> cSUP_least)
         finally show ?thesis
           by auto
       qed
       hence sumB': "sum B' gS \<le> B"
         using ennreal_le_epsilon ennreal_less_zero_iff by blast
       have "\<forall>r. \<exists>y. r \<in> gS \<longrightarrow> B' r = ennreal y"
         using B'fin less_top_ennreal by auto
       hence "\<exists>B''. \<forall>r. r \<in> gS \<longrightarrow> B' r = ennreal (B'' r)"
-        by (rule_tac choice) 
+        by (rule_tac choice)
       then obtain B'' where B'': "B' r = ennreal (B'' r)" if "r \<in> gS" for r
-        by atomize_elim 
+        by atomize_elim
       have cases[case_names zero finite infinite]: "P" if "r=0 \<Longrightarrow> P" and "finite (part r) \<Longrightarrow> P"
         and "infinite (part r) \<Longrightarrow> r\<noteq>0 \<Longrightarrow> P" for P r
         using that by metis
       have emeasure_B': "r * emeasure M (part r) \<le> B' r" if "r : gS" for r
       proof (cases rule:cases[of r])
         case zero
         thus ?thesis by simp
       next
         case finite
         have s1: "sum g F \<le> sum normf F"
           if "F \<in> {F. finite F \<and> F \<subseteq> part r}"
           for F
-          using \<open>g \<le> normf\<close> 
+          using \<open>g \<le> normf\<close>
           by (simp add: le_fun_def sum_mono)
 
         have "r * of_nat (card (part r)) = r * (\<Sum>x\<in>part r. 1)" by simp
         also have "\<dots> = (\<Sum>x\<in>part r. r)"
           using mult.commute by auto
         also have "\<dots> = (\<Sum>x\<in>part r. g x)"
           unfolding part_def by auto
         also have "\<dots> \<le> (SUP F\<in>{F. finite F \<and> F\<subseteq>part r}. sum g F)"
           using finite
           by (simp add: Sup_upper)
-        also have "\<dots> \<le> B' r"        
+        also have "\<dots> \<le> B' r"
           unfolding B'_def
           using s1 SUP_subset_mono by blast
         finally have "r * of_nat (card (part r)) \<le> B' r" by assumption
         thus ?thesis
           unfolding M_def
           using part_def finite by auto
       next
         case infinite
         from r_finite[OF \<open>r : gS\<close>] obtain r' where r': "r = ennreal r'"
           using ennreal_cases by auto
         with infinite have "r' > 0"
           using ennreal_less_zero_iff not_gr_zero by blast
         obtain N::nat where N:"N > B / r'" and "real N > 0" apply atomize_elim
           using reals_Archimedean2
           by (metis less_trans linorder_neqE_linordered_idom)
         obtain F where "finite F" and "card F = N" and "F \<subseteq> part r"
           using infinite(1) infinite_arbitrarily_large by blast
         from \<open>F \<subseteq> part r\<close> have "F \<subseteq> S" unfolding part_def by simp
         have "B < r * N"
           unfolding r' ennreal_of_nat_eq_real_of_nat
           using N \<open>0 < r'\<close> assms(2) r'
           by (metis enn2real_ennreal enn2real_less_iff ennreal_less_top ennreal_mult' less_le mult_less_cancel_left_pos nonzero_mult_div_cancel_left times_divide_eq_right)
         also have "r * N = (\<Sum>x\<in>F. r)"
           using \<open>card F = N\<close> by (simp add: mult.commute)
         also have "(\<Sum>x\<in>F. r) = (\<Sum>x\<in>F. g x)"
           using \<open>F \<subseteq> part r\<close>  part_def sum.cong subsetD by fastforce
         also have "(\<Sum>x\<in>F. g x) \<le> (\<Sum>x\<in>F. ennreal (norm (f x)))"
-          by (metis (mono_tags, lifting) \<open>g \<le> normf\<close> \<open>normf \<equiv> \<lambda>x. ennreal (norm (f x))\<close> le_fun_def 
+          by (metis (mono_tags, lifting) \<open>g \<le> normf\<close> \<open>normf \<equiv> \<lambda>x. ennreal (norm (f x))\<close> le_fun_def
               sum_mono)
         also have "(\<Sum>x\<in>F. ennreal (norm (f x))) \<le> B"
-          using \<open>F \<subseteq> S\<close> \<open>finite F\<close> \<open>normf \<equiv> \<lambda>x. ennreal (norm (f x))\<close> normf_B by blast 
+          using \<open>F \<subseteq> S\<close> \<open>finite F\<close> \<open>normf \<equiv> \<lambda>x. ennreal (norm (f x))\<close> normf_B by blast
         finally have "B < B" by auto
         thus ?thesis by simp
       qed
 
       have "integral\<^sup>S M g = (\<Sum>r \<in> gS. r * emeasure M (part r))"
         unfolding simple_integral_def gS_def M_def part_def by simp
       also have "\<dots> \<le> (\<Sum>r \<in> gS. B' r)"
         by (simp add: emeasure_B' sum_mono)
       also have "\<dots> \<le> B"
         using sumB' by blast
       finally show ?thesis by assumption
     qed
     hence int_leq_B: "integral\<^sup>N M normf \<le> B"
       unfolding nn_integral_def by (metis (no_types, lifting) SUP_least mem_Collect_eq)
     hence "integral\<^sup>N M normf < \<infinity>"
       using le_less_trans by fastforce
     hence "integrable M f"
       unfolding M_def normf_def by (rule integrableI_bounded[rotated], simp)
     hence v1: "f abs_summable_on S"
-      unfolding abs_summable_on_def M_def by simp  
+      unfolding abs_summable_on_def M_def by simp
 
     have "(\<lambda>x. norm (f x)) abs_summable_on S"
       using v1 Infinite_Set_Sum.abs_summable_on_norm_iff[where A = S and f = f]
       by auto
     moreover have "0 \<le> norm (f x)"
       if "x \<in> S" for x
-      by simp    
+      by simp
     moreover have "(\<integral>\<^sup>+ x. ennreal (norm (f x)) \<partial>count_space S) \<le> ennreal B"
-      using M_def \<open>normf \<equiv> \<lambda>x. ennreal (norm (f x))\<close> int_leq_B by auto    
+      using M_def \<open>normf \<equiv> \<lambda>x. ennreal (norm (f x))\<close> int_leq_B by auto
     ultimately have "ennreal (\<Sum>\<^sub>ax\<in>S. norm (f x)) \<le> ennreal B"
-      by (simp add: nn_integral_conv_infsetsum)    
+      by (simp add: nn_integral_conv_infsetsum)
     hence v2: "(\<Sum>\<^sub>ax\<in>S. norm (f x)) \<le> B"
       by (subst ennreal_le_iff[symmetric], simp add: assms)
     show ?thesis
       using v1 v2 by auto
   qed
   show "f abs_summable_on S"
     using t1 by blast
   show "(\<Sum>\<^sub>ax\<in>S. norm (f x)) \<le> B"
     using t1 by blast
 qed
 
 lemma abs_summable_finiteI:
   assumes "\<And>F. finite F \<Longrightarrow> F\<subseteq>S \<Longrightarrow> sum (\<lambda>x. norm (f x)) F \<le> B"
   shows "f abs_summable_on S"
 proof -
   from assms have "sum (\<lambda>x. norm (f x)) {} \<le> B" by blast
   hence "0 \<le> B" by simp
-  thus ?thesis 
+  thus ?thesis
     using assms by (rule abs_summable_finiteI0[rotated])
 qed
 
 lemma infsetsum_finite_sets:
   assumes "\<And>F. finite F \<Longrightarrow> F\<subseteq>S \<Longrightarrow> sum (\<lambda>x. norm (f x)) F \<le> B"
     and "B \<ge> 0" and "\<And>x. f x \<ge> 0"
   shows "infsetsum f S \<le> B"
   using abs_summable_finiteI0(2)[where f=f and S=S, OF assms(1-2), simplified]
     assms(3) by auto
 
 lemma abs_summable_finiteI_converse:
   assumes f_sum_S: "f abs_summable_on S"
     and finite_F: "finite F" and FS: "F\<subseteq>S"
   defines "B \<equiv> (infsetsum (\<lambda>x. norm (f x)) S)"
   shows "sum (\<lambda>x. norm (f x)) F \<le> B"
 proof-
   have a1: "(\<lambda>x. norm (f x)) abs_summable_on F"
-    by (simp add: finite_F)    
+    by (simp add: finite_F)
   have a2: "(\<lambda>x. norm (f x)) abs_summable_on S"
-    by (simp add: f_sum_S)    
+    by (simp add: f_sum_S)
   have a3: "x \<in> F \<Longrightarrow> norm (f x) \<le> norm (f x)"
     for x
     by simp
   have a4: "F \<subseteq> S"
-    by (simp add: FS)    
+    by (simp add: FS)
   have a5: "x \<in> S - F \<Longrightarrow> 0 \<le> norm (f x)"
     for x
-    by simp   
+    by simp
   have "sum (\<lambda>x. norm (f x)) F = infsetsum (\<lambda>x. norm (f x)) F"
-    by (simp add: finite_F)    
+    by (simp add: finite_F)
   also have "infsetsum (\<lambda>x. norm (f x)) F \<le> B"
-    unfolding B_def 
-    using a1 a2 a3 a4 a5 
+    unfolding B_def
+    using a1 a2 a3 a4 a5
     by (simp add: infsetsum_mono_neutral_left)
   finally show ?thesis by assumption
 qed
 
 lemma abs_summable_countable:
   fixes \<mu> :: "'a \<Rightarrow> 'b::{banach,second_countable_topology}"
   assumes "\<mu> abs_summable_on T"
   shows "countable {x\<in>T. 0 \<noteq> \<mu> x}"
 proof-
   define B where "B = infsetsum (\<lambda>x. norm (\<mu> x)) T"
   have \<mu>sum: "sum (\<lambda>x. norm (\<mu> x)) F \<le> B" if "finite F" and "F \<subseteq> T" for F
-    unfolding B_def 
+    unfolding B_def
     using assms that abs_summable_finiteI_converse by auto
   define S where "S i = {x\<in>T. 1/real (Suc i) < norm (\<mu> x)}" for i::nat
   have "\<exists>i. x \<in> S i" if "0 < norm (\<mu> x)" and "x \<in> T" for x
     using that unfolding S_def
-    by (metis (full_types, lifting) mem_Collect_eq nat_approx_posE)     
+    by (metis (full_types, lifting) mem_Collect_eq nat_approx_posE)
   hence union: "{x\<in>T. 0 < norm (\<mu> x)} = (\<Union>i. S i)"
     unfolding S_def by auto
   have finiteS: "finite (S i)" for i
   proof (rule ccontr)
     assume "infinite (S i)"
     then obtain F where F_Si: "F \<subseteq> S i" and cardF: "card F > (Suc i)*B" and finiteF: "finite F"
       by (metis One_nat_def ex_less_of_nat_mult infinite_arbitrarily_large lessI mult.commute mult.left_neutral of_nat_0_less_iff of_nat_1)
-    from F_Si have F_T: "F \<subseteq> T" 
+    from F_Si have F_T: "F \<subseteq> T"
       unfolding S_def by blast
     from finiteF \<mu>sum F_T have sumF: "sum (\<lambda>x. norm (\<mu> x)) F \<le> B" by simp
     have "1 / real (Suc i) \<le> norm (\<mu> x)"
       if "x \<in> F"
       for x
       using that F_Si S_def by auto
     hence "sum (\<lambda>x. norm (\<mu> x)) F \<ge> sum (\<lambda>_. 1/real (Suc i)) F" (is "_ \<ge> \<dots>")
       using sum_mono
-      by metis       
+      by metis
     moreover have "\<dots> = real (card F) / (Suc i)"
       by (subst sum_constant_scale, auto)
     moreover have "\<dots> > B"
       using cardF
       by (simp add: linordered_field_class.mult_imp_less_div_pos algebra_simps)
     ultimately have "sum (\<lambda>x. norm (\<mu> x)) F > B"
-      by linarith 
+      by linarith
     with sumF show False by simp
   qed
 
   have "countable (S i)"
     if "i \<in> UNIV"
     for i
     using finiteS by (simp add: countable_finite)
   hence "countable (\<Union>i. S i)"
     using countable_UN by simp
   hence "countable {x\<in>T. 0 < norm (\<mu> x)}"
     unfolding union by simp
   thus ?thesis
     by simp
 qed
 
 
 lemma infsetsum_cnj[simp]: "infsetsum (\<lambda>x. cnj (f x)) M = cnj (infsetsum f M)"
   unfolding infsetsum_def by (rule integral_cnj)
 
-lemma infsetsum_Re: 
+lemma infsetsum_Re:
   assumes "f abs_summable_on M"
   shows "infsetsum (\<lambda>x. Re (f x)) M = Re (infsetsum f M)"
-  unfolding infsetsum_def 
+  unfolding infsetsum_def
   using integral_Re assms by (simp add: abs_summable_on_def)
 
-lemma infsetsum_Im: 
+lemma infsetsum_Im:
   assumes "f abs_summable_on M"
   shows "infsetsum (\<lambda>x. Im (f x)) M = Im (infsetsum f M)"
   unfolding infsetsum_def using assms by (simp add: abs_summable_on_def)
 
 lemma infsetsum_mono_complex:
   fixes f g :: "'a \<Rightarrow> complex"
   assumes f_sum: "f abs_summable_on A" and g_sum: "g abs_summable_on A"
   assumes x: "\<And>x. x \<in> A \<Longrightarrow> f x \<le> g x"
   shows   "infsetsum f A \<le> infsetsum g A"
 proof -
   have a1: "infsetsum f A = Complex (Re (infsetsum f A)) (Im (infsetsum f A))" by auto
   also have a2: "Re (infsetsum f A) = infsetsum (\<lambda>x. Re (f x)) A"
-    unfolding infsetsum_def 
+    unfolding infsetsum_def
     using assms by (simp add: abs_summable_on_def)
   also have a3: "Im (infsetsum f A) = infsetsum (\<lambda>x. Im (f x)) A"
     using f_sum by (rule infsetsum_Im[symmetric])
   finally have fsplit: "infsetsum f A = Complex (\<Sum>\<^sub>ax\<in>A. Re (f x)) (\<Sum>\<^sub>ax\<in>A. Im (f x))" by assumption
   have "infsetsum g A = Complex (Re (infsetsum g A)) (Im (infsetsum g A))" by auto
   also have b2: "Re (infsetsum g A) = infsetsum (\<lambda>x. Re (g x)) A"
     using g_sum by (rule infsetsum_Re[symmetric])
   also have b1: "Im (infsetsum g A) = infsetsum (\<lambda>x. Im (g x)) A "
     using g_sum by (rule infsetsum_Im[symmetric])
-  finally have gsplit: "infsetsum g A = Complex (\<Sum>\<^sub>ax\<in>A. Re (g x)) (\<Sum>\<^sub>ax\<in>A. Im (g x))" 
+  finally have gsplit: "infsetsum g A = Complex (\<Sum>\<^sub>ax\<in>A. Re (g x)) (\<Sum>\<^sub>ax\<in>A. Im (g x))"
     by assumption
   have Re_leq: "Re (f x) \<le> Re (g x)" if "x\<in>A" for x
     using that assms unfolding less_eq_complex_def by simp
   have Im_eq: "Im (f x) = Im (g x)" if "x\<in>A" for x
-    using that assms 
+    using that assms
     unfolding less_eq_complex_def by simp
   have Refsum: "(\<lambda>x. Re (f x)) abs_summable_on A"
     using assms(1) abs_Re_le_cmod by (simp add: abs_summable_on_comparison_test[where g=f])
   have Regsum: "(\<lambda>x. Re (g x)) abs_summable_on A"
-    using assms(2) abs_Re_le_cmod 
+    using assms(2) abs_Re_le_cmod
     by (simp add: abs_summable_on_comparison_test[where g=g])
   show "infsetsum f A \<le> infsetsum g A"
     unfolding fsplit gsplit
     by (smt (verit, ccfv_SIG) Im_eq Re_leq Refsum Regsum a2 a3 b1 b2 fsplit gsplit infsetsum_cong infsetsum_mono less_eq_complex_def)
 qed
 
 lemma infsetsum_subset_complex:
   fixes f :: "'a \<Rightarrow> complex"
   assumes "f abs_summable_on B" and "A \<subseteq> B" and "\<And>x. x\<notin>A \<Longrightarrow> f x \<ge> 0"
   shows "infsetsum f A \<le> infsetsum f B"
 proof -
   have fBA: "f abs_summable_on B - A"
     by (meson Diff_subset abs_summable_on_subset assms(1))
   have "0 = infsetsum (\<lambda>_.0) (B-A)" by auto
   also have "... \<le> infsetsum f (B - A)"
     using assms fBA infsetsum_mono_complex
     by (metis DiffD2 abs_summable_on_0)
   also have "... = infsetsum f B - infsetsum f A"
     using assms by (simp add: infsetsum_Diff)
   finally show ?thesis by auto
 qed
 
 lemma infsetsum_subset_real:
   fixes f :: "'a \<Rightarrow> real"
   assumes "f abs_summable_on B" and "A \<subseteq> B" and "\<And>x. x\<notin>A \<Longrightarrow> f x \<ge> 0"
   shows "infsetsum f A \<le> infsetsum f B"
 proof -
   have fBA: "f abs_summable_on B - A"
     by (meson Diff_subset abs_summable_on_subset assms(1))
   have "0 = infsetsum (\<lambda>_.0) (B-A)" by auto
   also have "... \<le> infsetsum f (B - A)"
-    using assms fBA 
-    by (metis DiffD2 calculation infsetsum_nonneg) 
+    using assms fBA
+    by (metis DiffD2 calculation infsetsum_nonneg)
   also have "... = infsetsum f B - infsetsum f A"
     using assms by (simp add: infsetsum_Diff)
   finally show ?thesis by auto
 qed
 
 lemma abs_summable_product:
   fixes x :: "'a \<Rightarrow> 'b::{real_normed_div_algebra,banach,second_countable_topology}"
   assumes x2_sum: "(\<lambda>i. (x i) * (x i)) abs_summable_on A"
     and y2_sum: "(\<lambda>i. (y i) * (y i)) abs_summable_on A"
   shows "(\<lambda>i. x i * y i) abs_summable_on A"
 proof (rule abs_summable_finiteI)
   have aux: "a\<le>a' \<Longrightarrow> b\<le>b' \<Longrightarrow> a+b \<le> a'+b'" for a b a' b' :: real by simp
   fix F assume r1: "finite F" and b4: "F \<subseteq> A"
   define B :: real where "B = (\<Sum>\<^sub>ai\<in>A. norm (x i * x i)) + (\<Sum>\<^sub>ai\<in>A. norm (y i * y i))"
 
   have a1: "(\<Sum>\<^sub>ai\<in>F. norm (x i * x i)) \<le> (\<Sum>\<^sub>ai\<in>A. norm (x i * x i))"
   proof (rule infsetsum_mono_neutral_left)
     show "(\<lambda>i. norm (x i * x i)) abs_summable_on F"
-      by (simp add: r1)      
+      by (simp add: r1)
     show "(\<lambda>i. norm (x i * x i)) abs_summable_on A"
-      by (simp add: x2_sum)      
+      by (simp add: x2_sum)
     show "norm (x i * x i) \<le> norm (x i * x i)"
       if "i \<in> F"
       for i :: 'a
       by simp
     show "F \<subseteq> A"
-      by (simp add: b4)     
+      by (simp add: b4)
     show "0 \<le> norm (x i * x i)"
       if "i \<in> A - F"
       for i :: 'a
-      by simp 
+      by simp
   qed
   have "norm (x i * y i) \<le> norm (x i * x i) + norm (y i * y i)" for i
     unfolding norm_mult
     by (smt mult_left_mono mult_nonneg_nonneg mult_right_mono norm_ge_zero)
   hence "(\<Sum>i\<in>F. norm (x i * y i)) \<le> (\<Sum>i\<in>F. norm (x i * x i) + norm (y i * y i))"
     by (simp add: sum_mono)
   also have "\<dots> = (\<Sum>i\<in>F. norm (x i * x i)) + (\<Sum>i\<in>F. norm (y i * y i))"
     by (simp add: sum.distrib)
   also have "\<dots> = (\<Sum>\<^sub>ai\<in>F. norm (x i * x i)) + (\<Sum>\<^sub>ai\<in>F. norm (y i * y i))"
     by (simp add: \<open>finite F\<close>)
-  also have "\<dots> \<le> (\<Sum>\<^sub>ai\<in>A. norm (x i * x i)) + (\<Sum>\<^sub>ai\<in>A. norm (y i * y i))" 
+  also have "\<dots> \<le> (\<Sum>\<^sub>ai\<in>A. norm (x i * x i)) + (\<Sum>\<^sub>ai\<in>A. norm (y i * y i))"
     using aux a1
     by (simp add: aux \<open>F \<subseteq> A\<close> \<open>finite F\<close> abs_summable_finiteI_converse x2_sum y2_sum)
   also have "\<dots> = B"
     unfolding B_def by simp
   finally show "(\<Sum>i\<in>F. norm (x i * y i)) \<le> B" by assumption
 qed
 
 lemma abs_summable_cnj_iff[simp]:
   "(\<lambda>i. cnj (f i)) abs_summable_on A \<longleftrightarrow> f abs_summable_on A"
 proof
   show "f abs_summable_on A"
     if "(\<lambda>i. cnj (f i)) abs_summable_on A"
     using that abs_summable_on_norm_iff[symmetric]
-      abs_summable_on_comparison_test by fastforce    
+      abs_summable_on_comparison_test by fastforce
   show "(\<lambda>i. cnj (f i)) abs_summable_on A"
     if "f abs_summable_on A"
     using that abs_summable_on_norm_iff[symmetric]
-      abs_summable_on_comparison_test by fastforce 
+      abs_summable_on_comparison_test by fastforce
 qed
 
 lemma ennreal_Sup:
   assumes "bdd_above A" and nonempty: "A\<noteq>{}"
   shows "ennreal (Sup A) = Sup (ennreal ` A)"
 proof (rule Sup_eqI[symmetric])
   fix y assume "y \<in> ennreal ` A" thus "y \<le> ennreal (Sup A)"
     using assms cSup_upper ennreal_leI by auto
 next
   fix y assume asm: "\<And>z. z \<in> ennreal ` A \<Longrightarrow> z \<le> y"
   show "ennreal (Sup A) \<le> y"
   proof (cases y)
     case (real r)
-    show ?thesis      
-      by (metis assms(1) cSup_le_iff ennreal_leI real(1) real(2) asm Sup_least bdd_above_top 
+    show ?thesis
+      by (metis assms(1) cSup_le_iff ennreal_leI real(1) real(2) asm Sup_least bdd_above_top
           cSUP_le_iff ennreal_le_iff nonempty)
   next
     case top
     thus ?thesis by auto
   qed
 qed
 
 lemma infsetsum_nonneg_is_SUPREMUM_ennreal:
   fixes f :: "'a \<Rightarrow> real"
   assumes summable: "f abs_summable_on A"
     and fnn: "\<And>x. x\<in>A \<Longrightarrow> f x \<ge> 0"
   shows "ennreal (infsetsum f A) = (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. (ennreal (sum f F)))"
 proof-
-  have sum_F_A: "sum f F \<le> infsetsum f A" 
-    if "F \<in> {F. finite F \<and> F \<subseteq> A}" 
+  have sum_F_A: "sum f F \<le> infsetsum f A"
+    if "F \<in> {F. finite F \<and> F \<subseteq> A}"
     for F
   proof-
     from that have "finite F" and "F \<subseteq> A" by auto
     from \<open>finite F\<close> have "sum f F = infsetsum f F" by auto
     also have "\<dots> \<le> infsetsum f A"
     proof (rule infsetsum_mono_neutral_left)
       show "f abs_summable_on F"
-        by (simp add: \<open>finite F\<close>)        
+        by (simp add: \<open>finite F\<close>)
       show "f abs_summable_on A"
-        by (simp add: local.summable)        
+        by (simp add: local.summable)
       show "f x \<le> f x"
         if "x \<in> F"
         for x :: 'a
-        by simp 
+        by simp
       show "F \<subseteq> A"
-        by (simp add: \<open>F \<subseteq> A\<close>)        
+        by (simp add: \<open>F \<subseteq> A\<close>)
       show "0 \<le> f x"
         if "x \<in> A - F"
         for x :: 'a
-        using that fnn by auto 
+        using that fnn by auto
     qed
     finally show ?thesis by assumption
-  qed 
+  qed
   hence geq: "ennreal (infsetsum f A) \<ge> (SUP F\<in>{G. finite G \<and> G \<subseteq> A}. (ennreal (sum f F)))"
     by (meson SUP_least ennreal_leI)
 
   define fe where "fe x = ennreal (f x)" for x
 
   have sum_f_int: "infsetsum f A = \<integral>\<^sup>+ x. fe x \<partial>(count_space A)"
     unfolding infsetsum_def fe_def
   proof (rule nn_integral_eq_integral [symmetric])
     show "integrable (count_space A) f"
-      using abs_summable_on_def local.summable by blast      
+      using abs_summable_on_def local.summable by blast
     show "AE x in count_space A. 0 \<le> f x"
-      using fnn by auto      
+      using fnn by auto
   qed
   also have "\<dots> = (SUP g \<in> {g. finite (g`A) \<and> g \<le> fe}. integral\<^sup>S (count_space A) g)"
     unfolding nn_integral_def simple_function_count_space by simp
   also have "\<dots> \<le> (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. (ennreal (sum f F)))"
   proof (rule Sup_least)
     fix x assume "x \<in> integral\<^sup>S (count_space A) ` {g. finite (g ` A) \<and> g \<le> fe}"
-    then obtain g where xg: "x = integral\<^sup>S (count_space A) g" and fin_gA: "finite (g`A)" 
+    then obtain g where xg: "x = integral\<^sup>S (count_space A) g" and fin_gA: "finite (g`A)"
       and g_fe: "g \<le> fe" by auto
     define F where "F = {z:A. g z \<noteq> 0}"
     hence "F \<subseteq> A" by simp
 
     have fin: "finite {z:A. g z = t}" if "t \<noteq> 0" for t
     proof (rule ccontr)
       assume inf: "infinite {z:A. g z = t}"
       hence tgA: "t \<in> g ` A"
         by (metis (mono_tags, lifting) image_eqI not_finite_existsD)
       have "x = (\<Sum>x \<in> g ` A. x * emeasure (count_space A) (g -` {x} \<inter> A))"
         unfolding xg simple_integral_def space_count_space by simp
       also have "\<dots> \<ge> (\<Sum>x \<in> {t}. x * emeasure (count_space A) (g -` {x} \<inter> A))" (is "_ \<ge> \<dots>")
       proof (rule sum_mono2)
         show "finite (g ` A)"
-          by (simp add: fin_gA)          
+          by (simp add: fin_gA)
         show "{t} \<subseteq> g ` A"
-          by (simp add: tgA)          
+          by (simp add: tgA)
         show "0 \<le> b * emeasure (count_space A) (g -` {b} \<inter> A)"
           if "b \<in> g ` A - {t}"
           for b :: ennreal
           using that
           by simp
       qed
       also have "\<dots> = t * emeasure (count_space A) (g -` {t} \<inter> A)"
         by auto
       also have "\<dots> = t * \<infinity>"
       proof (subst emeasure_count_space_infinite)
         show "g -` {t} \<inter> A \<subseteq> A"
-          by simp             
+          by simp
         have "{a \<in> A. g a = t} = {a \<in> g -` {t}. a \<in> A}"
           by auto
         thus "infinite (g -` {t} \<inter> A)"
-          by (metis (full_types) Int_def inf) 
+          by (metis (full_types) Int_def inf)
         show "t * \<infinity> = t * \<infinity>"
           by simp
       qed
       also have "\<dots> = \<infinity>" using \<open>t \<noteq> 0\<close>
         by (simp add: ennreal_mult_eq_top_iff)
       finally have x_inf: "x = \<infinity>"
         using neq_top_trans by auto
       have "x = integral\<^sup>S (count_space A) g" by (fact xg)
       also have "\<dots> = integral\<^sup>N (count_space A) g"
         by (simp add: fin_gA nn_integral_eq_simple_integral)
       also have "\<dots> \<le> integral\<^sup>N (count_space A) fe"
         using g_fe
         by (simp add: le_funD nn_integral_mono)
       also have "\<dots> < \<infinity>"
-        by (metis sum_f_int ennreal_less_top infinity_ennreal_def) 
+        by (metis sum_f_int ennreal_less_top infinity_ennreal_def)
       finally have x_fin: "x < \<infinity>" by simp
       from x_inf x_fin show False by simp
     qed
     have F: "F = (\<Union>t\<in>g`A-{0}. {z\<in>A. g z = t})"
       unfolding F_def by auto
     hence "finite F"
       unfolding F using fin_gA fin by auto
     have "x = integral\<^sup>N (count_space A) g"
       unfolding xg
       by (simp add: fin_gA nn_integral_eq_simple_integral)
     also have "\<dots> = set_nn_integral (count_space UNIV) A g"
       by (simp add: nn_integral_restrict_space[symmetric] restrict_count_space)
     also have "\<dots> = set_nn_integral (count_space UNIV) F g"
     proof -
       have "\<forall>a. g a * (if a \<in> {a \<in> A. g a \<noteq> 0} then 1 else 0) = g a * (if a \<in> A then 1 else 0)"
         by auto
       hence "(\<integral>\<^sup>+ a. g a * (if a \<in> A then 1 else 0) \<partial>count_space UNIV)
            = (\<integral>\<^sup>+ a. g a * (if a \<in> {a \<in> A. g a \<noteq> 0} then 1 else 0) \<partial>count_space UNIV)"
         by presburger
       thus ?thesis unfolding F_def indicator_def
-        using mult.right_neutral mult_zero_right nn_integral_cong
-        by blast
+        by (simp add: of_bool_def)
     qed
     also have "\<dots> = integral\<^sup>N (count_space F) g"
       by (simp add: nn_integral_restrict_space[symmetric] restrict_count_space)
-    also have "\<dots> = sum g F" 
+    also have "\<dots> = sum g F"
       using \<open>finite F\<close> by (rule nn_integral_count_space_finite)
     also have "sum g F \<le> sum fe F"
       using g_fe unfolding le_fun_def
-      by (simp add: sum_mono) 
+      by (simp add: sum_mono)
     also have "\<dots> \<le> (SUP F \<in> {G. finite G \<and> G \<subseteq> A}. (sum fe F))"
       using \<open>finite F\<close> \<open>F\<subseteq>A\<close>
       by (simp add: SUP_upper)
     also have "\<dots> = (SUP F \<in> {F. finite F \<and> F \<subseteq> A}. (ennreal (sum f F)))"
     proof (rule SUP_cong [OF refl])
       have "finite x \<Longrightarrow> x \<subseteq> A \<Longrightarrow> (\<Sum>x\<in>x. ennreal (f x)) = ennreal (sum f x)"
         for x
         by (metis fnn subsetCE sum_ennreal)
       thus "sum fe x = ennreal (sum f x)"
         if "x \<in> {G. finite G \<and> G \<subseteq> A}"
         for x :: "'a set"
-        using that unfolding fe_def by auto      
-    qed 
+        using that unfolding fe_def by auto
+    qed
     finally show "x \<le> \<dots>" by simp
   qed
   finally have leq: "ennreal (infsetsum f A) \<le> (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. (ennreal (sum f F)))"
     by assumption
   from leq geq show ?thesis by simp
 qed
 
 lemma infsetsum_nonneg_is_SUPREMUM_ereal:
   fixes f :: "'a \<Rightarrow> real"
   assumes summable: "f abs_summable_on A"
     and fnn: "\<And>x. x\<in>A \<Longrightarrow> f x \<ge> 0"
   shows "ereal (infsetsum f A) = (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. (ereal (sum f F)))"
 proof -
   have "ereal (infsetsum f A) = enn2ereal (ennreal (infsetsum f A))"
     by (simp add: fnn infsetsum_nonneg)
   also have "\<dots> = enn2ereal (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. ennreal (sum f F))"
   proof (subst infsetsum_nonneg_is_SUPREMUM_ennreal)
     show "f abs_summable_on A"
-      by (simp add: local.summable)      
+      by (simp add: local.summable)
     show "0 \<le> f x"
       if "x \<in> A"
       for x :: 'a
       using that
-      by (simp add: fnn) 
+      by (simp add: fnn)
     show "enn2ereal (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. ennreal (sum f F)) = enn2ereal (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. ennreal (sum f F))"
-      by simp      
-  qed    
+      by simp
+  qed
   also have "\<dots> = (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. (ereal (sum f F)))"
   proof (simp add: image_def Sup_ennreal.rep_eq)
     have "0 \<le> Sup {y. \<exists>x. (\<exists>xa. finite xa \<and> xa \<subseteq> A \<and> x = ennreal (sum f xa)) \<and>
                      y = enn2ereal x}"
       by (metis (mono_tags, lifting) Sup_upper empty_subsetI ennreal_0 finite.emptyI
           mem_Collect_eq sum.empty zero_ennreal.rep_eq)
     moreover have "Sup {y. \<exists>x. (\<exists>y. finite y \<and> y \<subseteq> A \<and> x = ennreal (sum f y)) \<and>
                 y = enn2ereal x} = Sup {y. \<exists>x. finite x \<and> x \<subseteq> A \<and> y = ereal (sum f x)}"
       using enn2ereal_ennreal fnn in_mono sum_nonneg Collect_cong
       by smt
     ultimately show "max 0 (Sup {y. \<exists>x. (\<exists>xa. finite xa \<and> xa \<subseteq> A \<and> x
                                        = ennreal (sum f xa)) \<and> y = enn2ereal x})
          = Sup {y. \<exists>x. finite x \<and> x \<subseteq> A \<and> y = ereal (sum f x)}"
       by linarith
-  qed   
+  qed
   finally show ?thesis
     by simp
 qed
 
 lemma infsetsum_nonneg_is_SUPREMUM:
   fixes f :: "'a \<Rightarrow> real"
   assumes summable: "f abs_summable_on A"
     and fnn: "\<And>x. x\<in>A \<Longrightarrow> f x \<ge> 0"
   shows "infsetsum f A = (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. (sum f F))"
 proof -
   have "ereal (infsetsum f A) = (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. (ereal (sum f F)))"
     using assms by (rule infsetsum_nonneg_is_SUPREMUM_ereal)
   also have "\<dots> = ereal (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. (sum f F))"
   proof (subst ereal_SUP)
     show "\<bar>SUP a\<in>{F. finite F \<and> F \<subseteq> A}. ereal (sum f a)\<bar> \<noteq> \<infinity>"
-      using calculation by fastforce      
+      using calculation by fastforce
     show "(SUP F\<in>{F. finite F \<and> F \<subseteq> A}. ereal (sum f F)) = (SUP a\<in>{F. finite F \<and> F \<subseteq> A}. ereal (sum f a))"
-      by simp      
+      by simp
   qed
   finally show ?thesis by simp
 qed
 
 lemma infsetsum_geq0_complex:
   fixes f :: "'a \<Rightarrow> complex"
   assumes "f abs_summable_on M"
     and fnn: "\<And>x. x \<in> M \<Longrightarrow> 0 \<le> f x"
   shows "infsetsum f M \<ge> 0" (is "?lhs \<ge> _")
 proof -
   have "?lhs \<ge> infsetsum (\<lambda>x. 0) M" (is "_ \<ge> \<dots>")
   proof (rule infsetsum_mono_complex)
     show "(\<lambda>x. 0::complex) abs_summable_on M"
-      by simp      
+      by simp
     show "f abs_summable_on M"
-      by (simp add: assms(1))      
+      by (simp add: assms(1))
     show "0 \<le> f x"
       if "x \<in> M"
       for x :: 'a
       using that
       using fnn by blast
   qed
   also have "\<dots> = 0"
     by auto
   finally show ?thesis by assumption
 qed
 
 lemma infsetsum_cmod:
   assumes "f abs_summable_on M"
     and fnn: "\<And>x. x \<in> M \<Longrightarrow> 0 \<le> f x"
   shows "infsetsum (\<lambda>x. cmod (f x)) M = cmod (infsetsum f M)"
 proof -
-  have nn: "infsetsum f M \<ge> 0" 
-    using assms by (rule infsetsum_geq0_complex) 
+  have nn: "infsetsum f M \<ge> 0"
+    using assms by (rule infsetsum_geq0_complex)
   have "infsetsum (\<lambda>x. cmod (f x)) M = infsetsum (\<lambda>x. Re (f x)) M"
     using fnn cmod_eq_Re less_eq_complex_def by auto
   also have "\<dots> = Re (infsetsum f M)"
     using assms(1) infsetsum_Re by blast
   also have "\<dots> = cmod (infsetsum f M)" using nn cmod_eq_Re less_eq_complex_def by auto
   finally show ?thesis by assumption
 qed
 
 lemma infsetsum_Sigma:
   fixes A :: "'a set" and B :: "'a \<Rightarrow> 'b set"
   assumes summable: "f abs_summable_on (Sigma A B)"
   shows "infsetsum f (Sigma A B) = infsetsum (\<lambda>x. infsetsum (\<lambda>y. f (x, y)) (B x)) A"
 proof-
   from summable have countable_Sigma: "countable {x \<in> Sigma A B. 0 \<noteq> f x}"
     by (rule abs_summable_countable)
   define A' where "A' = fst ` {x \<in> Sigma A B. 0 \<noteq> f x}"
   have countA': "countable A'"
     using countable_Sigma unfolding A'_def by auto
 
   define B' where "B' a = snd ` ({x \<in> Sigma A B. 0 \<noteq> f x} \<inter> {(a,b) | b. True})" for a
   have countB': "countable (B' a)" for a
     using countable_Sigma unfolding B'_def by auto
 
   have Sigma_eq: "x \<in> Sigma A B \<longleftrightarrow> x \<in> Sigma A' B'" if "f x \<noteq> 0" for x
-    unfolding A'_def B'_def Sigma_def 
+    unfolding A'_def B'_def Sigma_def
     using that by force
 
   have Sigma'_smaller: "Sigma A' B' \<subseteq> Sigma A B"
     unfolding A'_def B'_def by auto
   with summable have summable': "f abs_summable_on Sigma A' B'"
     using abs_summable_on_subset by blast
 
   have A'_smaller: "A' \<subseteq> A"
     unfolding A'_def by auto
   have B'_smaller: "B' a \<subseteq> B a" for a
     unfolding B'_def by auto
 
   have "infsetsum f (Sigma A B) = infsetsum f (Sigma A' B')"
   proof (rule infsetsum_cong_neutral)
     show "f x = 0"
       if "x \<in> Sigma A B - Sigma A' B'"
       for x :: "'a \<times> 'b"
       using that
-      by (meson DiffD1 DiffD2 Sigma_eq) 
+      by (meson DiffD1 DiffD2 Sigma_eq)
     show "f x = 0"
       if "x \<in> Sigma A' B' - Sigma A B"
       for x :: "'a \<times> 'b"
-      using that Sigma'_smaller by auto 
+      using that Sigma'_smaller by auto
     show "f x = f x"
       if "x \<in> Sigma A B \<inter> Sigma A' B'"
       for x :: "'a \<times> 'b"
       using that
-      by simp 
-  qed 
+      by simp
+  qed
   also from countA' countB' summable' have "\<dots> = (\<Sum>\<^sub>aa\<in>A'. \<Sum>\<^sub>ab\<in>B' a. f (a, b))"
     by (rule infsetsum_Sigma)
   also have "\<dots> = (\<Sum>\<^sub>aa\<in>A. \<Sum>\<^sub>ab\<in>B' a. f (a, b))" (is "_ = (\<Sum>\<^sub>aa\<in>A. ?inner a)" is "_ = ?rhs")
   proof (rule infsetsum_cong_neutral)
     show "(\<Sum>\<^sub>ab\<in>B' x. f (x, b)) = 0"
       if "x \<in> A' - A"
       for x :: 'a
-      using that A'_smaller by blast 
+      using that A'_smaller by blast
     show "(\<Sum>\<^sub>ab\<in>B' x. f (x, b)) = 0"
       if "x \<in> A - A'"
       for x :: 'a
     proof -
       have f1: "x \<in> A"
         by (metis DiffD1 that)
       obtain bb :: "('b \<Rightarrow> 'c) \<Rightarrow> 'b set \<Rightarrow> 'b" where
         "\<forall>x0 x1. (\<exists>v2. v2 \<in> x1 \<and> x0 v2 \<noteq> 0) = (bb x0 x1 \<in> x1 \<and> x0 (bb x0 x1) \<noteq> 0)"
         by moura
       hence f2: "\<forall>B f. bb f B \<in> B \<and> f (bb f B) \<noteq> 0 \<or> infsetsum f B = 0"
         by (meson infsetsum_all_0)
       have "(x, bb (\<lambda>b. f (x, b)) (B' x)) \<notin> Sigma A' B'"
         by (meson DiffD2 SigmaE2 that)
       thus ?thesis
         using f2 f1 by (meson B'_smaller SigmaI Sigma_eq in_mono)
-    qed 
+    qed
     show "(\<Sum>\<^sub>ab\<in>B' x. f (x, b)) = (\<Sum>\<^sub>ab\<in>B' x. f (x, b))"
       if "x \<in> A' \<inter> A"
       for x :: 'a
       using that
-      by simp 
+      by simp
   qed
   also have "?inner a = (\<Sum>\<^sub>ab\<in>B a. f (a, b))" if "a\<in>A" for a
   proof (rule infsetsum_cong_neutral)
     show "f (a, x) = 0"
       if "x \<in> B' a - B a"
       for x :: 'b
-      using that B'_smaller by blast 
+      using that B'_smaller by blast
     show "f (a, x) = 0"
       if "x \<in> B a - B' a"
       for x :: 'b
-      using that Sigma_eq \<open>a \<in> A\<close> by fastforce 
+      using that Sigma_eq \<open>a \<in> A\<close> by fastforce
     show "f (a, x) = f (a, x)"
       if "x \<in> B' a \<inter> B a"
       for x :: 'b
       using that
-      by simp 
+      by simp
   qed
   hence "?rhs = (\<Sum>\<^sub>aa\<in>A. \<Sum>\<^sub>ab\<in>B a. f (a, b))"
     by (rule infsetsum_cong, auto)
-  finally show ?thesis 
+  finally show ?thesis
     by simp
 qed
 
 lemma infsetsum_Sigma':
   fixes A :: "'a set" and B :: "'a \<Rightarrow> 'b set"
   assumes summable: "(\<lambda>(x,y). f x y) abs_summable_on (Sigma A B)"
   shows   "infsetsum (\<lambda>x. infsetsum (\<lambda>y. f x y) (B x)) A = infsetsum (\<lambda>(x,y). f x y) (Sigma A B)"
   using assms by (subst infsetsum_Sigma) auto
 
 lemma infsetsum_Times:
   fixes A :: "'a set" and B :: "'b set"
   assumes summable: "f abs_summable_on (A \<times> B)"
   shows   "infsetsum f (A \<times> B) = infsetsum (\<lambda>x. infsetsum (\<lambda>y. f (x, y)) B) A"
   using assms by (subst infsetsum_Sigma) auto
 
 lemma infsetsum_Times':
   fixes A :: "'a set" and B :: "'b set"
   fixes f :: "'a \<Rightarrow> 'b \<Rightarrow> 'c :: {banach, second_countable_topology}"
   assumes summable: "(\<lambda>(x,y). f x y) abs_summable_on (A \<times> B)"
   shows   "infsetsum (\<lambda>x. infsetsum (\<lambda>y. f x y) B) A = infsetsum (\<lambda>(x,y). f x y) (A \<times> B)"
   using assms by (subst infsetsum_Times) auto
 
 lemma infsetsum_swap:
   fixes A :: "'a set" and B :: "'b set"
   fixes f :: "'a \<Rightarrow> 'b \<Rightarrow> 'c :: {banach, second_countable_topology}"
   assumes summable: "(\<lambda>(x,y). f x y) abs_summable_on A \<times> B"
   shows "infsetsum (\<lambda>x. infsetsum (\<lambda>y. f x y) B) A = infsetsum (\<lambda>y. infsetsum (\<lambda>x. f x y) A) B"
 proof-
   from summable have summable': "(\<lambda>(x,y). f y x) abs_summable_on B \<times> A"
     by (subst abs_summable_on_Times_swap) auto
   have bij: "bij_betw (\<lambda>(x, y). (y, x)) (B \<times> A) (A \<times> B)"
     by (auto simp: bij_betw_def inj_on_def)
   have "infsetsum (\<lambda>x. infsetsum (\<lambda>y. f x y) B) A = infsetsum (\<lambda>(x,y). f x y) (A \<times> B)"
     using summable by (subst infsetsum_Times) auto
   also have "\<dots> = infsetsum (\<lambda>(x,y). f y x) (B \<times> A)"
     by (subst infsetsum_reindex_bij_betw[OF bij, of "\<lambda>(x,y). f x y", symmetric])
       (simp_all add: case_prod_unfold)
   also have "\<dots> = infsetsum (\<lambda>y. infsetsum (\<lambda>x. f x y) A) B"
     using summable' by (subst infsetsum_Times) auto
   finally show ?thesis.
 qed
 
 
 lemma abs_summable_infsetsum'_converges:
   fixes f :: "'a\<Rightarrow>'b::{second_countable_topology,banach}" and A :: "'a set"
   assumes "f abs_summable_on A"
   shows "infsetsum'_converges f A"
 proof-
   define F where "F = filtermap (sum f) (finite_subsets_at_top A)"
   have F_not_bot: "F \<noteq> bot"
     unfolding F_def filtermap_bot_iff by simp
 
   have "\<exists>P. eventually P (finite_subsets_at_top A) \<and> (\<forall>x y. P x \<and> P y
          \<longrightarrow> dist (sum f x) (sum f y) < e)"
     if "0 < e"
     for e :: real
   proof-
     have is_SUP: "ereal (\<Sum>\<^sub>ax\<in>A. norm (f x)) = (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. ereal (\<Sum>x\<in>F. norm (f x)))"
     proof (rule infsetsum_nonneg_is_SUPREMUM_ereal)
       show "(\<lambda>x. norm (f x)) abs_summable_on A"
         by (simp add: assms)
 
       show "0 \<le> norm (f x)"
         if "x \<in> A"
         for x :: 'a
         using that
-        by simp 
-    qed 
+        by simp
+    qed
     have "\<exists>F0\<in>{F. finite F \<and> F \<subseteq> A}.
        (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. ereal (\<Sum>x\<in>F. norm (f x))) - ereal e
        < ereal (\<Sum>x\<in>F0. norm (f x))"
       unfolding is_SUP Bex_def[symmetric]
-      by (smt less_SUP_iff[symmetric] \<open>0 < e\<close> ereal_diff_le_self ereal_less_eq(5) ereal_minus(1) 
+      by (smt less_SUP_iff[symmetric] \<open>0 < e\<close> ereal_diff_le_self ereal_less_eq(5) ereal_minus(1)
           is_SUP less_eq_ereal_def)
     then obtain F0 where "F0\<in>{F. finite F \<and> F \<subseteq> A}" and "ereal (\<Sum>x\<in>F0. norm (f x)) > ereal (\<Sum>\<^sub>ax\<in>A. norm (f x)) - ereal e"
-      by (simp add: atomize_elim is_SUP) 
-    hence [simp]: "finite F0" and [simp]: "F0 \<subseteq> A" 
+      by (simp add: atomize_elim is_SUP)
+    hence [simp]: "finite F0" and [simp]: "F0 \<subseteq> A"
       and sum_diff: "sum (\<lambda>x. norm (f x)) F0 > infsetsum (\<lambda>x. norm (f x)) A - e"
       by auto
     define P where "P F \<longleftrightarrow> finite F \<and> F \<supseteq> F0 \<and> F \<subseteq> A" for F
     have "dist (sum f F1) (sum f F2) < e" if "P F1" and "P F2" for F1 F2
     proof -
       from that(1) have "finite F1" and "F1 \<supseteq> F0" and "F1 \<subseteq> A" unfolding P_def by auto
       from that(2) have "finite F2" and "F2 \<supseteq> F0" and "F2 \<subseteq> A" unfolding P_def by auto
       have "dist (sum f F1) (sum f F2) = norm (sum f (F1-F2) - sum f (F2-F1))"
         unfolding dist_norm
-        by (smt \<open>finite F1\<close> \<open>finite F2\<close> add_diff_cancel_left' add_diff_cancel_right' algebra_simps sum.Int_Diff sum.union_diff2 sum.union_inter) 
+        by (smt \<open>finite F1\<close> \<open>finite F2\<close> add_diff_cancel_left' add_diff_cancel_right' algebra_simps sum.Int_Diff sum.union_diff2 sum.union_inter)
       also have "\<dots> \<le> sum (\<lambda>x. norm (f x)) (F1-F2) + sum (\<lambda>x. norm (f x)) (F2-F1)"
         by (smt norm_triangle_ineq4 sum_norm_le)
       also have "\<dots> = infsetsum (\<lambda>x. norm (f x)) (F1-F2) + infsetsum (\<lambda>x. norm (f x)) (F2-F1)"
         by (simp add: \<open>finite F1\<close> \<open>finite F2\<close>)
       also have "\<dots> = infsetsum (\<lambda>x. norm (f x)) ((F1-F2)\<union>(F2-F1))"
       proof (rule infsetsum_Un_disjoint [symmetric])
         show "(\<lambda>x. norm (f x)) abs_summable_on F1 - F2"
-          by (simp add: \<open>finite F1\<close>)          
+          by (simp add: \<open>finite F1\<close>)
         show "(\<lambda>x. norm (f x)) abs_summable_on F2 - F1"
-          by (simp add: \<open>finite F2\<close>)          
+          by (simp add: \<open>finite F2\<close>)
         show "(F1 - F2) \<inter> (F2 - F1) = {}"
-          by (simp add: Diff_Int_distrib2)          
+          by (simp add: Diff_Int_distrib2)
       qed
       also have "\<dots> \<le> infsetsum (\<lambda>x. norm (f x)) (A-F0)"
       proof (rule infsetsum_mono_neutral_left)
         show "(\<lambda>x. norm (f x)) abs_summable_on F1 - F2 \<union> (F2 - F1)"
-          by (simp add: \<open>finite F1\<close> \<open>finite F2\<close>)          
+          by (simp add: \<open>finite F1\<close> \<open>finite F2\<close>)
         show "(\<lambda>x. norm (f x)) abs_summable_on A - F0"
-          using abs_summable_on_subset assms by fastforce          
+          using abs_summable_on_subset assms by fastforce
         show "norm (f x) \<le> norm (f x)"
           if "x \<in> F1 - F2 \<union> (F2 - F1)"
           for x :: 'a
           using that
-          by simp 
+          by simp
         show "F1 - F2 \<union> (F2 - F1) \<subseteq> A - F0"
-          by (simp add: Diff_mono \<open>F0 \<subseteq> F1\<close> \<open>F0 \<subseteq> F2\<close> \<open>F1 \<subseteq> A\<close> \<open>F2 \<subseteq> A\<close>)          
+          by (simp add: Diff_mono \<open>F0 \<subseteq> F1\<close> \<open>F0 \<subseteq> F2\<close> \<open>F1 \<subseteq> A\<close> \<open>F2 \<subseteq> A\<close>)
         show "0 \<le> norm (f x)"
           if "x \<in> A - F0 - (F1 - F2 \<union> (F2 - F1))"
           for x :: 'a
-          by simp 
+          by simp
       qed
       also have "\<dots> = infsetsum (\<lambda>x. norm (f x)) A - infsetsum (\<lambda>x. norm (f x)) F0"
         by (simp add: assms infsetsum_Diff)
       also have "\<dots> < e"
         using local.sum_diff by auto
       finally show "dist (sum f F1) (sum f F2) < e" by assumption
     qed
     moreover have "eventually P (finite_subsets_at_top A)"
       unfolding P_def eventually_finite_subsets_at_top
-      using \<open>F0 \<subseteq> A\<close> \<open>finite F0\<close> by blast      
+      using \<open>F0 \<subseteq> A\<close> \<open>finite F0\<close> by blast
     ultimately show "\<exists>P. eventually P (finite_subsets_at_top A) \<and> (\<forall>F1 F2. P F1 \<and> P F2 \<longrightarrow> dist (sum f F1) (sum f F2) < e)"
       by auto
   qed
   hence cauchy: "cauchy_filter F"
     unfolding F_def
-    by (rule cauchy_filter_metric_filtermapI)  
+    by (rule cauchy_filter_metric_filtermapI)
   from complete_UNIV have "F\<le>principal UNIV \<Longrightarrow> F \<noteq> bot \<Longrightarrow> cauchy_filter F \<Longrightarrow> (\<exists>x. F \<le> nhds x)"
     unfolding complete_uniform
     by auto
   have "(F \<le> principal UNIV \<Longrightarrow> F \<noteq> bot \<Longrightarrow> cauchy_filter F \<Longrightarrow> \<exists>x. F \<le> nhds x) \<Longrightarrow>
     \<exists>x. F \<le> nhds x"
     using cauchy F_not_bot by simp
   then obtain x where Fx: "F \<le> nhds x"
     using \<open>\<lbrakk>F \<le> principal UNIV; F \<noteq> bot; cauchy_filter F\<rbrakk> \<Longrightarrow> \<exists>x. F \<le> nhds x\<close> by blast
   hence "(sum f \<longlongrightarrow> x) (finite_subsets_at_top A)"
     unfolding F_def
     by (simp add: filterlim_def)
   thus ?thesis
     unfolding infsetsum'_converges_def by auto
 qed
 
 lemma infsetsum'_converges_cofin_subset:
   fixes f :: "'a \<Rightarrow> 'b::{topological_ab_group_add,t2_space}"
   assumes "infsetsum'_converges f A" and [simp]: "finite F"
   shows "infsetsum'_converges f (A-F)"
 proof-
   from assms(1) obtain x where lim_f: "(sum f \<longlongrightarrow> x) (finite_subsets_at_top A)"
     unfolding infsetsum'_converges_def by auto
   define F' where "F' = F\<inter>A"
   with assms have "finite F'" and "A-F = A-F'"
     by auto
   have "filtermap ((\<union>)F') (finite_subsets_at_top (A-F))
       \<le> finite_subsets_at_top A"
   proof (rule filter_leI)
     fix P assume "eventually P (finite_subsets_at_top A)"
-    then obtain X where [simp]: "finite X" and XA: "X \<subseteq> A" 
+    then obtain X where [simp]: "finite X" and XA: "X \<subseteq> A"
       and P: "\<forall>Y. finite Y \<and> X \<subseteq> Y \<and> Y \<subseteq> A \<longrightarrow> P Y"
       unfolding eventually_finite_subsets_at_top by auto
     define X' where "X' = X-F"
     hence [simp]: "finite X'" and [simp]: "X' \<subseteq> A-F"
       using XA by auto
     hence "finite Y \<and> X' \<subseteq> Y \<and> Y \<subseteq> A - F \<longrightarrow> P (F' \<union> Y)" for Y
       using P XA unfolding X'_def using F'_def \<open>finite F'\<close> by blast
     thus "eventually P (filtermap ((\<union>) F') (finite_subsets_at_top (A - F)))"
       unfolding eventually_filtermap eventually_finite_subsets_at_top
       by (rule_tac x=X' in exI, simp)
   qed
   with lim_f have "(sum f \<longlongrightarrow> x) (filtermap ((\<union>)F') (finite_subsets_at_top (A-F)))"
     using tendsto_mono by blast
   have "((\<lambda>G. sum f (F' \<union> G)) \<longlongrightarrow> x) (finite_subsets_at_top (A - F))"
     if "((sum f \<circ> (\<union>) F') \<longlongrightarrow> x) (finite_subsets_at_top (A - F))"
     using that unfolding o_def by auto
   hence "((\<lambda>G. sum f (F' \<union> G)) \<longlongrightarrow> x) (finite_subsets_at_top (A-F))"
     using tendsto_compose_filtermap [symmetric]
-    by (simp add: \<open>(sum f \<longlongrightarrow> x) (filtermap ((\<union>) F') (finite_subsets_at_top (A - F)))\<close> 
+    by (simp add: \<open>(sum f \<longlongrightarrow> x) (filtermap ((\<union>) F') (finite_subsets_at_top (A - F)))\<close>
         tendsto_compose_filtermap)
   have "\<forall>Y. finite Y \<and> Y \<subseteq> A - F \<longrightarrow> sum f (F' \<union> Y) = sum f F' + sum f Y"
     by (metis Diff_disjoint Int_Diff \<open>A - F = A - F'\<close> \<open>finite F'\<close> inf.orderE sum.union_disjoint)
   hence "\<forall>\<^sub>F x in finite_subsets_at_top (A - F). sum f (F' \<union> x) = sum f F' + sum f x"
     unfolding eventually_finite_subsets_at_top
     using exI [where x = "{}"]
-    by (simp add: \<open>\<And>P. P {} \<Longrightarrow> \<exists>x. P x\<close>) 
+    by (simp add: \<open>\<And>P. P {} \<Longrightarrow> \<exists>x. P x\<close>)
   hence "((\<lambda>G. sum f F' + sum f G) \<longlongrightarrow> x) (finite_subsets_at_top (A-F))"
     using tendsto_cong [THEN iffD1 , rotated]
       \<open>((\<lambda>G. sum f (F' \<union> G)) \<longlongrightarrow> x) (finite_subsets_at_top (A - F))\<close> by fastforce
   hence "((\<lambda>G. sum f F' + sum f G) \<longlongrightarrow> sum f F' + (x-sum f F')) (finite_subsets_at_top (A-F))"
     by simp
   hence "(sum f \<longlongrightarrow> x - sum f F') (finite_subsets_at_top (A-F))"
-    using Extra_General.tendsto_add_const_iff by blast    
+    using Extra_General.tendsto_add_const_iff by blast
   thus "infsetsum'_converges f (A - F)"
     unfolding infsetsum'_converges_def by auto
 qed
 
-lemma 
+lemma
   fixes f :: "'a \<Rightarrow> 'b::{comm_monoid_add,t2_space}"
   assumes "\<And>x. x\<in>(A-B)\<union>(B-A) \<Longrightarrow> f x = 0"
   shows infsetsum'_subset_zero: "infsetsum' f A = infsetsum' f B"
     and infsetsum'_converges_subset_zero: "infsetsum'_converges f A = infsetsum'_converges f B"
 proof -
   have convB: "infsetsum'_converges f B" and eq: "infsetsum' f A = infsetsum' f B"
     if convA: "infsetsum'_converges f A" and f0: "\<And>x. x\<in>(A-B)\<union>(B-A) \<Longrightarrow> f x = 0" for A B
   proof -
     define D where "D = (A-B)"
     define D' where "D' = B-A"
 
     from convA obtain x where limA: "(sum f \<longlongrightarrow> x) (finite_subsets_at_top A)"
       using infsetsum'_converges_def by blast
     have "sum f X = sum f (X - D)"
       if "finite (X::'a set)"
         and "X \<subseteq> A"
       for X :: "'a set"
       using that f0 D_def by (simp add: subset_iff sum.mono_neutral_cong_right)
     hence "\<forall>\<^sub>F x in finite_subsets_at_top A. sum f x = sum f (x - D)"
       by (rule eventually_finite_subsets_at_top_weakI)
     hence "((\<lambda>F. sum f (F-D)) \<longlongrightarrow> x) (finite_subsets_at_top A)"
       using tendsto_cong [THEN iffD1, rotated] limA by fastforce
     hence "(sum f \<longlongrightarrow> x) (filtermap (\<lambda>F. F-D) (finite_subsets_at_top A))"
       by (simp add: filterlim_filtermap)
     have "D \<subseteq> A"
       unfolding D_def by simp
     hence "finite_subsets_at_top (A - D) \<le> filtermap (\<lambda>F. F - D) (finite_subsets_at_top A)"
       by (rule finite_subsets_at_top_minus)
     hence "(sum f \<longlongrightarrow> x) (finite_subsets_at_top (A-D))"
-      using tendsto_mono [rotated] 
+      using tendsto_mono [rotated]
         \<open>(sum f \<longlongrightarrow> x) (filtermap (\<lambda>F. F - D) (finite_subsets_at_top A))\<close>
       by blast
     have "A - D \<subseteq> B"
       unfolding D_def by auto
     hence "filtermap (\<lambda>F. F \<inter> (A - D)) (finite_subsets_at_top B) \<le> finite_subsets_at_top (A - D)"
       by (rule finite_subsets_at_top_inter [where B = B and A = "A-D"])
     hence "(sum f \<longlongrightarrow> x) (filtermap (\<lambda>F. F \<inter> (A - D)) (finite_subsets_at_top B))"
       using tendsto_mono [rotated] \<open>(sum f \<longlongrightarrow> x) (finite_subsets_at_top (A - D))\<close> by blast
     hence "((\<lambda>F. sum f (F \<inter> (A - D))) \<longlongrightarrow> x) (finite_subsets_at_top B)"
       by (simp add: filterlim_filtermap)
     have "sum f (X \<inter> (A - D)) = sum f X"
       if "finite (X::'a set)"
         and "X \<subseteq> B"
       for X :: "'a set"
     proof (rule sum.mono_neutral_cong)
       show "finite X"
         by (simp add: that(1))
       show "finite (X \<inter> (A - D))"
         by (simp add: that(1))
       show "f i = 0"
         if "i \<in> X - X \<inter> (A - D)"
         for i :: 'a
-        using that D_def DiffD2 \<open>X \<subseteq> B\<close> f0 by auto 
+        using that D_def DiffD2 \<open>X \<subseteq> B\<close> f0 by auto
       show "f i = 0"
         if "i \<in> X \<inter> (A - D) - X"
         for i :: 'a
         using that
-        by auto 
+        by auto
       show "f x = f x"
         if "x \<in> X \<inter> (A - D) \<inter> X"
         for x :: 'a
         by simp
     qed
     hence "\<forall>\<^sub>F x in finite_subsets_at_top B. sum f (x \<inter> (A - D)) = sum f x"
-      by (rule eventually_finite_subsets_at_top_weakI)      
+      by (rule eventually_finite_subsets_at_top_weakI)
     hence limB: "(sum f \<longlongrightarrow> x) (finite_subsets_at_top B)"
       using tendsto_cong [THEN iffD1 , rotated]
         \<open>((\<lambda>F. sum f (F \<inter> (A - D))) \<longlongrightarrow> x) (finite_subsets_at_top B)\<close> by blast
     thus "infsetsum'_converges f B"
       unfolding infsetsum'_converges_def by auto
     have "Lim (finite_subsets_at_top A) (sum f) = Lim (finite_subsets_at_top B) (sum f)"
       if "infsetsum'_converges f B"
       using that    using limA limB
       using finite_subsets_at_top_neq_bot tendsto_Lim by blast
     thus "infsetsum' f A = infsetsum' f B"
-      unfolding infsetsum'_def 
+      unfolding infsetsum'_def
       using convA
       by (simp add: \<open>infsetsum'_converges f B\<close>)
   qed
   with assms show "infsetsum'_converges f A = infsetsum'_converges f B"
     by (metis Un_commute)
   thus "infsetsum' f A = infsetsum' f B"
     using assms convB eq
     by (metis infsetsum'_def)
 qed
 
 lemma
   fixes f :: "'a \<Rightarrow> 'b::{topological_ab_group_add,t2_space}"
   assumes "infsetsum'_converges f B" and "infsetsum'_converges f A" and AB: "A \<subseteq> B"
   shows infsetsum'_Diff: "infsetsum' f (B - A) = infsetsum' f B - infsetsum' f A"
     and infsetsum'_converges_Diff: "infsetsum'_converges f (B-A)"
 proof -
   define limA limB where "limA = infsetsum' f A" and "limB = infsetsum' f B"
   from assms(1) have limB: "(sum f \<longlongrightarrow> limB) (finite_subsets_at_top B)"
     unfolding infsetsum'_converges_def infsetsum'_def limB_def
     by (auto simp: tendsto_Lim)
   from assms(2) have limA: "(sum f \<longlongrightarrow> limA) (finite_subsets_at_top A)"
     unfolding infsetsum'_converges_def infsetsum'_def limA_def
     by (auto simp: tendsto_Lim)
   have "((\<lambda>F. sum f (F\<inter>A)) \<longlongrightarrow> limA) (finite_subsets_at_top B)"
   proof (subst asm_rl [of "(\<lambda>F. sum f (F\<inter>A)) = sum f o (\<lambda>F. F\<inter>A)"])
     show "(\<lambda>F. sum f (F \<inter> A)) = sum f \<circ> (\<lambda>F. F \<inter> A)"
       unfolding o_def by auto
     show "((sum f \<circ> (\<lambda>F. F \<inter> A)) \<longlongrightarrow> limA) (finite_subsets_at_top B)"
-      unfolding o_def 
+      unfolding o_def
       using tendsto_compose_filtermap finite_subsets_at_top_inter[OF AB] limA tendsto_mono
         \<open>(\<lambda>F. sum f (F \<inter> A)) = sum f \<circ> (\<lambda>F. F \<inter> A)\<close> by fastforce
   qed
   with limB have "((\<lambda>F. sum f F - sum f (F\<inter>A)) \<longlongrightarrow> limB - limA) (finite_subsets_at_top B)"
     using tendsto_diff by blast
   have "sum f X - sum f (X \<inter> A) = sum f (X - A)"
     if "finite (X::'a set)"
       and "X \<subseteq> B"
     for X :: "'a set"
     using that by (metis add_diff_cancel_left' sum.Int_Diff)
   hence "\<forall>\<^sub>F x in finite_subsets_at_top B. sum f x - sum f (x \<inter> A) = sum f (x - A)"
-    by (rule eventually_finite_subsets_at_top_weakI)  
+    by (rule eventually_finite_subsets_at_top_weakI)
   hence "((\<lambda>F. sum f (F-A)) \<longlongrightarrow> limB - limA) (finite_subsets_at_top B)"
     using tendsto_cong [THEN iffD1 , rotated]
       \<open>((\<lambda>F. sum f F - sum f (F \<inter> A)) \<longlongrightarrow> limB - limA) (finite_subsets_at_top B)\<close> by fastforce
   hence "(sum f \<longlongrightarrow> limB - limA) (filtermap (\<lambda>F. F-A) (finite_subsets_at_top B))"
     by (subst tendsto_compose_filtermap[symmetric], simp add: o_def)
   hence limBA: "(sum f \<longlongrightarrow> limB - limA) (finite_subsets_at_top (B-A))"
     using finite_subsets_at_top_minus[OF AB] by (rule tendsto_mono[rotated])
   thus "infsetsum'_converges f (B-A)"
     unfolding infsetsum'_converges_def by auto
   with limBA show "infsetsum' f (B - A) = limB - limA"
-    unfolding infsetsum'_def by (simp add: tendsto_Lim) 
+    unfolding infsetsum'_def by (simp add: tendsto_Lim)
 qed
 
 lemma infsetsum'_mono_set:
   fixes f :: "'a\<Rightarrow>'b::{ordered_comm_monoid_add,linorder_topology}"
   assumes fx0: "\<And>x. x\<in>B-A \<Longrightarrow> f x \<ge> 0"
     and "A \<subseteq> B"
     and "infsetsum'_converges f A"
     and "infsetsum'_converges f B"
   shows "infsetsum' f B \<ge> infsetsum' f A"
 proof -
   define limA limB f' where "limA = infsetsum' f A" and "limB = infsetsum' f B"
     and "f' x = (if x \<in> A then f x else 0)" for x
   have "infsetsum' f A = infsetsum' f' B"
   proof (subst infsetsum'_subset_zero [where f = f' and B = A])
     show "f' x = 0"
       if "x \<in> B - A \<union> (A - B)"
       for x :: 'a
-      using that assms(2) f'_def by auto 
+      using that assms(2) f'_def by auto
     show "infsetsum' f A = infsetsum' f' A"
-      by (metis f'_def infsetsum'_cong)      
+      by (metis f'_def infsetsum'_cong)
   qed
   hence limA_def': "limA = infsetsum' f' B"
     unfolding limA_def
     by auto
   have convA': "infsetsum'_converges f' B"
   proof (rule infsetsum'_converges_subset_zero [THEN iffD1 , where A1 = A])
     show "f' x = 0"
       if "x \<in> A - B \<union> (B - A)"
       for x :: 'a
-      using that assms(2) f'_def by auto 
+      using that assms(2) f'_def by auto
     show "infsetsum'_converges f' A"
-      by (simp add: assms(3) f'_def infsetsum'_converges_cong)      
+      by (simp add: assms(3) f'_def infsetsum'_converges_cong)
   qed
-  from assms have limA: "(sum f \<longlongrightarrow> limA) (finite_subsets_at_top A)" 
+  from assms have limA: "(sum f \<longlongrightarrow> limA) (finite_subsets_at_top A)"
     and limB: "(sum f \<longlongrightarrow> limB) (finite_subsets_at_top B)"
     by (auto simp: limA_def limB_def infsetsum'_converges_def infsetsum'_def tendsto_Lim)
   have limA': "(sum f' \<longlongrightarrow> limA) (finite_subsets_at_top B)"
     using finite_subsets_at_top_neq_bot tendsto_Lim convA'
     unfolding limA_def' infsetsum'_def  infsetsum'_converges_def
-    by fastforce 
+    by fastforce
   have "f' i \<le> f i"
     if "i \<in> X" and "X \<subseteq> B"
     for i :: 'a and X
     unfolding f'_def using fx0 that
     using \<open>X \<subseteq> B\<close> by auto
   hence "sum f' X \<le> sum f X"
     if "finite (X::'a set)"
       and "X \<subseteq> B"
     for X :: "'a set"
     using sum_mono
-    by (simp add: sum_mono that(2)) 
+    by (simp add: sum_mono that(2))
   hence sumf'_leq_sumf: "\<forall>\<^sub>F x in finite_subsets_at_top B. sum f' x \<le> sum f x"
     by (rule eventually_finite_subsets_at_top_weakI)
   show "limA \<le> limB"
-    using finite_subsets_at_top_neq_bot limB limA' sumf'_leq_sumf 
+    using finite_subsets_at_top_neq_bot limB limA' sumf'_leq_sumf
     by (rule tendsto_le)
 qed
 
 lemma infsetsum'_converges_finite[simp]:
   assumes "finite F"
   shows "infsetsum'_converges f F"
   unfolding infsetsum'_converges_def finite_subsets_at_top_finite[OF assms]
-  using tendsto_principal_singleton by fastforce 
+  using tendsto_principal_singleton by fastforce
 
 lemma infsetsum'_finite[simp]:
   assumes "finite F"
   shows "infsetsum' f F = sum f F"
   using assms by (auto intro: tendsto_Lim simp: finite_subsets_at_top_finite infsetsum'_def principal_eq_bot_iff tendsto_principal_singleton)
 
 lemma infsetsum'_approx_sum:
   fixes f :: "'a \<Rightarrow> 'b::{comm_monoid_add,metric_space}"
   assumes "infsetsum'_converges f A" and "\<epsilon> > 0"
   shows "\<exists>F. finite F \<and> F \<subseteq> A \<and> dist (sum f F) (infsetsum' f A) \<le> \<epsilon>"
 proof-
   have "infsetsum'_converges f A \<Longrightarrow>
     0 < \<epsilon> \<Longrightarrow> (sum f \<longlongrightarrow> Lim (finite_subsets_at_top A) (sum f)) (finite_subsets_at_top A)"
     unfolding infsetsum'_converges_def
     using Lim_trivial_limit tendsto_Lim by blast
   hence "(sum f \<longlongrightarrow> infsetsum' f A) (finite_subsets_at_top A)"
     unfolding infsetsum'_def
     using assms
     by simp
   hence "\<forall>\<^sub>F F in (finite_subsets_at_top A). dist (sum f F) (infsetsum' f A) < \<epsilon>"
     using assms(2) by (rule tendstoD)
   have "finite X \<Longrightarrow>
          X \<subseteq> A \<Longrightarrow>
          \<forall>Y. finite Y \<and> X \<subseteq> Y \<and> Y \<subseteq> A \<longrightarrow> dist (sum f Y) (infsetsum' f A) < \<epsilon> \<Longrightarrow>
          \<exists>F. finite F \<and> F \<subseteq> A \<and> dist (sum f F) (infsetsum' f A) \<le> \<epsilon>"
     for X
-    by fastforce    
+    by fastforce
   thus ?thesis
     using eventually_finite_subsets_at_top
     by (metis (no_types, lifting)
         \<open>\<forall>\<^sub>F F in finite_subsets_at_top A. dist (sum f F) (infsetsum' f A) < \<epsilon>\<close>)
 qed
 
 lemma norm_infsetsum'_bound:
   fixes f :: "'b \<Rightarrow> 'a::real_normed_vector"
     and A :: "'b set"
   assumes a1: "infsetsum'_converges (\<lambda>x. norm (f x)) A"
   shows "norm (infsetsum' f A) \<le> (infsetsum' (\<lambda>x. norm (f x)) A)"
 proof(cases "infsetsum'_converges f A")
   case True
   have "norm (infsetsum' f A) \<le> (infsetsum' (\<lambda>x. norm (f x)) A) + \<epsilon>" if "\<epsilon>>0" for \<epsilon>
   proof-
     have "\<exists>F. norm (infsetsum' f A - sum f F) \<le> \<epsilon> \<and> finite F \<and> F \<subseteq> A"
       using infsetsum'_approx_sum[where A=A and f=f and \<epsilon>="\<epsilon>"] a1 True \<open>0 < \<epsilon>\<close>
       by (metis dist_commute dist_norm)
     then obtain F where "norm (infsetsum' f A - sum f F) \<le> \<epsilon>"
       and "finite F" and "F \<subseteq> A"
       by (simp add: atomize_elim)
     hence "norm (infsetsum' f A) \<le> norm (sum f F) + \<epsilon>"
       by (smt norm_triangle_sub)
     also have "\<dots> \<le> sum (\<lambda>x. norm (f x)) F + \<epsilon>"
       using norm_sum by auto
     also have "\<dots> \<le> (infsetsum' (\<lambda>x. norm (f x)) A) + \<epsilon>"
     proof-
       have "infsetsum' (\<lambda>x. norm (f x)) F \<le> infsetsum' (\<lambda>x. norm (f x)) A"
       proof (rule infsetsum'_mono_set)
         show "0 \<le> norm (f x)"
           if "x \<in> A - F"
           for x :: 'b
           using that
-          by simp 
+          by simp
         show "F \<subseteq> A"
-          by (simp add: \<open>F \<subseteq> A\<close>)          
+          by (simp add: \<open>F \<subseteq> A\<close>)
         show "infsetsum'_converges (\<lambda>x. norm (f x)) F"
-          using \<open>finite F\<close> by auto         
+          using \<open>finite F\<close> by auto
         show "infsetsum'_converges (\<lambda>x. norm (f x)) A"
-          by (simp add: assms)          
+          by (simp add: assms)
       qed
       thus ?thesis
         by (simp_all flip: infsetsum'_finite add: \<open>finite F\<close>)
     qed
-    finally show ?thesis 
+    finally show ?thesis
       by assumption
   qed
   thus ?thesis
     using linordered_field_class.field_le_epsilon by blast
 next
   case False
   obtain t where t_def: "(sum (\<lambda>x. norm (f x)) \<longlongrightarrow> t) (finite_subsets_at_top A)"
     using a1 unfolding infsetsum'_converges_def by blast
   have sumpos: "sum (\<lambda>x. norm (f x)) X \<ge> 0"
     for X
     by (simp add: sum_nonneg)
   have tgeq0:"t \<ge> 0"
   proof(rule ccontr)
     define S::"real set" where "S = {s. s < 0}"
     assume "\<not> 0 \<le> t"
     hence "t < 0" by simp
     hence "t \<in> S"
       unfolding S_def by blast
     moreover have "open S"
     proof-
       have "closed {s::real. s \<ge> 0}"
         using Elementary_Topology.closed_sequential_limits[where S = "{s::real. s \<ge> 0}"]
         by (metis Lim_bounded2 mem_Collect_eq)
       moreover have "{s::real. s \<ge> 0} = UNIV - S"
         unfolding S_def by auto
       ultimately have "closed (UNIV - S)"
         by simp
       thus ?thesis
-        by (simp add: Compl_eq_Diff_UNIV open_closed) 
+        by (simp add: Compl_eq_Diff_UNIV open_closed)
     qed
     ultimately have "\<forall>\<^sub>F X in finite_subsets_at_top A. (\<Sum>x\<in>X. norm (f x)) \<in> S"
       using t_def unfolding tendsto_def by blast
     hence "\<exists>X. (\<Sum>x\<in>X. norm (f x)) \<in> S"
       by (metis (no_types, lifting) False eventually_mono filterlim_iff infsetsum'_converges_def)
     then obtain X where "(\<Sum>x\<in>X. norm (f x)) \<in> S"
       by blast
     hence "(\<Sum>x\<in>X. norm (f x)) < 0"
-      unfolding S_def by auto      
+      unfolding S_def by auto
     thus False using sumpos by smt
   qed
   have "\<exists>!h. (sum (\<lambda>x. norm (f x)) \<longlongrightarrow> h) (finite_subsets_at_top A)"
     using t_def finite_subsets_at_top_neq_bot tendsto_unique by blast
   hence "t = (Topological_Spaces.Lim (finite_subsets_at_top A) (sum (\<lambda>x. norm (f x))))"
     using t_def unfolding Topological_Spaces.Lim_def
-    by (metis the_equality)     
+    by (metis the_equality)
   hence "Lim (finite_subsets_at_top A) (sum (\<lambda>x. norm (f x))) \<ge> 0"
     using tgeq0 by blast
-  thus ?thesis unfolding infsetsum'_def 
+  thus ?thesis unfolding infsetsum'_def
     using False by auto
 qed
 
 
 lemma infsetsum_infsetsum':
   assumes "f abs_summable_on A"
   shows "infsetsum f A = infsetsum' f A"
 proof-
   have conv_sum_norm[simp]: "infsetsum'_converges (\<lambda>x. norm (f x)) A"
   proof (rule abs_summable_infsetsum'_converges)
     show "(\<lambda>x. norm (f x)) abs_summable_on A"
       using assms by simp
-  qed    
+  qed
   have "norm (infsetsum f A - infsetsum' f A) \<le> \<epsilon>" if "\<epsilon>>0" for \<epsilon>
   proof -
     define \<delta> where "\<delta> = \<epsilon>/2"
     with that have [simp]: "\<delta> > 0" by simp
     obtain F1 where F1A: "F1 \<subseteq> A" and finF1: "finite F1" and leq_eps: "infsetsum (\<lambda>x. norm (f x)) (A-F1) \<le> \<delta>"
     proof -
       have sum_SUP: "ereal (infsetsum (\<lambda>x. norm (f x)) A) = (SUP F\<in>{F. finite F \<and> F \<subseteq> A}. ereal (sum (\<lambda>x. norm (f x)) F))"
         (is "_ = ?SUP")
       proof (rule infsetsum_nonneg_is_SUPREMUM_ereal)
         show "(\<lambda>x. norm (f x)) abs_summable_on A"
-          by (simp add: assms)          
+          by (simp add: assms)
         show "0 \<le> norm (f x)"
           if "x \<in> A"
           for x :: 'a
           using that
-          by simp 
+          by simp
       qed
 
       have "(SUP F\<in>{F. finite F \<and> F \<subseteq> A}. ereal (\<Sum>x\<in>F. norm (f x))) - ereal \<delta>
     < (SUP i\<in>{F. finite F \<and> F \<subseteq> A}. ereal (\<Sum>x\<in>i. norm (f x)))"
         using \<open>\<delta>>0\<close>
         by (metis diff_strict_left_mono diff_zero ereal_less_eq(3) ereal_minus(1) not_le sum_SUP)
       then obtain F where "F\<in>{F. finite F \<and> F \<subseteq> A}" and "ereal (sum (\<lambda>x. norm (f x)) F) > ?SUP - ereal (\<delta>)"
         by (meson less_SUP_iff)
 
       hence "sum (\<lambda>x. norm (f x)) F > infsetsum (\<lambda>x. norm (f x)) A -  (\<delta>)"
         unfolding sum_SUP[symmetric] by auto
       hence "\<delta> > infsetsum (\<lambda>x. norm (f x)) (A-F)"
       proof (subst infsetsum_Diff)
         show "(\<lambda>x. norm (f x)) abs_summable_on A"
           if "(\<Sum>\<^sub>ax\<in>A. norm (f x)) - \<delta> < (\<Sum>x\<in>F. norm (f x))"
           using that
-          by (simp add: assms) 
+          by (simp add: assms)
         show "F \<subseteq> A"
           if "(\<Sum>\<^sub>ax\<in>A. norm (f x)) - \<delta> < (\<Sum>x\<in>F. norm (f x))"
-          using that \<open>F \<in> {F. finite F \<and> F \<subseteq> A}\<close> by blast 
+          using that \<open>F \<in> {F. finite F \<and> F \<subseteq> A}\<close> by blast
         show "(\<Sum>\<^sub>ax\<in>A. norm (f x)) - (\<Sum>\<^sub>ax\<in>F. norm (f x)) < \<delta>"
           if "(\<Sum>\<^sub>ax\<in>A. norm (f x)) - \<delta> < (\<Sum>x\<in>F. norm (f x))"
-          using that \<open>F \<in> {F. finite F \<and> F \<subseteq> A}\<close> by auto 
+          using that \<open>F \<in> {F. finite F \<and> F \<subseteq> A}\<close> by auto
       qed
-      thus ?thesis using that 
+      thus ?thesis using that
         apply atomize_elim
         using \<open>F \<in> {F. finite F \<and> F \<subseteq> A}\<close> less_imp_le by blast
     qed
     have "\<exists>F2\<subseteq>A.
        finite F2 \<and>
        dist (\<Sum>x\<in>F2. norm (f x)) (infsetsum' (\<lambda>x. norm (f x)) A) \<le> \<delta>"
       using infsetsum'_approx_sum[where f="(\<lambda>x. norm (f x))" and A=A and \<epsilon>=\<delta>]
         abs_summable_infsetsum'_converges assms by auto
     then obtain F2 where F2A: "F2 \<subseteq> A" and finF2: "finite F2"
       and dist: "dist (sum (\<lambda>x. norm (f x)) F2) (infsetsum' (\<lambda>x. norm (f x)) A) \<le> \<delta>"
-      by blast     
+      by blast
     have  leq_eps': "infsetsum' (\<lambda>x. norm (f x)) (A-F2) \<le> \<delta>"
     proof (subst infsetsum'_Diff)
       show "infsetsum'_converges (\<lambda>x. norm (f x)) A"
-        by simp        
+        by simp
       show "infsetsum'_converges (\<lambda>x. norm (f x)) F2"
-        by (simp add: finF2)        
+        by (simp add: finF2)
       show "F2 \<subseteq> A"
-        by (simp add: F2A)        
+        by (simp add: F2A)
       show "infsetsum' (\<lambda>x. norm (f x)) A - infsetsum' (\<lambda>x. norm (f x)) F2 \<le> \<delta>"
         using dist finF2
         by (auto simp: dist_norm)
-    qed 
+    qed
     define F where "F = F1 \<union> F2"
-    have FA: "F \<subseteq> A" and finF: "finite F" 
+    have FA: "F \<subseteq> A" and finF: "finite F"
       unfolding F_def using F1A F2A finF1 finF2 by auto
 
     have "(\<Sum>\<^sub>ax\<in>A - (F1 \<union> F2). norm (f x)) \<le> (\<Sum>\<^sub>ax\<in>A - F1. norm (f x))"
     proof (rule infsetsum_mono_neutral_left)
       show "(\<lambda>x. norm (f x)) abs_summable_on A - (F1 \<union> F2)"
-        using abs_summable_on_subset assms by fastforce        
+        using abs_summable_on_subset assms by fastforce
       show "(\<lambda>x. norm (f x)) abs_summable_on A - F1"
-        using abs_summable_on_subset assms by fastforce        
+        using abs_summable_on_subset assms by fastforce
       show "norm (f x) \<le> norm (f x)"
         if "x \<in> A - (F1 \<union> F2)"
         for x :: 'a
         using that
-        by auto 
+        by auto
       show "A - (F1 \<union> F2) \<subseteq> A - F1"
-        by (simp add: Diff_mono)        
+        by (simp add: Diff_mono)
       show "0 \<le> norm (f x)"
         if "x \<in> A - F1 - (A - (F1 \<union> F2))"
         for x :: 'a
         using that
-        by auto 
+        by auto
     qed
     hence leq_eps: "infsetsum (\<lambda>x. norm (f x)) (A-F) \<le> \<delta>"
       unfolding F_def
       using leq_eps by linarith
     have "infsetsum' (\<lambda>x. norm (f x)) (A - (F1 \<union> F2))
     \<le> infsetsum' (\<lambda>x. norm (f x)) (A - F2)"
     proof (rule infsetsum'_mono_set)
       show "0 \<le> norm (f x)"
         if "x \<in> A - F2 - (A - (F1 \<union> F2))"
         for x :: 'a
         using that
-        by simp 
+        by simp
       show "A - (F1 \<union> F2) \<subseteq> A - F2"
-        by (simp add: Diff_mono)        
+        by (simp add: Diff_mono)
       show "infsetsum'_converges (\<lambda>x. norm (f x)) (A - (F1 \<union> F2))"
-        using F_def conv_sum_norm finF infsetsum'_converges_cofin_subset by blast        
+        using F_def conv_sum_norm finF infsetsum'_converges_cofin_subset by blast
       show "infsetsum'_converges (\<lambda>x. norm (f x)) (A - F2)"
-        by (simp add: finF2 infsetsum'_converges_cofin_subset)        
+        by (simp add: finF2 infsetsum'_converges_cofin_subset)
     qed
     hence leq_eps': "infsetsum' (\<lambda>x. norm (f x)) (A-F) \<le> \<delta>"
-      unfolding F_def 
+      unfolding F_def
       by (rule order.trans[OF _ leq_eps'])
     have "norm (infsetsum f A - infsetsum f F) = norm (infsetsum f (A-F))"
     proof (subst infsetsum_Diff [symmetric])
       show "f abs_summable_on A"
-        by (simp add: assms)          
+        by (simp add: assms)
       show "F \<subseteq> A"
-        by (simp add: FA)          
+        by (simp add: FA)
       show "norm (infsetsum f (A - F)) = norm (infsetsum f (A - F))"
-        by simp          
+        by simp
     qed
     also have "\<dots> \<le> infsetsum (\<lambda>x. norm (f x)) (A-F)"
       using norm_infsetsum_bound by blast
     also have "\<dots> \<le> \<delta>"
       using leq_eps by simp
     finally have diff1: "norm (infsetsum f A - infsetsum f F) \<le> \<delta>"
       by assumption
     have "norm (infsetsum' f A - infsetsum' f F) = norm (infsetsum' f (A-F))"
     proof (subst infsetsum'_Diff [symmetric])
       show "infsetsum'_converges f A"
-        by (simp add: abs_summable_infsetsum'_converges assms)        
+        by (simp add: abs_summable_infsetsum'_converges assms)
       show "infsetsum'_converges f F"
-        by (simp add: finF)        
+        by (simp add: finF)
       show "F \<subseteq> A"
-        by (simp add: FA)        
+        by (simp add: FA)
       show "norm (infsetsum' f (A - F)) = norm (infsetsum' f (A - F))"
-        by simp        
+        by simp
     qed
     also have "\<dots> \<le> infsetsum' (\<lambda>x. norm (f x)) (A-F)"
       by (simp add: finF infsetsum'_converges_cofin_subset norm_infsetsum'_bound)
     also have "\<dots> \<le> \<delta>"
       using leq_eps' by simp
     finally have diff2: "norm (infsetsum' f A - infsetsum' f F) \<le> \<delta>"
       by assumption
 
     have x1: "infsetsum f F = infsetsum' f F"
       using finF by simp
     have "norm (infsetsum f A - infsetsum' f A) \<le> norm (infsetsum f A - infsetsum f F) + norm (infsetsum' f A - infsetsum' f F)"
       apply (rule_tac norm_diff_triangle_le)
        apply auto
       by (simp_all add: x1 norm_minus_commute)
     also have "\<dots> \<le> \<epsilon>"
       using diff1 diff2 \<delta>_def by linarith
     finally show ?thesis
       by assumption
   qed
   hence "norm (infsetsum f A - infsetsum' f A) = 0"
     by (meson antisym_conv1 dense_ge norm_not_less_zero)
   thus ?thesis
     by auto
 qed
 
 lemma abs_summable_partition:
   fixes T :: "'b set" and I :: "'a set"
   assumes "\<And>i. f abs_summable_on S i"
     and "(\<lambda>i. \<Sum>\<^sub>ax\<in>S i. norm (f x)) abs_summable_on I"
     and "T \<subseteq> (\<Union>i\<in>I. S i)"
   shows "f abs_summable_on T"
 proof (rule abs_summable_finiteI)
   fix F assume finite_F: "finite F" and FT: "F \<subseteq> T"
   define index where "index s = (SOME i. i\<in>I \<and> s\<in>S i)" for s
   hence index_I: "index s \<in> I" and S_index: "s \<in> S (index s)" if "s \<in> (\<Union>i\<in>I. S i)" for s
   proof auto
     show "(SOME i. i \<in> I \<and> s \<in> S i) \<in> I"
       if "\<And>s. index s = (SOME i. i \<in> I \<and> s \<in> S i)"
       using that
-      by (metis (no_types, lifting) UN_iff \<open>s \<in> \<Union> (S ` I)\<close> someI_ex) 
+      by (metis (no_types, lifting) UN_iff \<open>s \<in> \<Union> (S ` I)\<close> someI_ex)
     show "s \<in> S (SOME i. i \<in> I \<and> s \<in> S i)"
       if "\<And>s. index s = (SOME i. i \<in> I \<and> s \<in> S i)"
       using that
-      by (metis (no_types, lifting) UN_iff \<open>s \<in> \<Union> (S ` I)\<close> someI_ex) 
+      by (metis (no_types, lifting) UN_iff \<open>s \<in> \<Union> (S ` I)\<close> someI_ex)
   qed
   define S' where "S' i = {s\<in>S i. i = index s}" for i
   have S'_S: "S' i \<subseteq> S i" for i
     unfolding S'_def by simp
   hence f_sum_S': "f abs_summable_on S' i" for i
     by (meson abs_summable_on_subset assms(1))
   with assms(1) S'_S have "(\<Sum>\<^sub>ax\<in>S' i. norm (f x)) \<le> (\<Sum>\<^sub>ax\<in>S i. norm (f x))" for i
     by (simp add: infsetsum_mono_neutral_left)
   with assms(2) have sum_I: "(\<lambda>i. \<Sum>\<^sub>ax\<in>S' i. norm (f x)) abs_summable_on I"
     by (smt abs_summable_on_comparison_test' infsetsum_cong norm_ge_zero norm_infsetsum_bound real_norm_def)
   have "(\<Union>i\<in>I. S i) = (\<Union>i\<in>I. S' i)"
     unfolding S'_def by (auto intro!: index_I S_index)
   with assms(3) have T_S': "T \<subseteq> (\<Union>i\<in>I. S' i)"
     by simp
   have S'_disj: "(S' i) \<inter> (S' j) = {}" if "i\<noteq>j" for i j
     unfolding S'_def disjnt_def using that by auto
 
   define B where "B i = (\<Sum>\<^sub>ax\<in>S i. norm (f x))" for i
   have sum_FS'_B: "(\<Sum>x\<in>F\<inter>S' i. norm (f x)) \<le> B i" for i
     unfolding B_def using f_sum_S' finite_F FT
-    by (metis S'_S abs_summable_finiteI_converse assms(1) finite_Int le_inf_iff order_refl 
+    by (metis S'_S abs_summable_finiteI_converse assms(1) finite_Int le_inf_iff order_refl
         subset_antisym)
   have B_pos[simp]: "B i \<ge> 0" for i
     unfolding B_def by (rule infsetsum_nonneg, simp)
   have B_sum_I[simp]: "B abs_summable_on I"
     by (simp add: B_def assms(2))
   define J where "J = {i\<in>I. F\<inter>S' i \<noteq> {}}"
   have finite_J[simp]: "finite J"
   proof -
     define a where "a i = (SOME x. x\<in>F\<inter>S' i)" for i
     hence a: "a i \<in> F\<inter>S' i" if "i \<in> J" for i
       unfolding J_def
       by (metis (mono_tags) Collect_conj_eq Int_Collect J_def some_in_eq that)
     have xy: "x = y"
       if "x \<in> J" and "y \<in> J" and "a x = a y" and "\<And>i. i \<in> J \<Longrightarrow> a i \<in> F \<and> a i \<in> S' i"
         and "\<And>i j. i \<noteq> j \<Longrightarrow> S' i \<inter> S' j = {}"
-        for x y     
+        for x y
       using that a S'_disj
       by (metis S'_disj disjoint_iff_not_equal)
     hence "inj_on a J"
       unfolding inj_on_def
-      using S'_disj a by auto 
+      using S'_disj a by auto
     moreover have "a ` J \<subseteq> F"
       using a by auto
     ultimately show "finite J"
       using finite_F Finite_Set.inj_on_finite by blast
   qed
   have JI[simp]: "J \<subseteq> I"
     unfolding J_def by simp
   have "F = (\<Union>i\<in>J. F\<inter>S' i)"
     unfolding J_def apply auto
     by (metis FT T_S' UN_E disjoint_iff_not_equal subsetD)
   hence "(\<Sum>x\<in>F. norm (f x)) = (\<Sum>x\<in>(\<Union>i\<in>J. F\<inter>S' i). norm (f x))"
     by simp
   also have "\<dots> = (\<Sum>i\<in>J. \<Sum>x\<in>F \<inter> S' i. norm (f x))"
   proof (rule sum.UNION_disjoint)
     show "finite J"
-      by simp      
+      by simp
     show "\<forall>i\<in>J. finite (F \<inter> S' i)"
-      by (simp add: finite_F)      
+      by (simp add: finite_F)
     show "\<forall>i\<in>J. \<forall>j\<in>J. i \<noteq> j \<longrightarrow> F \<inter> S' i \<inter> (F \<inter> S' j) = {}"
-      using S'_disj by auto      
+      using S'_disj by auto
   qed
   also have "\<dots> \<le> (\<Sum>i\<in>J. B i)"
     using sum_FS'_B
     by (simp add: ordered_comm_monoid_add_class.sum_mono)
   also have "\<dots> = (\<Sum>\<^sub>ai\<in>J. B i)"
     by simp
   also have "\<dots> \<le> (\<Sum>\<^sub>ai\<in>I. B i)"
   proof (rule infsetsum_mono_neutral_left)
     show "B abs_summable_on J"
-      by simp      
+      by simp
     show "B abs_summable_on I"
       by simp
     show "B x \<le> B x"
       if "x \<in> J"
       for x :: 'a
       using that
-      by simp 
+      by simp
     show "J \<subseteq> I"
-      by simp      
+      by simp
     show "0 \<le> B x"
       if "x \<in> I - J"
       for x :: 'a
       using that
-      by simp 
-  qed    
+      by simp
+  qed
   finally show "(\<Sum>x\<in>F. norm(f x)) \<le> (\<Sum>\<^sub>ai\<in>I. B i)"
     by simp
 qed
 
 lemma abs_summable_product':
   fixes X :: "'a set" and Y :: "'b set"
   assumes "\<And>x. (\<lambda>y. f (x,y)) abs_summable_on Y"
     and "(\<lambda>x. \<Sum>\<^sub>ay\<in>Y. norm (f (x,y))) abs_summable_on X"
   shows "f abs_summable_on X\<times>Y"
 proof-
   define S where "S x = {x} \<times> Y" for x :: 'a
   have bij[simp]: "bij_betw (Pair x) Y (S x)" for x
   proof (rule bij_betwI [where g = snd])
     show "Pair x \<in> Y \<rightarrow> S x"
-      by (simp add: S_def)      
+      by (simp add: S_def)
     show "snd \<in> S x \<rightarrow> Y"
-      using Pi_I' S_def by auto      
+      using Pi_I' S_def by auto
     show "snd (y, x::'b) = x"
       if "x \<in> Y"
       for x :: 'b and y::'a
       using that
-      by simp 
+      by simp
     show "(x, snd y::'b) = y"
       if "y \<in> S x"
       for y :: "'a \<times> 'b"
       using that
       unfolding S_def
       by auto
   qed
   have "f abs_summable_on S x" for x
   proof (subst abs_summable_on_reindex_bij_betw [symmetric , where A = Y and g = "\<lambda>y. (x,y)"])
     show "bij_betw (Pair x) Y (S x)"
-      by simp      
+      by simp
     show "(\<lambda>xa. f (x, xa)) abs_summable_on Y"
-      using assms(1) by auto      
+      using assms(1) by auto
   qed
   moreover have "bij_betw (Pair x) Y (S x)"
     for x
     unfolding S_def using bij_betw_def
     using S_def bij by auto
   hence "(\<Sum>\<^sub>ay\<in>Y. norm (f (x, y))) = (\<Sum>\<^sub>ay\<in>S x. norm (f y))" for x
-    by (rule infsetsum_reindex_bij_betw) 
+    by (rule infsetsum_reindex_bij_betw)
   hence "(\<lambda>i. \<Sum>\<^sub>ax\<in>S i. norm (f x)) abs_summable_on X"
     using assms(2) by simp
   hence "(\<lambda>i. \<Sum>\<^sub>ax\<in>S i. norm (f x)) abs_summable_on X"
     by auto
   moreover have "X \<times> Y \<subseteq> (\<Union>i\<in>X. S i)"
     unfolding S_def by auto
   ultimately show ?thesis
     by (rule abs_summable_partition[where S=S and I=X])
 qed
 
 lemma infsetsum_prod_PiE:
   fixes f :: "'a \<Rightarrow> 'b \<Rightarrow> 'c :: {real_normed_field,banach,second_countable_topology}"
   assumes finite: "finite A"
     and summable: "\<And>x. x \<in> A \<Longrightarrow> f x abs_summable_on B x"
   shows "infsetsum (\<lambda>g. \<Prod>x\<in>A. f x (g x)) (PiE A B) = (\<Prod>x\<in>A. infsetsum (f x) (B x))"
 proof-
   define B' where "B' x = {y\<in>B x. 0 \<noteq> f x y}" for x
   have [simp]: "B' x \<subseteq> B x" for x
     unfolding B'_def by simp
   have PiE_subset: "Pi\<^sub>E A B' \<subseteq> Pi\<^sub>E A B"
     by (simp add: PiE_mono)
   have "f x abs_summable_on B x"
     if "x\<in>A"
     for x
     using that
-    by (simp add: local.summable) 
+    by (simp add: local.summable)
   hence countable: "countable (B' x)" if "x\<in>A" for x
     unfolding B'_def using abs_summable_countable
     using that by blast
   have summable: "f x abs_summable_on B' x" if "x\<in>A" for x
     using that summable[where x = x] \<open>\<And>x. B' x \<subseteq> B x\<close> abs_summable_on_subset by blast
   have 0: "(\<Prod>x\<in>A. f x (g x)) = 0" if "g \<in> Pi\<^sub>E A B - Pi\<^sub>E A B'" for g
   proof-
     from that have "g \<in> extensional A"
       by (simp add: PiE_def)
     from that have "g \<notin> Pi\<^sub>E A B'"
       by simp
     with \<open>g \<in> extensional A\<close> have "g \<notin> Pi A B'"
       unfolding PiE_def by simp
     then obtain x where "x\<in>A" and "g x \<notin> B' x"
       unfolding Pi_def by auto
     hence "f x (g x) = 0"
       unfolding B'_def using that by auto
     with finite show ?thesis
     proof (rule_tac prod_zero)
       show "finite A"
         if "finite A"
           and "f x (g x) = 0"
         using that
-        by simp 
+        by simp
       show "\<exists>a\<in>A. f a (g a) = 0"
         if "finite A"
           and "f x (g x) = 0"
-        using that \<open>x \<in> A\<close> by blast 
-    qed      
+        using that \<open>x \<in> A\<close> by blast
+    qed
   qed
 
   have d: "infsetsum (f x) (B' x) = infsetsum (f x) (B x)"
     if "x \<in> A"
     for x
   proof (rule infsetsum_cong_neutral)
     show "f y x = 0"
       if "x \<in> B' y - B y"
       for x :: 'b and y :: 'a
       using that
-      by (meson DiffD1 DiffD2 \<open>\<And>x. B' x \<subseteq> B x\<close> in_mono) 
+      by (meson DiffD1 DiffD2 \<open>\<And>x. B' x \<subseteq> B x\<close> in_mono)
     show "f y x = 0"
       if "x \<in> B y - B' y"
       for x :: 'b and y
-      using that B'_def by auto 
+      using that B'_def by auto
     show "f y x = f y x"
       if "x \<in> B' y \<inter> B y"
       for x :: 'b and y
       using that
-      by simp 
-  qed    
+      by simp
+  qed
   have "infsetsum (\<lambda>g. \<Prod>x\<in>A. f x (g x)) (PiE A B)
       = infsetsum (\<lambda>g. \<Prod>x\<in>A. f x (g x)) (PiE A B')"
   proof (rule infsetsum_cong_neutral)
     show "(\<Prod>a\<in>A. f a (x a)) = 0"
       if "x \<in> Pi\<^sub>E A B - Pi\<^sub>E A B'"
       for x :: "'a \<Rightarrow> 'b"
       using that
-      by (simp add: "0") 
+      by (simp add: "0")
     show "(\<Prod>a\<in>A. f a (x a)) = 0"
       if "x \<in> Pi\<^sub>E A B' - Pi\<^sub>E A B"
       for x :: "'a \<Rightarrow> 'b"
-      using that PiE_subset by auto 
+      using that PiE_subset by auto
     show "(\<Prod>a\<in>A. f a (x a)) = (\<Prod>a\<in>A. f a (x a))"
       if "x \<in> Pi\<^sub>E A B \<inter> Pi\<^sub>E A B'"
       for x :: "'a \<Rightarrow> 'b"
       using that
-      by simp 
+      by simp
   qed
   also have "\<dots> = (\<Prod>x\<in>A. infsetsum (f x) (B' x))"
     using finite countable summable by (rule infsetsum_prod_PiE)
   also have "\<dots> = (\<Prod>x\<in>A. infsetsum (f x) (B x))"
     using d
     by auto
   finally show ?thesis.
 qed
 
 
 lemma infsetsum_0D:
   fixes f :: "'a \<Rightarrow> real"
   assumes "infsetsum f A = 0"
     and abs_sum: "f abs_summable_on A"
     and nneg: "\<And>x. x \<in> A \<Longrightarrow> f x \<ge> 0"
     and "x \<in> A"
   shows "f x = 0"
 proof -
   from abs_sum have [simp]: "f abs_summable_on (A-{x})"
     by (meson Diff_subset abs_summable_on_subset)
   from abs_sum \<open>x\<in>A\<close> have [simp]: "f abs_summable_on {x}"
     by auto
   have a: "\<And>a. a \<in> A - {x} \<Longrightarrow> a \<in> A"
-    by simp   
+    by simp
   from assms have "0 = infsetsum f A"
     by simp
   also have "\<dots> = infsetsum f (A-{x}) + infsetsum f {x}"
   proof (subst infsetsum_Un_disjoint [symmetric])
     show "f abs_summable_on A - {x}"
-      by simp      
+      by simp
     show "f abs_summable_on {x}"
-      by simp      
+      by simp
     show "(A - {x}) \<inter> {x} = {}"
-      by simp      
+      by simp
     show "infsetsum f A = infsetsum f (A - {x} \<union> {x})"
-      using assms(4) insert_Diff by fastforce      
+      using assms(4) insert_Diff by fastforce
   qed
   also have "\<dots> \<ge> 0 + infsetsum f {x}" (is "_ \<ge> \<dots>")
     using a
-    by (smt infsetsum_nonneg nneg)    
+    by (smt infsetsum_nonneg nneg)
   also have "\<dots> = f x"
     by simp
   finally have "f x \<le> 0".
   with nneg[OF \<open>x\<in>A\<close>] show "f x = 0"
     by auto
 qed
 
 lemma sum_leq_infsetsum:
   fixes f :: "_ \<Rightarrow> real"
   assumes "f abs_summable_on N"
     and "finite M"
     and "M \<subseteq> N"
     and "\<And>x. x\<in>N-M \<Longrightarrow> f x \<ge> 0"
   shows "sum f M \<le> infsetsum f N"
 proof -
   have "infsetsum f M \<le> infsetsum f N"
   proof (rule infsetsum_mono_neutral_left)
     show "f abs_summable_on M"
-      by (simp add: assms(2))      
+      by (simp add: assms(2))
     show "f abs_summable_on N"
-      by (simp add: assms(1))      
+      by (simp add: assms(1))
     show "f x \<le> f x"
       if "x \<in> M"
       for x :: 'b
       using that
-      by simp 
+      by simp
     show "M \<subseteq> N"
-      by (simp add: assms(3))      
+      by (simp add: assms(3))
     show "0 \<le> f x"
       if "x \<in> N - M"
       for x :: 'b
       using that
-      by (simp add: assms(4)) 
+      by (simp add: assms(4))
   qed
   thus ?thesis
     using assms by auto
 qed
 
 lemma infsetsum_cmult_left':
   fixes f :: "'a \<Rightarrow> 'b :: {banach, real_normed_algebra, second_countable_topology, division_ring}"
   shows  "infsetsum (\<lambda>x. f x * c) A = infsetsum f A * c"
 proof (cases "c \<noteq> 0 \<longrightarrow> f abs_summable_on A")
   case True
   have "(\<Sum>\<^sub>ax\<in>A. f x * c) = infsetsum f A * c"
     if "f abs_summable_on A"
     using infsetsum_cmult_left that by blast
   thus ?thesis
-    using True by auto     
+    using True by auto
 next
   case False
   hence "c\<noteq>0" and "\<not> f abs_summable_on A"
     by auto
   have "\<not> (\<lambda>x. f x * c) abs_summable_on A"
   proof (rule notI)
     assume "(\<lambda>x. f x * c) abs_summable_on A"
     hence "(\<lambda>x. (f x * c) * inverse c) abs_summable_on A"
       by (rule abs_summable_on_cmult_left)
     with \<open>\<not> f abs_summable_on A\<close> show False
       by (metis (no_types, lifting) False Groups.mult_ac(1) abs_summable_on_cong mult_1_right
           right_inverse)
   qed
   with \<open>\<not> f abs_summable_on A\<close>
-  show ?thesis 
+  show ?thesis
     by (simp add: not_summable_infsetsum_eq)
 qed
 
 lemma abs_summable_on_zero_diff:
   assumes "f abs_summable_on A"
     and "\<And>x. x \<in> B - A \<Longrightarrow> f x = 0"
   shows "f abs_summable_on B"
 proof (subst asm_rl [of "B = (B-A) \<union> (A\<inter>B)"])
   show "B = B - A \<union> A \<inter> B"
     by auto
   have "(\<lambda>x. 0::real) abs_summable_on B - A"
-    by simp    
+    by simp
   moreover have "norm (f x) \<le> 0"
     if "x \<in> B - A"
     for x :: 'a
     using that
-    by (simp add: assms(2)) 
+    by (simp add: assms(2))
   ultimately have "f abs_summable_on B - A"
-    by (rule abs_summable_on_comparison_test' [where g = "\<lambda>x. 0"])   
+    by (rule abs_summable_on_comparison_test' [where g = "\<lambda>x. 0"])
   moreover have "f abs_summable_on A \<inter> B"
     using abs_summable_on_subset assms(1) by blast
   ultimately show "f abs_summable_on B - A \<union> A \<inter> B"
-    by (rule abs_summable_on_union)    
+    by (rule abs_summable_on_union)
 qed
 
 lemma abs_summable_on_Sigma_iff:
   "f abs_summable_on Sigma A B \<longleftrightarrow>
              (\<forall>x\<in>A. (\<lambda>y. f (x, y)) abs_summable_on B x) \<and>
              ((\<lambda>x. infsetsum (\<lambda>y. norm (f (x, y))) (B x)) abs_summable_on A)"
 proof auto
   assume sum_AB: "f abs_summable_on Sigma A B"
   define S' where "S' = {x\<in>Sigma A B. 0 \<noteq> f x}"
   from sum_AB have "countable S'"
     unfolding S'_def by (rule abs_summable_countable)
   define A' B' where "A' = fst ` S'" and "B' x = B x \<inter> snd ` S'" for x
   have A'A: \<open>A' \<subseteq> A\<close> and B'B: \<open>B' x \<subseteq> B x\<close> for x
     unfolding A'_def B'_def S'_def by auto
   have  cntA: "countable A'" and cntB: "countable (B' x)" for x
     unfolding A'_def B'_def using \<open>countable S'\<close> by auto
   have f0: "f (x,y) = 0" if "x \<in> A - A'" and "y \<in> B x" for x y
   proof -
     from that have "(x,y) \<in> Sigma A B"
       by auto
     moreover from that have "(x,y) \<notin> S'"
       unfolding A'_def
-      by (metis image_eqI mem_simps(6) prod.sel(1)) 
+      by (metis image_eqI mem_simps(6) prod.sel(1))
     ultimately show "f (x,y) = 0"
       unfolding S'_def by auto
   qed
   have f0': "f (x,y) = 0" if "x \<in> A" and "y \<in> B x - B' x" for x y
   proof -
     from that have "(x,y) \<in> Sigma A B"
       by auto
     moreover from that have "(x,y) \<notin> S'"
       unfolding B'_def
       by (auto simp add: rev_image_eqI)
     ultimately show "f (x,y) = 0"
       unfolding S'_def by auto
   qed
   have "Sigma A' B' \<subseteq> Sigma A B"
     using A'A B'B by (rule Sigma_mono)
   hence sum_A'B': "f abs_summable_on Sigma A' B'"
-    using sum_AB abs_summable_on_subset by auto 
+    using sum_AB abs_summable_on_subset by auto
   from sum_A'B' have "(\<lambda>y. f (x, y)) abs_summable_on B' x" if "x \<in> A'" for x
     using abs_summable_on_Sigma_iff[OF cntA cntB, where f=f] that by auto
-  moreover have "(\<lambda>y. f (x, y)) abs_summable_on B' x" 
-    if t:"x \<in> A - A'" 
+  moreover have "(\<lambda>y. f (x, y)) abs_summable_on B' x"
+    if t:"x \<in> A - A'"
     for x
   proof (subst abs_summable_on_zero_diff [where A = "{}"])
     show "(\<lambda>y. f (x, y)) abs_summable_on {}"
       by simp
     have "f (x, a) = 0"
       if "a \<in> B' x"
       for a
       using t f0 that B'B
       by auto
     thus "f (x, a) = 0"
       if "a \<in> B' x - {}"
       for a
-      using that by auto 
+      using that by auto
     show True by blast
-  qed     
+  qed
   ultimately have "(\<lambda>y. f (x, y)) abs_summable_on B' x" if "x \<in> A" for x
     using that by auto
   thus "(\<lambda>y. f (x, y)) abs_summable_on B x" if "x \<in> A" for x
     apply (rule abs_summable_on_zero_diff)
     using that f0' by auto
 
   have Q: "\<And>x. x \<in> A - A' \<Longrightarrow> (\<Sum>\<^sub>ay\<in>B' x. norm (f (x, y))) = 0"
     apply (subst infsetsum_cong[where g=\<open>\<lambda>x. 0\<close> and B="B' _"])
     using f0 B'B by auto
 
   from sum_A'B' have "(\<lambda>x. infsetsum (\<lambda>y. norm (f (x, y))) (B' x)) abs_summable_on A'"
     using abs_summable_on_Sigma_iff[OF cntA cntB, where f=f] by auto
   hence "(\<lambda>x. infsetsum (\<lambda>y. norm (f (x, y))) (B' x)) abs_summable_on A"
     apply (rule abs_summable_on_zero_diff)
     using Q by auto
   have R: "\<And>x. x \<in> A \<Longrightarrow>
          (\<Sum>\<^sub>ay\<in>B' x. norm (f (x, y))) =
          (\<Sum>\<^sub>ay\<in>B x. norm (f (x, y)))"
   proof (rule infsetsum_cong_neutral)
     show "norm (f (x, a)) = 0"
       if "x \<in> A"
         and "a \<in> B' x - B x"
       for x :: 'a
         and a :: 'b
-      using that B'B by blast 
+      using that B'B by blast
     show "norm (f (x, a)) = 0"
       if "x \<in> A"
         and "a \<in> B x - B' x"
       for x :: 'a
         and a :: 'b
       using that
-      by (simp add: f0') 
+      by (simp add: f0')
     show "norm (f (x, a)) = norm (f (x, a))"
       if "x \<in> A"
         and "a \<in> B' x \<inter> B x"
       for x :: 'a
         and a :: 'b
       using that
-      by simp 
+      by simp
   qed
-  thus "(\<lambda>x. infsetsum (\<lambda>y. norm (f (x, y))) (B x)) abs_summable_on A"    
-    using \<open>(\<lambda>x. \<Sum>\<^sub>ay\<in>B' x. norm (f (x, y))) abs_summable_on A\<close> by auto 
+  thus "(\<lambda>x. infsetsum (\<lambda>y. norm (f (x, y))) (B x)) abs_summable_on A"
+    using \<open>(\<lambda>x. \<Sum>\<^sub>ay\<in>B' x. norm (f (x, y))) abs_summable_on A\<close> by auto
 next
   assume sum_B: "\<forall>x\<in>A. (\<lambda>y. f (x, y)) abs_summable_on B x"
   assume sum_A: "(\<lambda>x. \<Sum>\<^sub>ay\<in>B x. norm (f (x, y))) abs_summable_on A"
   define B' where "B' x = {y\<in>B x. 0 \<noteq> f (x,y)}" for x
   from sum_B have cnt_B': "countable (B' x)" if "x\<in>A" for x
     unfolding B'_def apply (rule_tac abs_summable_countable)
     using that by auto
   define A' where "A' = {x\<in>A. 0 \<noteq> (\<Sum>\<^sub>ay\<in>B x. norm (f (x, y)))}"
   from sum_A have cnt_A': "countable A'"
     unfolding A'_def by (rule abs_summable_countable)
   have A'A: "A' \<subseteq> A" and B'B: "B' x \<subseteq> B x" for x
     unfolding A'_def B'_def by auto
   have f0': "f (x,y) = 0" if "y \<in> B x - B' x" for x y
     using that unfolding B'_def by auto
   have f0: "f (x,y) = 0" if "x \<in> A - A'" and "y \<in> B x" for x y
   proof -
     have "(\<Sum>\<^sub>ay\<in>B x. norm (f (x, y))) = 0"
       using that unfolding A'_def by auto
     hence "norm (f (x, y)) = 0"
       apply (rule infsetsum_0D)
       using sum_B that by auto
     thus ?thesis
       by auto
   qed
 
   from sum_B have sum_B': "(\<lambda>y. f (x, y)) abs_summable_on B' x" if "x\<in>A" for x
   proof (rule_tac abs_summable_on_subset [where B = "B x"])
     show "(\<lambda>y. f (x, y)) abs_summable_on B x"
       if "\<forall>x\<in>A. (\<lambda>y. f (x, y)) abs_summable_on B x"
-      using that \<open>x \<in> A\<close> by blast 
+      using that \<open>x \<in> A\<close> by blast
     show "B' x \<subseteq> B x"
       if "\<forall>x\<in>A. (\<lambda>y. f (x, y)) abs_summable_on B x"
       using that
-      by (simp add: B'B) 
+      by (simp add: B'B)
   qed
   have *: "(\<Sum>\<^sub>ay\<in>B x. norm (f (x, y))) = (\<Sum>\<^sub>ay\<in>B' x. norm (f (x, y)))" if "x\<in>A" for x
     using infsetsum_cong_neutral f0' B'B that
     by (metis (no_types, lifting) DiffD1 DiffD2 Int_iff inf.absorb_iff2 norm_zero)
   have "(\<lambda>x. \<Sum>\<^sub>ay\<in>B' x. norm (f (x, y))) abs_summable_on A"
     using abs_summable_on_cong sum_A "*" by auto
   hence sum_A': "(\<lambda>x. \<Sum>\<^sub>ay\<in>B' x. norm (f (x, y))) abs_summable_on A'"
-    using _ A'A abs_summable_on_subset by blast 
+    using _ A'A abs_summable_on_subset by blast
   from sum_A' sum_B'
   have "f abs_summable_on Sigma A' B'"
     using abs_summable_on_Sigma_iff[where A=A' and B=B' and f=f, OF cnt_A' cnt_B'] A'A by auto
   moreover have "f x = 0"
     if "x \<in> Sigma A B - Sigma A' B'" for x
-    using that f0 f0' by force     
+    using that f0 f0' by force
   ultimately show "f abs_summable_on Sigma A B"
     by (rule abs_summable_on_zero_diff)
 qed
 
 lemma
   fixes f :: "'a \<Rightarrow> 'c :: {banach, real_normed_field, second_countable_topology}"
   assumes "f abs_summable_on A" and "g abs_summable_on B"
   shows   abs_summable_on_product: "(\<lambda>(x,y). f x * g y) abs_summable_on A \<times> B"
     and   infsetsum_product: "infsetsum (\<lambda>(x,y). f x * g y) (A \<times> B) =
                                 infsetsum f A * infsetsum g B"
 proof -
   from assms show "(\<lambda>(x,y). f x * g y) abs_summable_on A \<times> B"
     by (subst abs_summable_on_Sigma_iff)
       (auto simp: norm_mult infsetsum_cmult_right)
   with assms show "infsetsum (\<lambda>(x,y). f x * g y) (A \<times> B) = infsetsum f A * infsetsum g B"
     by (subst infsetsum_Sigma)
       (auto simp: infsetsum_cmult_left infsetsum_cmult_right)
 qed
 
 
 
 lemma infsetsum'_converges_ennreal: \<open>infsetsum'_converges (f::_ \<Rightarrow> ennreal) S\<close>
 proof -
   define B where \<open>B = (SUP F\<in>{F. F \<subseteq> S \<and> finite F}. sum f F)\<close>
 
   have upper: \<open>\<forall>\<^sub>F F in finite_subsets_at_top S. sum f F \<le> B\<close>
     apply (rule eventually_finite_subsets_at_top_weakI)
     unfolding B_def
     by (simp add: SUP_upper)
   have lower: \<open>\<forall>\<^sub>F n in finite_subsets_at_top S. x < sum f n\<close> if \<open>x < B\<close> for x
   proof -
     obtain F where Fx: \<open>sum f F > x\<close> and \<open>F \<subseteq> S\<close> and \<open>finite F\<close>
       using \<open>x < B\<close> unfolding B_def
       by (metis (mono_tags, lifting)  less_SUP_iff mem_Collect_eq)
     have geq: \<open>sum f Y \<ge> sum f F\<close> if \<open>finite Y\<close> and \<open>Y \<supseteq> F\<close> for Y
       by (simp add: sum_mono2 that(1) that(2))
     show ?thesis
       unfolding eventually_finite_subsets_at_top
       apply (rule exI[of _ F])
       using \<open>finite F\<close> \<open>F \<subseteq> S\<close> Fx geq by force
   qed
 
   show ?thesis
     unfolding infsetsum'_converges_def
     apply (rule exI[of _ B])
     using upper lower by (rule increasing_tendsto)
 qed
 
 lemma infsetsum'_superconst_infinite:
   assumes geqb: \<open>\<And>x. x \<in> S \<Longrightarrow> f x \<ge> b\<close>
   assumes b: \<open>b > 0\<close>
   assumes \<open>infinite S\<close>
   shows "infsetsum' f S = (\<infinity>::ennreal)"
 proof -
   have \<open>(sum f \<longlongrightarrow> \<infinity>) (finite_subsets_at_top S)\<close>
   proof (rule order_tendstoI[rotated], simp)
     fix y :: ennreal assume \<open>y < \<infinity>\<close>
     then have \<open>y / b < \<infinity>\<close>
       by (metis b ennreal_divide_eq_top_iff gr_implies_not_zero infinity_ennreal_def top.not_eq_extremum)
     then obtain F where \<open>finite F\<close> and \<open>F \<subseteq> S\<close> and cardF: \<open>card F > y / b\<close>
       using \<open>infinite S\<close>
       by (metis ennreal_Ex_less_of_nat infinite_arbitrarily_large infinity_ennreal_def)
     moreover have \<open>sum f Y > y\<close> if \<open>finite Y\<close> and \<open>F \<subseteq> Y\<close> and \<open>Y \<subseteq> S\<close> for Y
     proof -
       have \<open>y < b * card F\<close>
         by (metis \<open>y < \<infinity>\<close> b cardF divide_less_ennreal ennreal_mult_eq_top_iff gr_implies_not_zero infinity_ennreal_def mult.commute top.not_eq_extremum)
       also have \<open>\<dots> \<le> b * card Y\<close>
         by (meson b card_mono less_imp_le mult_left_mono of_nat_le_iff that(1) that(2))
       also have \<open>\<dots> = sum (\<lambda>_. b) Y\<close>
         by (simp add: mult.commute)
       also have \<open>\<dots> \<le> sum f Y\<close>
         using geqb by (meson subset_eq sum_mono that(3))
       finally show ?thesis
         by -
     qed
     ultimately show \<open>\<forall>\<^sub>F x in finite_subsets_at_top S. y < sum f x\<close>
-      unfolding eventually_finite_subsets_at_top 
+      unfolding eventually_finite_subsets_at_top
       by auto
   qed
   then show ?thesis
-    unfolding infsetsum'_def 
+    unfolding infsetsum'_def
     apply (simp add: infsetsum'_converges_ennreal)
     by (simp add: tendsto_Lim)
 qed
 
 lemma infsetsum'_tendsto:
   assumes \<open>infsetsum'_converges f S\<close>
   shows \<open>((\<lambda>F. sum f F) \<longlongrightarrow> infsetsum' f S) (finite_subsets_at_top S)\<close>
   by (metis assms finite_subsets_at_top_neq_bot infsetsum'_converges_def infsetsum'_def tendsto_Lim)
 
 lemma infsetsum'_constant[simp]:
   assumes \<open>finite F\<close>
   shows \<open>infsetsum' (\<lambda>_. c) F = of_nat (card F) * c\<close>
   apply (subst infsetsum'_finite[OF assms])
   by simp
 
 lemma infsetsum'_zero[simp]:
   shows \<open>infsetsum' (\<lambda>_. 0) S = 0\<close>
   unfolding infsetsum'_def sum.neutral_const
   by (simp add: tendsto_Lim)
 
 lemma
   fixes f g :: "'a \<Rightarrow> 'b::{topological_monoid_add, t2_space, comm_monoid_add}"
   assumes \<open>infsetsum'_converges f A\<close>
   assumes \<open>infsetsum'_converges g A\<close>
   shows infsetsum'_add: \<open>infsetsum' (\<lambda>x. f x + g x) A = infsetsum' f A + infsetsum' g A\<close>
     and infsetsum'_converges_add: \<open>infsetsum'_converges (\<lambda>x. f x + g x) A\<close>
 proof -
   note lim_f = infsetsum'_tendsto[OF assms(1)]
     and lim_g = infsetsum'_tendsto[OF assms(2)]
   then have lim: \<open>(sum (\<lambda>x. f x + g x) \<longlongrightarrow> infsetsum' f A + infsetsum' g A) (finite_subsets_at_top A)\<close>
     unfolding sum.distrib
     by (rule tendsto_add)
   then show conv: \<open>infsetsum'_converges (\<lambda>x. f x + g x) A\<close>
     unfolding infsetsum'_converges_def by auto
   show \<open>infsetsum' (\<lambda>x. f x + g x) A = infsetsum' f A + infsetsum' g A\<close>
-    unfolding infsetsum'_def 
+    unfolding infsetsum'_def
     using lim_f lim_g lim
     by (auto simp: assms conv tendsto_Lim)
 qed
 
-lemma 
+lemma
   fixes f :: "'a \<Rightarrow> 'b::{topological_monoid_add, t2_space, comm_monoid_add}"
   assumes "infsetsum'_converges f A"
   assumes "infsetsum'_converges f B"
   assumes disj: "A \<inter> B = {}"
   shows infsetsum'_Un_disjoint: \<open>infsetsum' f (A \<union> B) = infsetsum' f A + infsetsum' f B\<close>
     and infsetsum'_converges_Un_disjoint: \<open>infsetsum'_converges f (A \<union> B)\<close>
 proof -
   define fA fB where \<open>fA x = (if x \<in> A then f x else 0)\<close>
     and \<open>fB x = (if x \<notin> A then f x else 0)\<close> for x
   have conv_fA: \<open>infsetsum'_converges fA (A \<union> B)\<close>
     unfolding fA_def
     apply (subst infsetsum'_converges_subset_zero, auto)
     by (simp add: assms(1) infsetsum'_converges_cong)
   have conv_fB: \<open>infsetsum'_converges fB (A \<union> B)\<close>
     unfolding fB_def
     apply (subst infsetsum'_converges_subset_zero, auto)
     by (smt (verit, ccfv_SIG) assms(2) assms(3) disjoint_iff infsetsum'_converges_cong)
   have fAB: \<open>f x = fA x + fB x\<close> for x
     unfolding fA_def fB_def by simp
   have \<open>infsetsum' f (A \<union> B) = infsetsum' fA (A \<union> B) + infsetsum' fB (A \<union> B)\<close>
     unfolding fAB
     using conv_fA conv_fB by (rule infsetsum'_add)
   also have \<open>\<dots> = infsetsum' fA A + infsetsum' fB B\<close>
     unfolding fA_def fB_def
     by (subst infsetsum'_subset_zero[where A=\<open>A\<union>B\<close>], auto)+
   also have \<open>\<dots> = infsetsum' f A + infsetsum' f B\<close>
     apply (subst infsetsum'_cong[where f=fA and g=f], simp add: fA_def)
     apply (subst infsetsum'_cong[where f=fB and g=f], simp add: fB_def)
     using disj by auto
   finally show \<open>infsetsum' f (A \<union> B) = infsetsum' f A + infsetsum' f B\<close>
     by -
   from conv_fA conv_fB
   have \<open>infsetsum'_converges (\<lambda>x. fA x + fB x) (A \<union> B)\<close>
     by (rule infsetsum'_converges_add)
   then show \<open>infsetsum'_converges f (A \<union> B)\<close>
     unfolding fAB by -
 qed
 
 lemma infsetsum'_converges_union_disjoint:
   fixes f :: "'a \<Rightarrow> 'b::{topological_monoid_add, t2_space, comm_monoid_add}"
   assumes finite: \<open>finite A\<close>
   assumes conv: \<open>\<And>a. a \<in> A \<Longrightarrow> infsetsum'_converges f (B a)\<close>
   assumes disj: \<open>\<And>a a'. a\<in>A \<Longrightarrow> a'\<in>A \<Longrightarrow> a\<noteq>a' \<Longrightarrow> B a \<inter> B a' = {}\<close>
   shows \<open>infsetsum'_converges f (\<Union>a\<in>A. B a)\<close>
   using finite conv disj apply induction by (auto intro!: infsetsum'_converges_Un_disjoint)
 
 lemma sum_infsetsum':
   fixes f :: "'a \<Rightarrow> 'b::{topological_monoid_add, t2_space, comm_monoid_add}"
   assumes finite: \<open>finite A\<close>
   assumes conv: \<open>\<And>a. a \<in> A \<Longrightarrow> infsetsum'_converges f (B a)\<close>
   assumes disj: \<open>\<And>a a'. a\<in>A \<Longrightarrow> a'\<in>A \<Longrightarrow> a\<noteq>a' \<Longrightarrow> B a \<inter> B a' = {}\<close>
   shows \<open>sum (\<lambda>a. infsetsum' f (B a)) A = infsetsum' f (\<Union>a\<in>A. B a)\<close>
   using assms
 proof (insert finite conv disj, induction)
   case empty
-  then show ?case 
+  then show ?case
     by simp
 next
   case (insert x F)
   have \<open>(\<Sum>a\<in>insert x F. infsetsum' f (B a)) = infsetsum' f (B x) + (\<Sum>a\<in>F. infsetsum' f (B a))\<close>
     apply (subst sum.insert) using insert by auto
   also have \<open>\<dots> = infsetsum' f (B x) + infsetsum' f (\<Union> (B ` F))\<close>
     apply (subst insert.IH) using assms insert by auto
   also have \<open>\<dots> = infsetsum' f (B x \<union> \<Union> (B ` F))\<close>
     apply (rule infsetsum'_Un_disjoint[symmetric])
     using insert.prems insert.hyps by (auto simp: infsetsum'_converges_union_disjoint)
   also have \<open>\<dots> = infsetsum' f (\<Union>a\<in>insert x F. B a)\<close>
     by auto
   finally show ?case
     by -
 qed
 
 theorem infsetsum'_mono:
   fixes f g :: "'a\<Rightarrow>'b::{ordered_comm_monoid_add,linorder_topology}"
   assumes "infsetsum'_converges f A"
     and "infsetsum'_converges g A"
   assumes leq: "\<And>x. x \<in> A \<Longrightarrow> f x \<le> g x"
   shows "infsetsum' f A \<le> infsetsum' g A"
 proof -
   note limf = infsetsum'_tendsto[OF assms(1)]
     and limg =  infsetsum'_tendsto[OF assms(2)]
   have sum_leq: \<open>\<And>F. finite F \<Longrightarrow> F \<subseteq> A \<Longrightarrow> sum f F \<le> sum g F\<close>
     by (simp add: in_mono leq sum_mono)
   show ?thesis
     using _ limg limf apply (rule tendsto_le)
     by (auto intro!: sum_leq)
 qed
 
 end
diff --git a/thys/Complex_Bounded_Operators/extra/Extra_Lattice.thy b/thys/Complex_Bounded_Operators/extra/Extra_Lattice.thy
--- a/thys/Complex_Bounded_Operators/extra/Extra_Lattice.thy
+++ b/thys/Complex_Bounded_Operators/extra/Extra_Lattice.thy
@@ -1,271 +1,271 @@
 section \<open>\<open>Extra_Lattice\<close> -- Additional results about lattices\<close>
 
 theory Extra_Lattice
   imports Main
 begin
 
 
 subsection\<open>\<open>Lattice_Missing\<close> -- Miscellaneous missing facts about lattices\<close>
 
 text \<open>Two bundles to activate and deactivate lattice specific notation (e.g., \<open>\<sqinter>\<close> etc.).
   Activate the notation locally via "@{theory_text \<open>includes lattice_notation\<close>}" in a lemma statement.
   (Or sandwich a declaration using that notation between "@{theory_text \<open>unbundle lattice_notation ... unbundle no_lattice_notation\<close>}.)\<close>
 
 bundle lattice_notation begin
 notation inf (infixl "\<sqinter>" 70)
 notation sup (infixl "\<squnion>" 65)
 notation Inf ("\<Sqinter>")
 notation Sup ("\<Squnion>")
 notation bot ("\<bottom>")
 notation top ("\<top>")
 end
 
 bundle no_lattice_notation begin
 notation inf (infixl "\<sqinter>" 70)
 notation sup (infixl "\<squnion>" 65)
 notation Inf ("\<Sqinter>")
 notation Sup ("\<Squnion>")
 notation bot ("\<bottom>")
 notation top ("\<top>")
 end
 
 unbundle lattice_notation
 
 text \<open>The following class \<open>complemented_lattice\<close> describes complemented lattices (with
-  \<^const>\<open>uminus\<close> for the complement). The definition follows 
+  \<^const>\<open>uminus\<close> for the complement). The definition follows
   \<^url>\<open>https://en.wikipedia.org/wiki/Complemented_lattice#Definition_and_basic_properties\<close>.
-  Additionally, it adopts the convention from \<^class>\<open>boolean_algebra\<close> of defining 
+  Additionally, it adopts the convention from \<^class>\<open>boolean_algebra\<close> of defining
   \<^const>\<open>minus\<close> in terms of the complement.\<close>
 
-class complemented_lattice = bounded_lattice + uminus + minus + 
+class complemented_lattice = bounded_lattice + uminus + minus +
   assumes inf_compl_bot[simp]: "inf x (-x) = bot"
     and sup_compl_top[simp]: "sup x (-x) = top"
     and diff_eq:  "x - y = inf x (- y)" begin
 
 lemma dual_complemented_lattice:
   "class.complemented_lattice (\<lambda>x y. x \<squnion> (- y)) uminus sup greater_eq greater inf \<top> \<bottom>"
 proof (rule class.complemented_lattice.intro)
   show "class.bounded_lattice (\<squnion>) (\<lambda>x y. (y::'a) \<le> x) (\<lambda>x y. y < x) (\<sqinter>) \<top> \<bottom>"
     by (rule dual_bounded_lattice)
   show "class.complemented_lattice_axioms (\<lambda>x y. (x::'a) \<squnion> - y) uminus (\<squnion>) (\<sqinter>) \<top> \<bottom>"
     by (unfold_locales, auto simp add: diff_eq)
 qed
 
 
 lemma compl_inf_bot [simp]: "inf (- x) x = bot"
   by (simp add: inf_commute)
 
 lemma compl_sup_top [simp]: "sup (- x) x = top"
   by (simp add: sup_commute)
 
 end
 
-class complete_complemented_lattice = complemented_lattice + complete_lattice 
+class complete_complemented_lattice = complemented_lattice + complete_lattice
 
 text \<open>The following class \<open>complemented_lattice\<close> describes orthocomplemented lattices,
   following   \<^url>\<open>https://en.wikipedia.org/wiki/Complemented_lattice#Orthocomplementation\<close>.\<close>
 class orthocomplemented_lattice = complemented_lattice +
   assumes ortho_involution[simp]: "- (- x) = x"
     and ortho_antimono: "x \<le> y \<Longrightarrow> -x \<ge> -y" begin
 
 lemma dual_orthocomplemented_lattice:
   "class.orthocomplemented_lattice (\<lambda>x y. x \<squnion> - y) uminus sup greater_eq greater inf \<top> \<bottom>"
 proof (rule class.orthocomplemented_lattice.intro)
   show "class.complemented_lattice (\<lambda>x y. (x::'a) \<squnion> - y) uminus (\<squnion>) (\<lambda>x y. y \<le> x) (\<lambda>x y. y < x) (\<sqinter>) \<top> \<bottom>"
     by (rule dual_complemented_lattice)
   show "class.orthocomplemented_lattice_axioms uminus (\<lambda>x y. (y::'a) \<le> x)"
     by (unfold_locales, auto simp add: diff_eq intro: ortho_antimono)
 qed
 
 
 
 lemma compl_eq_compl_iff [simp]: "- x = - y \<longleftrightarrow> x = y"
   by (metis ortho_involution)
 
 lemma compl_bot_eq [simp]: "- bot = top"
   by (metis inf_compl_bot inf_top_left ortho_involution)
 
 lemma compl_top_eq [simp]: "- top = bot"
   using compl_bot_eq ortho_involution by blast
 
 text \<open>De Morgan's law\<close>
   (* Proof from: https://planetmath.org/orthocomplementedlattice *)
 lemma compl_sup [simp]: "- (x \<squnion> y) = - x \<sqinter> - y"
 proof -
   have "- (x \<squnion> y) \<le> - x"
     by (simp add: ortho_antimono)
   moreover have "- (x \<squnion> y) \<le> - y"
     by (simp add: ortho_antimono)
   ultimately have 1: "- (x \<squnion> y) \<le> - x \<sqinter> - y"
     by (simp add: sup.coboundedI1)
   have \<open>x \<le> - (-x \<sqinter> -y)\<close>
     by (metis inf.cobounded1 ortho_antimono ortho_involution)
   moreover have \<open>y \<le> - (-x \<sqinter> -y)\<close>
     by (metis inf.cobounded2 ortho_antimono ortho_involution)
   ultimately have \<open>x \<squnion> y \<le> - (-x \<sqinter> -y)\<close>
     by auto
   hence 2: \<open>-x \<sqinter> -y \<le> - (x \<squnion> y)\<close>
     using ortho_antimono by fastforce
   from 1 2 show ?thesis
-    by (simp add: eq_iff)
+    using dual_order.antisym by blast
 qed
 
 text \<open>De Morgan's law\<close>
 lemma compl_inf [simp]: "- (x \<sqinter> y) = - x \<squnion> - y"
   using compl_sup
   by (metis ortho_involution)
 
 lemma compl_mono:
   assumes "x \<le> y"
   shows "- y \<le> - x"
   by (simp add: assms local.ortho_antimono)
 
 lemma compl_le_compl_iff [simp]: "- x \<le> - y \<longleftrightarrow> y \<le> x"
   by (auto dest: compl_mono)
 
 lemma compl_le_swap1:
   assumes "y \<le> - x"
   shows "x \<le> -y"
   using assms ortho_antimono by fastforce
 
 lemma compl_le_swap2:
   assumes "- y \<le> x"
   shows "- x \<le> y"
   using assms local.ortho_antimono by fastforce
 
 lemma compl_less_compl_iff[simp]: "- x < - y \<longleftrightarrow> y < x"
   by (auto simp add: less_le)
 
 lemma compl_less_swap1:
   assumes "y < - x"
   shows "x < - y"
   using assms compl_less_compl_iff by fastforce
 
 lemma compl_less_swap2:
   assumes "- y < x"
   shows "- x < y"
   using assms compl_le_swap1 compl_le_swap2 less_le_not_le by auto
 
 lemma sup_cancel_left1: "sup (sup x a) (sup (- x) b) = top"
   by (simp add: sup_commute sup_left_commute)
 
 lemma sup_cancel_left2: "sup (sup (- x) a) (sup x b) = top"
   by (simp add: sup.commute sup_left_commute)
 
 lemma inf_cancel_left1: "inf (inf x a) (inf (- x) b) = bot"
   by (simp add: inf.left_commute inf_commute)
 
 lemma inf_cancel_left2: "inf (inf (- x) a) (inf x b) = bot"
   using inf.left_commute inf_commute by auto
 
 lemma sup_compl_top_left1 [simp]: "sup (- x) (sup x y) = top"
   by (simp add: sup_assoc[symmetric])
 
 lemma sup_compl_top_left2 [simp]: "sup x (sup (- x) y) = top"
   using sup_compl_top_left1[of "- x" y] by simp
 
 lemma inf_compl_bot_left1 [simp]: "inf (- x) (inf x y) = bot"
   by (simp add: inf_assoc[symmetric])
 
 lemma inf_compl_bot_left2 [simp]: "inf x (inf (- x) y) = bot"
   using inf_compl_bot_left1[of "- x" y] by simp
 
 lemma inf_compl_bot_right [simp]: "inf x (inf y (- x)) = bot"
   by (subst inf_left_commute) simp
 
 end
 
 class complete_orthocomplemented_lattice = orthocomplemented_lattice + complete_lattice
 
 instance complete_orthocomplemented_lattice \<subseteq> complete_complemented_lattice
   by intro_classes
 
 text \<open>The following class \<open>orthomodular_lattice\<close> describes orthomodular lattices,
 following   \<^url>\<open>https://en.wikipedia.org/wiki/Complemented_lattice#Orthomodular_lattices\<close>.\<close>
 class orthomodular_lattice = orthocomplemented_lattice +
   assumes orthomodular: "x \<le> y \<Longrightarrow> sup x (inf (-x) y) = y" begin
 
 lemma dual_orthomodular_lattice:
   "class.orthomodular_lattice (\<lambda>x y. x \<squnion> - y) uminus sup greater_eq greater inf \<top> \<bottom>"
 proof (rule class.orthomodular_lattice.intro)
   show "class.orthocomplemented_lattice (\<lambda>x y. (x::'a) \<squnion> - y) uminus (\<squnion>) (\<lambda>x y. y \<le> x) (\<lambda>x y. y < x) (\<sqinter>) \<top> \<bottom>"
     by (rule dual_orthocomplemented_lattice)
   show "class.orthomodular_lattice_axioms uminus (\<squnion>) (\<lambda>x y. (y::'a) \<le> x) (\<sqinter>)"
   proof (unfold_locales)
     show "(x::'a) \<sqinter> (- x \<squnion> y) = y"
       if "(y::'a) \<le> x"
       for x :: 'a
         and y :: 'a
       using that local.compl_eq_compl_iff local.ortho_antimono local.orthomodular by fastforce
   qed
 
 qed
 
 
 end
 
 class complete_orthomodular_lattice = orthomodular_lattice + complete_lattice begin
 
 end
 
 instance complete_orthomodular_lattice \<subseteq> complete_orthocomplemented_lattice
   by intro_classes
 
 
 instance boolean_algebra \<subseteq> orthomodular_lattice
 proof
-  fix x y :: 'a  
+  fix x y :: 'a
   show "sup (x::'a) (inf (- x) y) = y"
     if "(x::'a) \<le> y"
     using that
-    by (simp add: sup.absorb_iff2 sup_inf_distrib1) 
+    by (simp add: sup.absorb_iff2 sup_inf_distrib1)
   show "x - y = inf x (- y)"
     by (simp add: boolean_algebra_class.diff_eq)
 qed auto
 
 instance complete_boolean_algebra \<subseteq> complete_orthomodular_lattice
   by intro_classes
 
 lemma image_of_maximum:
   fixes f::"'a::order \<Rightarrow> 'b::conditionally_complete_lattice"
   assumes "mono f"
     and "\<And>x. x:M \<Longrightarrow> x\<le>m"
     and "m:M"
   shows "(SUP x\<in>M. f x) = f m"
   by (smt (verit, ccfv_threshold) assms(1) assms(2) assms(3) cSup_eq_maximum imageE imageI monoD)
 
 lemma cSup_eq_cSup:
   fixes A B :: \<open>'a::conditionally_complete_lattice set\<close>
   assumes bdd: \<open>bdd_above A\<close>
   assumes B: \<open>\<And>a. a\<in>A \<Longrightarrow> \<exists>b\<in>B. b \<ge> a\<close>
   assumes A: \<open>\<And>b. b\<in>B \<Longrightarrow> \<exists>a\<in>A. a \<ge> b\<close>
   shows \<open>Sup A = Sup B\<close>
 proof (cases \<open>B = {}\<close>)
   case True
   with A B have \<open>A = {}\<close>
     by auto
   with True show ?thesis by simp
 next
   case False
   have \<open>bdd_above B\<close>
     by (meson A bdd bdd_above_def order_trans)
   have \<open>A \<noteq> {}\<close>
     using A False by blast
   moreover have \<open>a \<le> Sup B\<close> if \<open>a \<in> A\<close> for a
   proof -
     obtain b where \<open>b \<in> B\<close> and \<open>b \<ge> a\<close>
       using B \<open>a \<in> A\<close> by auto
     then show ?thesis
       apply (rule cSup_upper2)
       using \<open>bdd_above B\<close> by simp
   qed
   moreover have \<open>Sup B \<le> c\<close> if \<open>\<And>a. a \<in> A \<Longrightarrow> a \<le> c\<close> for c
     using False apply (rule cSup_least)
     using A that by fastforce
   ultimately show ?thesis
     by (rule cSup_eq_non_empty)
 qed
 
 unbundle no_lattice_notation
 
 end
diff --git a/thys/Complex_Bounded_Operators/extra/Extra_Operator_Norm.thy b/thys/Complex_Bounded_Operators/extra/Extra_Operator_Norm.thy
--- a/thys/Complex_Bounded_Operators/extra/Extra_Operator_Norm.thy
+++ b/thys/Complex_Bounded_Operators/extra/Extra_Operator_Norm.thy
@@ -1,392 +1,392 @@
 section \<open>\<open>Extra_Operator_Norm\<close> -- Additional facts bout the operator norm\<close>
 
 theory Extra_Operator_Norm
   imports "HOL-Analysis.Operator_Norm"
     Extra_General
     "HOL-Analysis.Bounded_Linear_Function"
 begin
 
 
 text \<open>This theorem complements \<^theory>\<open>HOL-Analysis.Operator_Norm\<close>
       additional useful facts about operator norms.\<close>
 
-lemma ex_norm1: 
+lemma ex_norm1:
   assumes \<open>(UNIV::'a::real_normed_vector set) \<noteq> {0}\<close>
   shows \<open>\<exists>x::'a. norm x = 1\<close>
 proof-
   have \<open>\<exists>x::'a. x \<noteq> 0\<close>
     using assms by fastforce
   then obtain x::'a where \<open>x \<noteq> 0\<close>
     by blast
   hence \<open>norm x \<noteq> 0\<close>
     by simp
   hence \<open>(norm x) / (norm x) = 1\<close>
     by simp
   moreover have \<open>(norm x) / (norm x) = norm (x /\<^sub>R (norm x))\<close>
     by simp
   ultimately have \<open>norm (x /\<^sub>R (norm x)) = 1\<close>
     by simp
   thus ?thesis
-    by blast 
+    by blast
 qed
 
 lemma bdd_above_norm_f:
   assumes "bounded_linear f"
   shows \<open>bdd_above {norm (f x) |x. norm x = 1}\<close>
 proof-
   have \<open>\<exists>M. \<forall>x. norm x = 1 \<longrightarrow> norm (f x) \<le> M\<close>
     using assms
     by (metis bounded_linear.axioms(2) bounded_linear_axioms_def)
   thus ?thesis by auto
 qed
 
 lemma onorm_sphere:
   fixes f :: "'a::{real_normed_vector, not_singleton} \<Rightarrow> 'b::real_normed_vector"
   assumes a1: "bounded_linear f"
   shows \<open>onorm f = Sup {norm (f x) | x. norm x = 1}\<close>
 proof(cases \<open>f = (\<lambda> _. 0)\<close>)
   case True
   have \<open>(UNIV::'a set) \<noteq> {0}\<close>
     by simp
   hence \<open>\<exists>x::'a. norm x = 1\<close>
     using  ex_norm1
     by blast
   have \<open>norm (f x) = 0\<close>
     for x
-    by (simp add: True)      
+    by (simp add: True)
   hence \<open>{norm (f x) | x. norm x = 1} = {0}\<close>
     using \<open>\<exists>x. norm x = 1\<close> by auto
   hence v1: \<open>Sup {norm (f x) | x. norm x = 1} = 0\<close>
-    by simp 
+    by simp
   have \<open>onorm f = 0\<close>
-    by (simp add: True onorm_eq_0)  
+    by (simp add: True onorm_eq_0)
   thus ?thesis using v1 by simp
 next
   case False
   have \<open>y \<in> {norm (f x) |x. norm x = 1} \<union> {0}\<close>
     if "y \<in> {norm (f x) / norm x |x. True}"
     for y
   proof(cases \<open>y = 0\<close>)
     case True
     thus ?thesis
-      by simp 
+      by simp
   next
     case False
     have \<open>\<exists> x. y = norm (f x) / norm x\<close>
       using \<open>y \<in> {norm (f x) / norm x |x. True}\<close> by auto
     then obtain x where \<open>y = norm (f x) / norm x\<close>
       by blast
     hence \<open>y = \<bar>(1/norm x)\<bar> * norm ( f x )\<close>
       by simp
     hence \<open>y = norm ( (1/norm x) *\<^sub>R f x )\<close>
       by simp
     hence \<open>y = norm ( f ((1/norm x) *\<^sub>R x) )\<close>
       apply (subst linear_cmul[of f])
       by (simp_all add: assms bounded_linear.linear)
     moreover have \<open>norm ((1/norm x) *\<^sub>R x) = 1\<close>
-      using False \<open>y = norm (f x) / norm x\<close> by auto              
+      using False \<open>y = norm (f x) / norm x\<close> by auto
     ultimately have \<open>y \<in> {norm (f x) |x. norm x = 1}\<close>
       by blast
     thus ?thesis by blast
   qed
   moreover have "y \<in> {norm (f x) / norm x |x. True}"
     if \<open>y \<in> {norm (f x) |x. norm x = 1} \<union> {0}\<close>
     for y
   proof(cases \<open>y = 0\<close>)
     case True
     thus ?thesis
-      by auto 
+      by auto
   next
     case False
     hence \<open>y \<notin> {0}\<close>
       by simp
     hence \<open>y \<in> {norm (f x) |x. norm x = 1}\<close>
-      using that by auto      
+      using that by auto
     hence \<open>\<exists> x. norm x = 1 \<and> y = norm (f x)\<close>
       by auto
     then obtain x where \<open>norm x = 1\<close> and \<open>y = norm (f x)\<close>
       by auto
     have \<open>y = norm (f x) / norm x\<close> using  \<open>norm x = 1\<close>  \<open>y = norm (f x)\<close>
-      by simp 
+      by simp
     thus ?thesis
-      by auto 
+      by auto
   qed
-  ultimately have \<open>{norm (f x) / norm x |x. True} = {norm (f x) |x. norm x = 1} \<union> {0}\<close> 
+  ultimately have \<open>{norm (f x) / norm x |x. True} = {norm (f x) |x. norm x = 1} \<union> {0}\<close>
     by blast
   hence \<open>Sup {norm (f x) / norm x |x. True} = Sup ({norm (f x) |x. norm x = 1} \<union> {0})\<close>
     by simp
   moreover have \<open>Sup {norm (f x) |x. norm x = 1} \<ge> 0\<close>
   proof-
     have \<open>\<exists> x::'a. norm x = 1\<close>
-      by (metis (mono_tags, hide_lams) False assms bounded_linear.nonneg_bounded mult_zero_left norm_le_zero_iff norm_sgn)
+      by (metis (full_types) False assms linear_simps(3) norm_sgn)
     then obtain x::'a where \<open>norm x = 1\<close>
       by blast
     have \<open>norm (f x) \<ge> 0\<close>
       by simp
     hence \<open>\<exists> x::'a. norm x = 1 \<and> norm (f x) \<ge> 0\<close>
       using \<open>norm x = 1\<close> by blast
     hence \<open>\<exists> y \<in> {norm (f x) |x. norm x = 1}. y \<ge> 0\<close>
       by blast
-    then obtain y::real where \<open>y \<in> {norm (f x) |x. norm x = 1}\<close> 
+    then obtain y::real where \<open>y \<in> {norm (f x) |x. norm x = 1}\<close>
       and \<open>y \<ge> 0\<close>
       by auto
     have \<open>{norm (f x) |x. norm x = 1} \<noteq> {}\<close>
-      using \<open>y \<in> {norm (f x) |x. norm x = 1}\<close> by blast         
+      using \<open>y \<in> {norm (f x) |x. norm x = 1}\<close> by blast
     moreover have \<open>bdd_above {norm (f x) |x. norm x = 1}\<close>
       using bdd_above_norm_f
-      by (metis (mono_tags, lifting) a1) 
+      by (metis (mono_tags, lifting) a1)
     ultimately have \<open>y \<le> Sup {norm (f x) |x. norm x = 1}\<close>
       using \<open>y \<in> {norm (f x) |x. norm x = 1}\<close>
-      by (simp add: cSup_upper) 
+      by (simp add: cSup_upper)
     thus ?thesis using \<open>y \<ge> 0\<close> by simp
   qed
   moreover have \<open>Sup ({norm (f x) |x. norm x = 1} \<union> {0}) = Sup {norm (f x) |x. norm x = 1}\<close>
   proof-
     have \<open>{norm (f x) |x. norm x = 1} \<noteq> {}\<close>
       by (simp add: assms(1) ex_norm1)
     moreover have \<open>bdd_above {norm (f x) |x. norm x = 1}\<close>
       using a1 bdd_above_norm_f by force
     have \<open>{0::real} \<noteq> {}\<close>
       by simp
     moreover have \<open>bdd_above {0::real}\<close>
       by simp
     ultimately have \<open>Sup ({norm (f x) |x. norm x = 1} \<union> {(0::real)})
              = max (Sup {norm (f x) |x. norm x = 1}) (Sup {0::real})\<close>
       by (metis (lifting) \<open>0 \<le> Sup {norm (f x) |x. norm x = 1}\<close> \<open>bdd_above {0}\<close> \<open>bdd_above {norm (f x) |x. norm x = 1}\<close> \<open>{0} \<noteq> {}\<close> \<open>{norm (f x) |x. norm x = 1} \<noteq> {}\<close> cSup_singleton cSup_union_distrib max.absorb_iff1 sup.absorb_iff1)
     moreover have \<open>Sup {(0::real)} = (0::real)\<close>
-      by simp          
+      by simp
     moreover have \<open>Sup {norm (f x) |x. norm x = 1} \<ge> 0\<close>
       by (simp add: \<open>0 \<le> Sup {norm (f x) |x. norm x = 1}\<close>)
     ultimately show ?thesis
       by simp
   qed
   moreover have \<open>Sup ( {norm (f x) |x. norm x = 1} \<union> {0})
            = max (Sup {norm (f x) |x. norm x = 1}) (Sup {0}) \<close>
     using calculation(2) calculation(3) by auto
   ultimately have w1: "Sup {norm (f x) / norm x | x. True} = Sup {norm (f x) | x. norm x = 1}"
-    by simp 
+    by simp
 
   have \<open>(SUP x. norm (f x) / (norm x)) = Sup {norm (f x) / norm x | x. True}\<close>
     by (simp add: full_SetCompr_eq)
   also have \<open>... = Sup {norm (f x) | x. norm x = 1}\<close>
     using w1 by auto
   ultimately  have \<open>(SUP x. norm (f x) / (norm x)) = Sup {norm (f x) | x. norm x = 1}\<close>
     by linarith
   thus ?thesis unfolding onorm_def by blast
 qed
 
 
 lemma onorm_Inf_bound:
   fixes f :: \<open>'a::{real_normed_vector,not_singleton} \<Rightarrow> 'b::real_normed_vector\<close>
   assumes a1: "bounded_linear f"
   shows "onorm f = Inf {K. (\<forall>x\<noteq>0. norm (f x) \<le> norm x * K)}"
 proof-
   have a2: \<open>(UNIV::'a set) \<noteq> {0}\<close>
     by simp
 
   define A where \<open>A = {norm (f x) / (norm x) | x. x \<noteq> 0}\<close>
   have \<open>A \<noteq> {}\<close>
   proof-
     have \<open>\<exists> x::'a. x \<noteq> 0\<close>
       using a2 by auto
     thus ?thesis using A_def
-      by simp 
+      by simp
   qed
   moreover have \<open>bdd_above A\<close>
   proof-
     have \<open>\<exists> M. \<forall> x.  norm (f x) / (norm x) \<le> M\<close>
       using \<open>bounded_linear f\<close> le_onorm by auto
     thus ?thesis using A_def
-      by auto 
+      by auto
   qed
-  ultimately have \<open>Sup A = Inf {b. \<forall>a\<in>A. a \<le> b}\<close>      
-    by (simp add: cSup_cInf)  
+  ultimately have \<open>Sup A = Inf {b. \<forall>a\<in>A. a \<le> b}\<close>
+    by (simp add: cSup_cInf)
   moreover have \<open>{b. \<forall>a\<in>A. a \<le> b} = {K. (\<forall>x\<noteq>0. norm (f x)/ norm x \<le>  K)}\<close>
   proof-
     have \<open>{b. \<forall>a\<in>A. a \<le> b} = {b. \<forall>a\<in>{norm (f x) / (norm x) | x. x \<noteq> 0}. a \<le> b}\<close>
       using A_def by blast
     also have \<open>... = {b. \<forall>x\<in>{x | x. x \<noteq> 0}. norm (f x) / (norm x) \<le> b}\<close>
       by auto
     also have \<open>... = {b. \<forall>x\<noteq>0. norm (f x) / (norm x) \<le> b}\<close>
       by auto
     finally show ?thesis by blast
   qed
-  ultimately have \<open>Sup {norm (f x) / (norm x) | x. x \<noteq> 0} 
+  ultimately have \<open>Sup {norm (f x) / (norm x) | x. x \<noteq> 0}
                     = Inf {K. (\<forall>x\<noteq>0. norm (f x)/ norm x \<le>  K)}\<close>
     using A_def
-    by simp 
+    by simp
   moreover have \<open>(\<forall>x\<noteq>0. norm (f x) \<le> norm x * K) \<longleftrightarrow> (\<forall>x\<noteq>0. norm (f x)/ norm x \<le> K)\<close>
     for K
   proof
     show "\<forall>x\<noteq>0. norm (f x) / norm x \<le> K"
       if "\<forall>x\<noteq>0. norm (f x) \<le> norm x * K"
       using divide_le_eq nonzero_mult_div_cancel_left norm_le_zero_iff that
       by (simp add: divide_le_eq mult.commute)
 
     show "\<forall>x\<noteq>0. norm (f x) \<le> norm x * K"
       if "\<forall>x\<noteq>0. norm (f x) / norm x \<le> K"
       using divide_le_eq nonzero_mult_div_cancel_left norm_le_zero_iff that
       by (simp add: divide_le_eq mult.commute)
   qed
   ultimately have f1: \<open>Sup {norm (f x) / (norm x) | x. x \<noteq> 0} = Inf {K. (\<forall>x\<noteq>0. norm (f x) \<le> norm x * K)}\<close>
     by simp
-  moreover 
+  moreover
   have t1: \<open>{norm (f x) / (norm x) | x. x \<noteq> 0} \<union> {norm (f x) / (norm x) | x. x = 0}  = {norm (f x) / (norm x) | x. True}\<close>
     using Collect_cong by blast
 
   have \<open>{norm (f x) / (norm x) | x. x \<noteq> 0} \<noteq> {}\<close>
   proof-
     have \<open>\<exists> x::'a. x \<noteq> 0\<close>
       using \<open>UNIV\<noteq>{0}\<close> by auto
     thus ?thesis
-      by simp 
+      by simp
   qed
   moreover have \<open>bdd_above {norm (f x) / (norm x) | x. x \<noteq> 0}\<close>
   proof-
     have \<open>\<exists> M. \<forall> x.  norm (f x) / (norm x) \<le> M\<close>
-      using \<open>bounded_linear f\<close> bounded_linear.nonneg_bounded 
+      using \<open>bounded_linear f\<close> bounded_linear.nonneg_bounded
         mult_divide_mult_cancel_left_if norm_zero real_divide_square_eq
       using le_onorm by blast
     thus ?thesis
-      by auto 
+      by auto
   qed
   moreover have \<open>{norm (f x) / (norm x) | x. x = 0} \<noteq> {}\<close>
     by simp
   moreover have \<open>bdd_above {norm (f x) / (norm x) | x. x = 0}\<close>
     by simp
-  ultimately 
+  ultimately
   have d1: \<open>Sup ({norm (f x) / (norm x) | x. x \<noteq> 0} \<union> {norm (f x) / (norm x) | x. x = 0})
         = max (Sup {norm (f x) / (norm x) | x. x \<noteq> 0}) (Sup {norm (f x) / (norm x) | x. x = 0})\<close>
     by (metis (no_types, lifting) cSup_union_distrib sup_max)
   have g1: \<open>Sup {norm (f x) / (norm x) | x. x \<noteq> 0} \<ge> 0\<close>
   proof-
     have t2: \<open>{norm (f x) / (norm x) | x. x \<noteq> 0} \<noteq> {}\<close>
     proof-
       have \<open>\<exists> x::'a. x \<noteq> 0\<close>
         using \<open>UNIV\<noteq>{0}\<close> by auto
-      thus ?thesis 
+      thus ?thesis
         by auto
     qed
     have \<open>\<exists> M. \<forall> x.  norm (f x) / (norm x) \<le> M\<close>
       using \<open>bounded_linear f\<close>
       by (metis \<open>\<And>K. (\<forall>x. x \<noteq> 0 \<longrightarrow> norm (f x) \<le> norm x * K) = (\<forall>x. x \<noteq> 0 \<longrightarrow> norm (f x) / norm x \<le> K)\<close> bounded_linear.nonneg_bounded mult_divide_mult_cancel_left_if norm_zero real_divide_square_eq)
     hence t3: \<open>bdd_above {norm (f x) / (norm x) | x. x \<noteq> 0}\<close>
       by auto
     have \<open>norm (f x) / (norm x) \<ge> 0\<close>
       for x
       by simp
     hence \<open>\<forall> y\<in>{norm (f x) / (norm x) | x. x \<noteq> 0}. y \<ge> 0\<close>
       by blast
     show ?thesis
       by (metis (lifting) \<open>\<forall>y\<in>{norm (f x) / norm x |x. x \<noteq> 0}. 0 \<le> y\<close> \<open>bdd_above {norm (f x) / norm x |x. x \<noteq> 0}\<close> \<open>{norm (f x) / norm x |x. x \<noteq> 0} \<noteq> {}\<close> bot.extremum_uniqueI cSup_upper2 subset_emptyI)
   qed
-  hence r: \<open>Sup ({norm (f x) / (norm x) | x. x \<noteq> 0} \<union> {norm (f x) / (norm x) | x. x = 0}) 
+  hence r: \<open>Sup ({norm (f x) / (norm x) | x. x \<noteq> 0} \<union> {norm (f x) / (norm x) | x. x = 0})
          = Sup {norm (f x) / (norm x) | x. True}\<close>
     using t1 by auto
   have \<open>{norm (f x) / (norm x) | x. x = 0} = {norm (f 0) / (norm 0)}\<close>
     by simp
   hence \<open>Sup {norm (f x) / (norm x) | x. x = 0} = 0\<close>
     by simp
   have h1: \<open>Sup {norm (f x) / (norm x) | x. x \<noteq> 0} = Sup {norm (f x) / (norm x) | x. True}\<close>
-    using d1 r g1 by auto 
+    using d1 r g1 by auto
   have \<open>(SUP x. norm (f x) / (norm x)) = Inf {K. (\<forall>x\<noteq>0. norm (f x) \<le> norm x * K)}\<close>
     using full_SetCompr_eq
     by (metis f1 h1)
   thus ?thesis
     by (simp add: onorm_def)
 qed
 
 
 lemma onormI:
   assumes "\<And>x. norm (f x) \<le> b * norm x"
     and "x \<noteq> 0" and "norm (f x) = b * norm x"
   shows "onorm f = b"
   apply (unfold onorm_def, rule cSup_eq_maximum)
    apply (smt (verit) UNIV_I assms(2) assms(3) image_iff nonzero_mult_div_cancel_right norm_eq_zero)
   by (smt (verit, del_insts) assms(1) assms(2) divide_nonneg_nonpos norm_ge_zero norm_le_zero_iff pos_divide_le_eq rangeE zero_le_mult_iff)
 
 
 lemma norm_unit_sphere:
   fixes f::\<open>'a::{real_normed_vector,not_singleton} \<Rightarrow>\<^sub>L 'b::real_normed_vector\<close>
-  assumes a1: "bounded_linear f" and a2: "e > 0"     
+  assumes a1: "bounded_linear f" and a2: "e > 0"
   shows \<open>\<exists>x\<in>(sphere 0 1). norm (norm (blinfun_apply f x) - norm f) < e\<close>
 proof-
   define S::"real set" where \<open>S = { norm (f x)| x. x \<in> sphere 0 1 }\<close>
   have "\<exists>x::'a. norm x = 1"
     by (metis (full_types) Collect_empty_eq Extra_General.UNIV_not_singleton UNIV_I equalityI mem_Collect_eq norm_sgn singleton_conv subsetI)
   hence \<open>\<exists>x::'a. x \<in> sphere 0 1\<close>
-    by simp                
-  hence \<open>S\<noteq>{}\<close>unfolding S_def 
-    by auto 
+    by simp
+  hence \<open>S\<noteq>{}\<close>unfolding S_def
+    by auto
   hence t1: \<open>e > 0 \<Longrightarrow> \<exists> y \<in> S. Sup S - e < y\<close>
     for e
     by (simp add: less_cSupD)
   have \<open>onorm f = Sup { norm (f x)| x. norm x = 1 }\<close>
     using \<open>bounded_linear f\<close> onorm_sphere
-    by auto      
+    by auto
   hence \<open>onorm f = Sup { norm (f x)| x. x \<in> sphere 0 1 }\<close>
     unfolding sphere_def
     by simp
-  hence t2: \<open>Sup S = onorm f\<close> unfolding S_def 
+  hence t2: \<open>Sup S = onorm f\<close> unfolding S_def
     by auto
   have s1: \<open>\<exists>y\<in>{norm (f x) |x. x \<in> sphere 0 1}. norm (onorm f - y) < e\<close>
     if "0 < e"
     for e
   proof-
     have \<open>\<exists> y \<in> S. (onorm f) - e < y\<close>
       using t1 t2 that by auto
     hence \<open>\<exists> y \<in> S. (onorm f) - y  < e\<close>
       using that
       by force
     have \<open>\<exists> y \<in> S. (onorm f) - y  < e\<close>
       using \<open>0 < e\<close> \<open>\<exists>y\<in>S. onorm f - y < e\<close> by auto
     then obtain y where \<open>y \<in> S\<close> and \<open>(onorm f) - y  < e\<close>
       by blast
     have \<open>y \<in> {norm (f x) |x. x \<in> sphere 0 1} \<Longrightarrow> y \<le> onorm f\<close>
     proof-
       assume \<open>y \<in> {norm (f x) |x. x \<in> sphere 0 1}\<close>
       hence \<open>\<exists> x \<in> sphere 0 1. y = norm (f x)\<close>
         by blast
       then obtain x where \<open>x \<in> sphere 0 1\<close> and \<open>y = norm (f x)\<close>
         by blast
       from \<open>y = norm (f x)\<close>
       have \<open>y \<le> onorm f * norm x\<close>
         using a1 onorm by auto
       moreover have \<open>norm x = 1\<close>
         using  \<open>x \<in> sphere 0 1\<close> unfolding sphere_def by auto
       ultimately show ?thesis by simp
     qed
     hence \<open>bdd_above {norm (f x) |x. x \<in> sphere 0 1}\<close>
       using a1 bdd_above_norm_f by force
-    hence \<open>bdd_above S\<close> unfolding S_def 
+    hence \<open>bdd_above S\<close> unfolding S_def
       by blast
     hence \<open>y \<le> Sup S\<close>
       using \<open>y \<in> S\<close> \<open>S \<noteq> {}\<close> cSup_upper
       by blast
     hence \<open>0 \<le> Sup S - y\<close>
       by simp
     hence \<open>0 \<le> onorm f - y\<close>
       using \<open>Sup S = onorm f\<close>
       by simp
     hence \<open>\<bar> (onorm f - y) \<bar> = onorm f - y\<close>
       by simp
     hence \<open>norm (onorm f - y)  = onorm f - y\<close>
       by auto
     hence \<open>\<exists> y \<in> S. norm ((onorm f) - y)  < e\<close>
-      using \<open>onorm f - y < e\<close> \<open>y \<in> S\<close> by force    
+      using \<open>onorm f - y < e\<close> \<open>y \<in> S\<close> by force
     show ?thesis
       unfolding S_def
-      using S_def \<open>\<exists>y\<in>S. norm (onorm (blinfun_apply f) - y) < e\<close> by blast      
+      using S_def \<open>\<exists>y\<in>S. norm (onorm (blinfun_apply f) - y) < e\<close> by blast
   qed
   have f2: "onorm (blinfun_apply f) = Sup S"
     using S_def \<open>onorm (blinfun_apply f) = Sup {norm (blinfun_apply f x) |x. x \<in> sphere 0 1}\<close> by blast
   hence "\<exists>a. norm (norm (blinfun_apply f a) - Sup S) < e \<and> a \<in> sphere 0 1"
-    using a1 a2 s1 a2 t2 
-    by force 
+    using a1 a2 s1 a2 t2
+    by force
   thus ?thesis
-    using f2 by (metis (full_types) norm_blinfun.rep_eq)  
+    using f2 by (metis (full_types) norm_blinfun.rep_eq)
 qed
 
 
 
 end
diff --git a/thys/Complex_Bounded_Operators/extra/Extra_Ordered_Fields.thy b/thys/Complex_Bounded_Operators/extra/Extra_Ordered_Fields.thy
--- a/thys/Complex_Bounded_Operators/extra/Extra_Ordered_Fields.thy
+++ b/thys/Complex_Bounded_Operators/extra/Extra_Ordered_Fields.thy
@@ -1,958 +1,958 @@
 section \<open>\<open>Extra_Ordered_Fields\<close> -- Additional facts about ordered fields\<close>
 
 theory Extra_Ordered_Fields
-  imports Complex_Main 
+  imports Complex_Main
     Jordan_Normal_Form.Conjugate (* Defines ordering for complex. We have to use theirs, otherwise there will be conflicts *)
 begin
 
 
 subsection\<open>Ordered Fields\<close>
 text \<open>In this section we introduce some type classes for ordered rings/fields/etc.
-that are weakenings of existing classes. Most theorems in this section are 
-copies of the eponymous theorems from Isabelle/HOL, except that they are now proven 
+that are weakenings of existing classes. Most theorems in this section are
+copies of the eponymous theorems from Isabelle/HOL, except that they are now proven
 requiring weaker type classes (usually the need for a total order is removed).
 
-Since the lemmas are identical to the originals except for weaker type constraints, 
+Since the lemmas are identical to the originals except for weaker type constraints,
 we use the same names as for the original lemmas. (In fact, the new lemmas could replace
 the original ones in Isabelle/HOL with at most minor incompatibilities.\<close>
 
 subsection \<open>Missing from Orderings.thy\<close>
 
 text \<open>This class is analogous to \<^class>\<open>unbounded_dense_linorder\<close>, except that it does not require a total order\<close>
 
 class unbounded_dense_order = dense_order + no_top + no_bot
 
 instance unbounded_dense_linorder \<subseteq> unbounded_dense_order ..
 
 subsection \<open>Missing from Rings.thy\<close>
 
 text \<open>The existing class \<^class>\<open>abs_if\<close> requires \<^term>\<open>\<bar>a\<bar> = (if a < 0 then - a else a)\<close>.
-However, if \<^term>\<open>(<)\<close> is not a total order, this condition is too strong when \<^term>\<open>a\<close> 
+However, if \<^term>\<open>(<)\<close> is not a total order, this condition is too strong when \<^term>\<open>a\<close>
 is incomparable with \<^term>\<open>0\<close>. (Namely, it requires the absolute value to be
-the identity on such elements. E.g., the absolute value for complex numbers does not 
+the identity on such elements. E.g., the absolute value for complex numbers does not
 satisfy this.) The following class \<open>partial_abs_if\<close> is analogous to \<^class>\<open>abs_if\<close>
 but does not require anything if \<^term>\<open>a\<close> is incomparable with \<^term>\<open>0\<close>.\<close>
 
 
 class partial_abs_if = minus + uminus + ord + zero + abs +
   assumes abs_neg: "a \<le> 0 \<Longrightarrow> abs a = -a"
   assumes abs_pos: "a \<ge> 0 \<Longrightarrow> abs a = a"
 
 class ordered_semiring_1 = ordered_semiring + semiring_1
   \<comment> \<open>missing class analogous to \<^class>\<open>linordered_semiring_1\<close> without requiring a total order\<close>
 begin
 
 lemma convex_bound_le:
   assumes "x \<le> a" and "y \<le> a" and "0 \<le> u" and "0 \<le> v" and "u + v = 1"
   shows "u * x + v * y \<le> a"
 proof-
   from assms have "u * x + v * y \<le> u * a + v * a"
     by (simp add: add_mono mult_left_mono)
   with assms show ?thesis
     unfolding distrib_right[symmetric] by simp
 qed
 
 end
 
 subclass (in linordered_semiring_1) ordered_semiring_1 ..
 
 class ordered_semiring_strict = semiring + comm_monoid_add + ordered_cancel_ab_semigroup_add +
   \<comment> \<open>missing class analogous to \<^class>\<open>linordered_semiring_strict\<close> without requiring a total order\<close>
   assumes mult_strict_left_mono: "a < b \<Longrightarrow> 0 < c \<Longrightarrow> c * a < c * b"
   assumes mult_strict_right_mono: "a < b \<Longrightarrow> 0 < c \<Longrightarrow> a * c < b * c"
 begin
 
 subclass semiring_0_cancel ..
 
 subclass ordered_semiring
 proof
   fix a b c :: 'a
   assume t1: "a \<le> b" and t2: "0 \<le> c"
   thus "c * a \<le> c * b"
     unfolding le_less
     using mult_strict_left_mono by (cases "c = 0") auto
   from t2 show "a * c \<le> b * c"
     unfolding le_less
-    by (metis local.antisym_conv2 local.mult_not_zero local.mult_strict_right_mono t1)    
+    by (metis local.antisym_conv2 local.mult_not_zero local.mult_strict_right_mono t1)
 qed
 
 lemma mult_pos_pos[simp]: "0 < a \<Longrightarrow> 0 < b \<Longrightarrow> 0 < a * b"
   using mult_strict_left_mono [of 0 b a] by simp
 
 lemma mult_pos_neg: "0 < a \<Longrightarrow> b < 0 \<Longrightarrow> a * b < 0"
   using mult_strict_left_mono [of b 0 a] by simp
 
 lemma mult_neg_pos: "a < 0 \<Longrightarrow> 0 < b \<Longrightarrow> a * b < 0"
   using mult_strict_right_mono [of a 0 b] by simp
 
 text \<open>Strict monotonicity in both arguments\<close>
 lemma mult_strict_mono:
   assumes t1: "a < b" and t2: "c < d" and t3: "0 < b" and t4: "0 \<le> c"
   shows "a * c < b * d"
 proof-
   have "a * c < b * d"
-    by (metis local.dual_order.order_iff_strict local.dual_order.strict_trans2 
-        local.mult_strict_left_mono local.mult_strict_right_mono local.mult_zero_right t1 t2 t3 t4)        
+    by (metis local.dual_order.order_iff_strict local.dual_order.strict_trans2
+        local.mult_strict_left_mono local.mult_strict_right_mono local.mult_zero_right t1 t2 t3 t4)
   thus ?thesis
     using assms by blast
 qed
 
 
 text \<open>This weaker variant has more natural premises\<close>
 lemma mult_strict_mono':
   assumes "a < b" and "c < d" and "0 \<le> a" and "0 \<le> c"
   shows "a * c < b * d"
   by (rule mult_strict_mono) (insert assms, auto)
 
 lemma mult_less_le_imp_less:
   assumes t1: "a < b" and t2: "c \<le> d" and t3: "0 \<le> a" and t4: "0 < c"
   shows "a * c < b * d"
-  using local.mult_strict_mono' local.mult_strict_right_mono local.order.order_iff_strict 
+  using local.mult_strict_mono' local.mult_strict_right_mono local.order.order_iff_strict
     t1 t2 t3 t4 by auto
 
 lemma mult_le_less_imp_less:
   assumes "a \<le> b" and "c < d" and "0 < a" and "0 \<le> c"
   shows "a * c < b * d"
-  by (metis assms(1) assms(2) assms(3) assms(4) local.antisym_conv2 local.dual_order.strict_trans1 
+  by (metis assms(1) assms(2) assms(3) assms(4) local.antisym_conv2 local.dual_order.strict_trans1
       local.mult_strict_left_mono local.mult_strict_mono)
 
 end
 
-subclass (in linordered_semiring_strict) ordered_semiring_strict 
+subclass (in linordered_semiring_strict) ordered_semiring_strict
 proof
   show "c * a < c * b"
     if "a < b"
       and "0 < c"
     for a :: 'a
-      and b 
-      and c 
+      and b
+      and c
     using that
-    by (simp add: local.mult_strict_left_mono) 
+    by (simp add: local.mult_strict_left_mono)
   show "a * c < b * c"
     if "a < b"
       and "0 < c"
     for a :: 'a
-      and b 
-      and c 
+      and b
+      and c
     using that
-    by (simp add: local.mult_strict_right_mono) 
+    by (simp add: local.mult_strict_right_mono)
 qed
 
 class ordered_semiring_1_strict = ordered_semiring_strict + semiring_1
-  \<comment> \<open>missing class analogous to \<^class>\<open>linordered_semiring_1_strict\<close> without requiring 
+  \<comment> \<open>missing class analogous to \<^class>\<open>linordered_semiring_1_strict\<close> without requiring
   a total order\<close>
 begin
 
 subclass ordered_semiring_1 ..
 
 lemma convex_bound_lt:
   assumes "x < a" and "y < a" and "0 \<le> u" and "0 \<le> v" and "u + v = 1"
   shows "u * x + v * y < a"
 proof -
   from assms have "u * x + v * y < u * a + v * a"
     by (cases "u = 0") (auto intro!: add_less_le_mono mult_strict_left_mono mult_left_mono)
   with assms show ?thesis
     unfolding distrib_right[symmetric] by simp
 qed
 
 end
 
-subclass (in linordered_semiring_1_strict) ordered_semiring_1_strict .. 
+subclass (in linordered_semiring_1_strict) ordered_semiring_1_strict ..
 
 class ordered_comm_semiring_strict = comm_semiring_0 + ordered_cancel_ab_semigroup_add +
   \<comment> \<open>missing class analogous to \<^class>\<open>linordered_comm_semiring_strict\<close> without requiring a total order\<close>
   assumes comm_mult_strict_left_mono: "a < b \<Longrightarrow> 0 < c \<Longrightarrow> c * a < c * b"
 begin
 
 subclass ordered_semiring_strict
 proof
   fix a b c :: 'a
   assume "a < b" and "0 < c"
   thus "c * a < c * b"
     by (rule comm_mult_strict_left_mono)
   thus "a * c < b * c"
     by (simp only: mult.commute)
 qed
 
 subclass ordered_cancel_comm_semiring
 proof
   fix a b c :: 'a
   assume "a \<le> b" and "0 \<le> c"
   thus "c * a \<le> c * b"
     unfolding le_less
     using mult_strict_left_mono by (cases "c = 0") auto
 qed
 
 end
 
-subclass (in linordered_comm_semiring_strict) ordered_comm_semiring_strict 
+subclass (in linordered_comm_semiring_strict) ordered_comm_semiring_strict
   apply standard
   by (simp add: local.mult_strict_left_mono)
 
 class ordered_ring_strict = ring + ordered_semiring_strict
   + ordered_ab_group_add + partial_abs_if
   \<comment> \<open>missing class analogous to \<^class>\<open>linordered_ring_strict\<close> without requiring a total order\<close>
 begin
 
 subclass ordered_ring ..
 
 lemma mult_strict_left_mono_neg: "b < a \<Longrightarrow> c < 0 \<Longrightarrow> c * a < c * b"
   using mult_strict_left_mono [of b a "- c"] by simp
 
 lemma mult_strict_right_mono_neg: "b < a \<Longrightarrow> c < 0 \<Longrightarrow> a * c < b * c"
   using mult_strict_right_mono [of b a "- c"] by simp
 
 lemma mult_neg_neg: "a < 0 \<Longrightarrow> b < 0 \<Longrightarrow> 0 < a * b"
   using mult_strict_right_mono_neg [of a 0 b] by simp
 
 end
 
 lemmas mult_sign_intros =
   mult_nonneg_nonneg mult_nonneg_nonpos
   mult_nonpos_nonneg mult_nonpos_nonpos
   mult_pos_pos mult_pos_neg
   mult_neg_pos mult_neg_neg
 
 
 subsection \<open>Ordered fields\<close>
 
-class ordered_field = field + order + ordered_comm_semiring_strict + ordered_ab_group_add 
-  + partial_abs_if 
+class ordered_field = field + order + ordered_comm_semiring_strict + ordered_ab_group_add
+  + partial_abs_if
   \<comment> \<open>missing class analogous to \<^class>\<open>linordered_field\<close> without requiring a total order\<close>
 begin
 
 lemma frac_less_eq:
   "y \<noteq> 0 \<Longrightarrow> z \<noteq> 0 \<Longrightarrow> x / y < w / z \<longleftrightarrow> (x * z - w * y) / (y * z) < 0"
   by (subst less_iff_diff_less_0) (simp add: diff_frac_eq )
 
 lemma frac_le_eq:
   "y \<noteq> 0 \<Longrightarrow> z \<noteq> 0 \<Longrightarrow> x / y \<le> w / z \<longleftrightarrow> (x * z - w * y) / (y * z) \<le> 0"
   by (subst le_iff_diff_le_0) (simp add: diff_frac_eq )
 
 lemmas sign_simps = algebra_simps zero_less_mult_iff mult_less_0_iff
 
 lemmas (in -) sign_simps = algebra_simps zero_less_mult_iff mult_less_0_iff
 
 text\<open>Simplify expressions equated with 1\<close>
 
 lemma zero_eq_1_divide_iff [simp]: "0 = 1 / a \<longleftrightarrow> a = 0"
   by (cases "a = 0") (auto simp: field_simps)
 
 lemma one_divide_eq_0_iff [simp]: "1 / a = 0 \<longleftrightarrow> a = 0"
   using zero_eq_1_divide_iff[of a] by simp
 
 text\<open>Simplify expressions such as \<open>0 < 1/x\<close> to \<open>0 < x\<close>\<close>
 
 text\<open>Simplify quotients that are compared with the value 1.\<close>
 
 text \<open>Conditional Simplification Rules: No Case Splits\<close>
 
 lemma eq_divide_eq_1 [simp]:
   "(1 = b/a) = ((a \<noteq> 0 & a = b))"
   by (auto simp add: eq_divide_eq)
 
 lemma divide_eq_eq_1 [simp]:
   "(b/a = 1) = ((a \<noteq> 0 & a = b))"
   by (auto simp add: divide_eq_eq)
 
 end (* class ordered_field *)
 
 
-text \<open>The following type class intends to capture some important properties 
+text \<open>The following type class intends to capture some important properties
   that are common both to the real and the complex numbers. The purpose is
-  to be able to state and prove lemmas that apply both to the real and the complex 
+  to be able to state and prove lemmas that apply both to the real and the complex
   numbers without needing to state the lemma twice.
 \<close>
 
 class nice_ordered_field = ordered_field + zero_less_one + idom_abs_sgn +
   assumes positive_imp_inverse_positive: "0 < a \<Longrightarrow> 0 < inverse a"
     and inverse_le_imp_le: "inverse a \<le> inverse b \<Longrightarrow> 0 < a \<Longrightarrow> b \<le> a"
     and dense_le: "(\<And>x. x < y \<Longrightarrow> x \<le> z) \<Longrightarrow> y \<le> z"
     and nn_comparable: "0 \<le> a \<Longrightarrow> 0 \<le> b \<Longrightarrow> a \<le> b \<or> b \<le> a"
     and abs_nn: "\<bar>x\<bar> \<ge> 0"
 begin
 
 subclass (in linordered_field) nice_ordered_field
 proof
   show "\<bar>a\<bar> = - a"
     if "a \<le> 0"
     for a :: 'a
     using that
-    by simp 
+    by simp
   show "\<bar>a\<bar> = a"
     if "0 \<le> a"
     for a :: 'a
     using that
-    by simp 
+    by simp
   show "0 < inverse a"
     if "0 < a"
     for a :: 'a
     using that
-    by simp 
+    by simp
   show "b \<le> a"
     if "inverse a \<le> inverse b"
       and "0 < a"
     for a :: 'a
       and b
     using that
-    using local.inverse_le_imp_le by blast 
+    using local.inverse_le_imp_le by blast
   show "y \<le> z"
     if "\<And>x::'a. x < y \<Longrightarrow> x \<le> z"
     for y
       and z
     using that
-    using local.dense_le by blast 
+    using local.dense_le by blast
   show "a \<le> b \<or> b \<le> a"
     if "0 \<le> a"
       and "0 \<le> b"
     for a :: 'a
       and b
     using that
-    by auto 
+    by auto
   show "0 \<le> \<bar>x\<bar>"
     for x :: 'a
-    by simp    
+    by simp
 qed
 
 lemma comparable:
   assumes h1: "a \<le> c \<or> a \<ge> c"
     and h2: "b \<le> c \<or> b \<ge> c"
   shows "a \<le> b \<or> b \<le> a"
 proof-
   have "a \<le> b"
     if t1: "\<not> b \<le> a" and t2: "a \<le> c" and t3: "b \<le> c"
   proof-
     have "0 \<le> c-a"
-      by (simp add: t2)      
+      by (simp add: t2)
     moreover have "0 \<le> c-b"
-      by (simp add: t3)      
+      by (simp add: t3)
     ultimately have "c-a \<le> c-b \<or> c-a \<ge> c-b" by (rule nn_comparable)
     hence "-a \<le> -b \<or> -a \<ge> -b"
       using local.add_le_imp_le_right local.uminus_add_conv_diff by presburger
     thus ?thesis
       by (simp add: t1)
   qed
   moreover have "a \<le> b"
     if t1: "\<not> b \<le> a" and t2: "c \<le> a" and t3: "b \<le> c"
   proof-
-    have "b \<le> a"       
-      using local.dual_order.trans t2 t3 by blast 
+    have "b \<le> a"
+      using local.dual_order.trans t2 t3 by blast
     thus ?thesis
       using t1 by auto
   qed
   moreover have "a \<le> b"
     if t1: "\<not> b \<le> a" and t2: "c \<le> a" and t3: "c \<le> b"
   proof-
     have "0 \<le> a-c"
-      by (simp add: t2)        
+      by (simp add: t2)
     moreover have "0 \<le> b-c"
-      by (simp add: t3)      
+      by (simp add: t3)
     ultimately have "a-c \<le> b-c \<or> a-c \<ge> b-c" by (rule nn_comparable)
     hence "a \<le> b \<or> a \<ge> b"
       by (simp add: local.le_diff_eq)
     thus ?thesis
       by (simp add: t1)
   qed
   ultimately show ?thesis using assms by auto
 qed
 
 lemma negative_imp_inverse_negative:
   "a < 0 \<Longrightarrow> inverse a < 0"
   by (insert positive_imp_inverse_positive [of "-a"],
       simp add: nonzero_inverse_minus_eq less_imp_not_eq)
 
 lemma inverse_positive_imp_positive:
   assumes inv_gt_0: "0 < inverse a" and nz: "a \<noteq> 0"
   shows "0 < a"
 proof -
   have "0 < inverse (inverse a)"
     using inv_gt_0 by (rule positive_imp_inverse_positive)
   thus "0 < a"
     using nz by (simp add: nonzero_inverse_inverse_eq)
 qed
 
 lemma inverse_negative_imp_negative:
   assumes inv_less_0: "inverse a < 0" and nz: "a \<noteq> 0"
   shows "a < 0"
 proof-
   have "inverse (inverse a) < 0"
     using inv_less_0 by (rule negative_imp_inverse_negative)
   thus "a < 0" using nz by (simp add: nonzero_inverse_inverse_eq)
 qed
 
 lemma linordered_field_no_lb:
   "\<forall>x. \<exists>y. y < x"
 proof
   fix x::'a
   have m1: "- (1::'a) < 0" by simp
   from add_strict_right_mono[OF m1, where c=x]
   have "(- 1) + x < x" by simp
   thus "\<exists>y. y < x" by blast
 qed
 
 lemma linordered_field_no_ub:
   "\<forall>x. \<exists>y. y > x"
 proof
   fix x::'a
   have m1: " (1::'a) > 0" by simp
   from add_strict_right_mono[OF m1, where c=x]
   have "1 + x > x" by simp
   thus "\<exists>y. y > x" by blast
 qed
 
 lemma less_imp_inverse_less:
   assumes less: "a < b" and apos:  "0 < a"
   shows "inverse b < inverse a"
-  using assms by (metis local.dual_order.strict_iff_order 
+  using assms by (metis local.dual_order.strict_iff_order
       local.inverse_inverse_eq local.inverse_le_imp_le local.positive_imp_inverse_positive)
 
 lemma inverse_less_imp_less:
   "inverse a < inverse b \<Longrightarrow> 0 < a \<Longrightarrow> b < a"
   using local.inverse_le_imp_le local.order.strict_iff_order by blast
 
 text\<open>Both premises are essential. Consider -1 and 1.\<close>
 lemma inverse_less_iff_less [simp]:
   "0 < a \<Longrightarrow> 0 < b \<Longrightarrow> inverse a < inverse b \<longleftrightarrow> b < a"
   by (blast intro: less_imp_inverse_less dest: inverse_less_imp_less)
 
 lemma le_imp_inverse_le:
   "a \<le> b \<Longrightarrow> 0 < a \<Longrightarrow> inverse b \<le> inverse a"
   by (force simp add: le_less less_imp_inverse_less)
 
 lemma inverse_le_iff_le [simp]:
   "0 < a \<Longrightarrow> 0 < b \<Longrightarrow> inverse a \<le> inverse b \<longleftrightarrow> b \<le> a"
   by (blast intro: le_imp_inverse_le dest: inverse_le_imp_le)
 
 
 text\<open>These results refer to both operands being negative.  The opposite-sign
 case is trivial, since inverse preserves signs.\<close>
 lemma inverse_le_imp_le_neg:
   "inverse a \<le> inverse b \<Longrightarrow> b < 0 \<Longrightarrow> b \<le> a"
-  by (metis local.inverse_le_imp_le local.inverse_minus_eq local.neg_0_less_iff_less 
+  by (metis local.inverse_le_imp_le local.inverse_minus_eq local.neg_0_less_iff_less
       local.neg_le_iff_le)
 
 lemma inverse_less_imp_less_neg:
   "inverse a < inverse b \<Longrightarrow> b < 0 \<Longrightarrow> b < a"
   using local.dual_order.strict_iff_order local.inverse_le_imp_le_neg by blast
 
 lemma inverse_less_iff_less_neg [simp]:
   "a < 0 \<Longrightarrow> b < 0 \<Longrightarrow> inverse a < inverse b \<longleftrightarrow> b < a"
-  by (metis local.antisym_conv2 local.inverse_less_imp_less_neg local.negative_imp_inverse_negative 
+  by (metis local.antisym_conv2 local.inverse_less_imp_less_neg local.negative_imp_inverse_negative
       local.nonzero_inverse_inverse_eq local.order.strict_implies_order)
 
 lemma le_imp_inverse_le_neg:
   "a \<le> b \<Longrightarrow> b < 0 \<Longrightarrow> inverse b \<le> inverse a"
   by (force simp add: le_less less_imp_inverse_less_neg)
 
 lemma inverse_le_iff_le_neg [simp]:
   "a < 0 \<Longrightarrow> b < 0 \<Longrightarrow> inverse a \<le> inverse b \<longleftrightarrow> b \<le> a"
   by (blast intro: le_imp_inverse_le_neg dest: inverse_le_imp_le_neg)
 
 lemma one_less_inverse:
   "0 < a \<Longrightarrow> a < 1 \<Longrightarrow> 1 < inverse a"
   using less_imp_inverse_less [of a 1, unfolded inverse_1] .
 
 lemma one_le_inverse:
   "0 < a \<Longrightarrow> a \<le> 1 \<Longrightarrow> 1 \<le> inverse a"
   using le_imp_inverse_le [of a 1, unfolded inverse_1] .
 
 lemma pos_le_divide_eq [field_simps]:
   assumes "0 < c"
   shows "a \<le> b / c \<longleftrightarrow> a * c \<le> b"
-  using assms by (metis local.divide_eq_imp local.divide_inverse_commute 
-      local.dual_order.order_iff_strict local.dual_order.strict_iff_order 
-      local.mult_right_mono local.mult_strict_left_mono local.nonzero_divide_eq_eq 
+  using assms by (metis local.divide_eq_imp local.divide_inverse_commute
+      local.dual_order.order_iff_strict local.dual_order.strict_iff_order
+      local.mult_right_mono local.mult_strict_left_mono local.nonzero_divide_eq_eq
       local.order.strict_implies_order local.positive_imp_inverse_positive)
 
 lemma pos_less_divide_eq [field_simps]:
   assumes "0 < c"
   shows "a < b / c \<longleftrightarrow> a * c < b"
-  using assms local.dual_order.strict_iff_order local.nonzero_divide_eq_eq local.pos_le_divide_eq 
+  using assms local.dual_order.strict_iff_order local.nonzero_divide_eq_eq local.pos_le_divide_eq
   by auto
 
 lemma neg_less_divide_eq [field_simps]:
   assumes "c < 0"
   shows "a < b / c \<longleftrightarrow> b < a * c"
-  by (metis assms local.minus_divide_divide local.mult_minus_right local.neg_0_less_iff_less 
+  by (metis assms local.minus_divide_divide local.mult_minus_right local.neg_0_less_iff_less
       local.neg_less_iff_less local.pos_less_divide_eq)
 
 lemma neg_le_divide_eq [field_simps]:
   assumes "c < 0"
   shows "a \<le> b / c \<longleftrightarrow> b \<le> a * c"
-  by (metis assms local.dual_order.order_iff_strict local.dual_order.strict_iff_order 
+  by (metis assms local.dual_order.order_iff_strict local.dual_order.strict_iff_order
       local.neg_less_divide_eq local.nonzero_divide_eq_eq)
 
 lemma pos_divide_le_eq [field_simps]:
   assumes "0 < c"
   shows "b / c \<le> a \<longleftrightarrow> b \<le> a * c"
-  by (metis assms local.dual_order.strict_iff_order local.nonzero_eq_divide_eq 
+  by (metis assms local.dual_order.strict_iff_order local.nonzero_eq_divide_eq
       local.pos_le_divide_eq)
 
 lemma pos_divide_less_eq [field_simps]:
   assumes "0 < c"
   shows "b / c < a \<longleftrightarrow> b < a * c"
-  by (metis assms local.minus_divide_left local.mult_minus_left local.neg_less_iff_less 
+  by (metis assms local.minus_divide_left local.mult_minus_left local.neg_less_iff_less
       local.pos_less_divide_eq)
 
 lemma neg_divide_le_eq [field_simps]:
   assumes "c < 0"
   shows "b / c \<le> a \<longleftrightarrow> a * c \<le> b"
-  by (metis assms local.minus_divide_left local.mult_minus_left local.neg_le_divide_eq 
+  by (metis assms local.minus_divide_left local.mult_minus_left local.neg_le_divide_eq
       local.neg_le_iff_le)
 
 lemma neg_divide_less_eq [field_simps]:
   assumes "c < 0"
   shows "b / c < a \<longleftrightarrow> a * c < b"
   using assms local.dual_order.strict_iff_order local.neg_divide_le_eq by auto
 
 text\<open>The following \<open>field_simps\<close> rules are necessary, as minus is always moved atop of
 division but we want to get rid of division.\<close>
 
 lemma pos_le_minus_divide_eq [field_simps]: "0 < c \<Longrightarrow> a \<le> - (b / c) \<longleftrightarrow> a * c \<le> - b"
   unfolding minus_divide_left by (rule pos_le_divide_eq)
 
 lemma neg_le_minus_divide_eq [field_simps]: "c < 0 \<Longrightarrow> a \<le> - (b / c) \<longleftrightarrow> - b \<le> a * c"
   unfolding minus_divide_left by (rule neg_le_divide_eq)
 
 lemma pos_less_minus_divide_eq [field_simps]: "0 < c \<Longrightarrow> a < - (b / c) \<longleftrightarrow> a * c < - b"
   unfolding minus_divide_left by (rule pos_less_divide_eq)
 
 lemma neg_less_minus_divide_eq [field_simps]: "c < 0 \<Longrightarrow> a < - (b / c) \<longleftrightarrow> - b < a * c"
   unfolding minus_divide_left by (rule neg_less_divide_eq)
 
 lemma pos_minus_divide_less_eq [field_simps]: "0 < c \<Longrightarrow> - (b / c) < a \<longleftrightarrow> - b < a * c"
   unfolding minus_divide_left by (rule pos_divide_less_eq)
 
 lemma neg_minus_divide_less_eq [field_simps]: "c < 0 \<Longrightarrow> - (b / c) < a \<longleftrightarrow> a * c < - b"
   unfolding minus_divide_left by (rule neg_divide_less_eq)
 
 lemma pos_minus_divide_le_eq [field_simps]: "0 < c \<Longrightarrow> - (b / c) \<le> a \<longleftrightarrow> - b \<le> a * c"
   unfolding minus_divide_left by (rule pos_divide_le_eq)
 
 lemma neg_minus_divide_le_eq [field_simps]: "c < 0 \<Longrightarrow> - (b / c) \<le> a \<longleftrightarrow> a * c \<le> - b"
   unfolding minus_divide_left by (rule neg_divide_le_eq)
 
 lemma frac_less_eq:
   "y \<noteq> 0 \<Longrightarrow> z \<noteq> 0 \<Longrightarrow> x / y < w / z \<longleftrightarrow> (x * z - w * y) / (y * z) < 0"
   by (subst less_iff_diff_less_0) (simp add: diff_frac_eq )
 
 lemma frac_le_eq:
   "y \<noteq> 0 \<Longrightarrow> z \<noteq> 0 \<Longrightarrow> x / y \<le> w / z \<longleftrightarrow> (x * z - w * y) / (y * z) \<le> 0"
   by (subst le_iff_diff_le_0) (simp add: diff_frac_eq )
 
 
 text\<open>Lemmas \<open>sign_simps\<close> is a first attempt to automate proofs
-of positivity/negativity needed for \<open>field_simps\<close>. Have not added \<open>sign_simps\<close> to \<open>field_simps\<close> 
+of positivity/negativity needed for \<open>field_simps\<close>. Have not added \<open>sign_simps\<close> to \<open>field_simps\<close>
   because the former can lead to case explosions.\<close>
 
 lemma divide_pos_pos[simp]:
   "0 < x \<Longrightarrow> 0 < y \<Longrightarrow> 0 < x / y"
   by(simp add:field_simps)
 
 lemma divide_nonneg_pos:
   "0 \<le> x \<Longrightarrow> 0 < y \<Longrightarrow> 0 \<le> x / y"
   by(simp add:field_simps)
 
 lemma divide_neg_pos:
   "x < 0 \<Longrightarrow> 0 < y \<Longrightarrow> x / y < 0"
   by(simp add:field_simps)
 
 lemma divide_nonpos_pos:
   "x \<le> 0 \<Longrightarrow> 0 < y \<Longrightarrow> x / y \<le> 0"
   by(simp add:field_simps)
 
 lemma divide_pos_neg:
   "0 < x \<Longrightarrow> y < 0 \<Longrightarrow> x / y < 0"
   by(simp add:field_simps)
 
 lemma divide_nonneg_neg:
   "0 \<le> x \<Longrightarrow> y < 0 \<Longrightarrow> x / y \<le> 0"
   by(simp add:field_simps)
 
 lemma divide_neg_neg:
   "x < 0 \<Longrightarrow> y < 0 \<Longrightarrow> 0 < x / y"
   by(simp add:field_simps)
 
 lemma divide_nonpos_neg:
   "x \<le> 0 \<Longrightarrow> y < 0 \<Longrightarrow> 0 \<le> x / y"
   by(simp add:field_simps)
 
 lemma divide_strict_right_mono:
   "a < b \<Longrightarrow> 0 < c \<Longrightarrow> a / c < b / c"
   by (simp add: less_imp_not_eq2 divide_inverse mult_strict_right_mono
       positive_imp_inverse_positive)
 
 
 lemma divide_strict_right_mono_neg:
   "b < a \<Longrightarrow> c < 0 \<Longrightarrow> a / c < b / c"
   by (simp add: local.neg_less_divide_eq)
 
 text\<open>The last premise ensures that \<^term>\<open>a\<close> and \<^term>\<open>b\<close>
       have the same sign\<close>
 lemma divide_strict_left_mono:
   "b < a \<Longrightarrow> 0 < c \<Longrightarrow> 0 < a*b \<Longrightarrow> c / a < c / b"
   by (metis local.divide_neg_pos local.dual_order.strict_iff_order local.frac_less_eq local.less_iff_diff_less_0 local.mult_not_zero local.mult_strict_left_mono)
 
 lemma divide_left_mono:
   "b \<le> a \<Longrightarrow> 0 \<le> c \<Longrightarrow> 0 < a*b \<Longrightarrow> c / a \<le> c / b"
   using local.divide_cancel_left local.divide_strict_left_mono local.dual_order.order_iff_strict by auto
 
 lemma divide_strict_left_mono_neg:
   "a < b \<Longrightarrow> c < 0 \<Longrightarrow> 0 < a*b \<Longrightarrow> c / a < c / b"
   by (metis local.divide_strict_left_mono local.minus_divide_left local.neg_0_less_iff_less local.neg_less_iff_less mult_commute)
 
 lemma mult_imp_div_pos_le: "0 < y \<Longrightarrow> x \<le> z * y \<Longrightarrow> x / y \<le> z"
   by (subst pos_divide_le_eq, assumption+)
 
 lemma mult_imp_le_div_pos: "0 < y \<Longrightarrow> z * y \<le> x \<Longrightarrow> z \<le> x / y"
   by(simp add:field_simps)
 
 lemma mult_imp_div_pos_less: "0 < y \<Longrightarrow> x < z * y \<Longrightarrow> x / y < z"
   by(simp add:field_simps)
 
 lemma mult_imp_less_div_pos: "0 < y \<Longrightarrow> z * y < x \<Longrightarrow> z < x / y"
   by(simp add:field_simps)
 
 lemma frac_le: "0 \<le> x \<Longrightarrow> x \<le> y \<Longrightarrow> 0 < w \<Longrightarrow> w \<le> z  \<Longrightarrow> x / z \<le> y / w"
   using local.mult_imp_div_pos_le local.mult_imp_le_div_pos local.mult_mono by auto
 
 lemma frac_less: "0 \<le> x \<Longrightarrow> x < y \<Longrightarrow> 0 < w \<Longrightarrow> w \<le> z \<Longrightarrow> x / z < y / w"
 proof-
   assume a1: "w \<le> z"
   assume a2: "0 < w"
   assume a3: "0 \<le> x"
   assume a4: "x < y"
   have f5: "a = 0 \<or> (b = c / a) = (b * a = c)"
     for a b c::'a
     by (meson local.nonzero_eq_divide_eq)
   have f6: "0 < z"
-    using a2 a1 by (meson local.order.ordering_axioms ordering.strict_trans2)
+    using a2 a1 by (meson local.order.ordering_axioms order.strict_trans2)
   have "z \<noteq> 0"
     using a2 a1 by (meson local.leD)
   moreover have "x / z \<noteq> y / w"
     using a1 a2 a3 a4 local.frac_eq_eq local.mult_less_le_imp_less by fastforce
   ultimately have "x / z \<noteq> y / w"
     using f5 by (metis (no_types))
   thus ?thesis
-    using a4 a3 a2 a1 by (meson local.frac_le local.order.not_eq_order_implies_strict 
+    using a4 a3 a2 a1 by (meson local.frac_le local.order.not_eq_order_implies_strict
         local.order.strict_implies_order)
 qed
 
 
 lemma frac_less2: "0 < x \<Longrightarrow> x \<le> y \<Longrightarrow> 0 < w \<Longrightarrow> w < z  \<Longrightarrow> x / z < y / w"
-  by (metis local.antisym_conv2 local.divide_cancel_left local.dual_order.strict_implies_order 
+  by (metis local.antisym_conv2 local.divide_cancel_left local.dual_order.strict_implies_order
       local.frac_le local.frac_less)
 
 lemma less_half_sum: "a < b \<Longrightarrow> a < (a+b) / (1+1)"
   by (metis local.add_pos_pos local.add_strict_left_mono local.mult_imp_less_div_pos local.semiring_normalization_rules(4) local.zero_less_one mult_commute)
 
 lemma gt_half_sum: "a < b \<Longrightarrow> (a+b)/(1+1) < b"
   by (metis local.add_pos_pos local.add_strict_left_mono local.mult_imp_div_pos_less local.semiring_normalization_rules(24) local.semiring_normalization_rules(4) local.zero_less_one mult_commute)
 
 subclass unbounded_dense_order
 proof
   fix x y :: 'a
   have less_add_one: "a < a + 1" for a::'a by auto
   from less_add_one show "\<exists>y. x < y"
-    by blast 
+    by blast
 
   from less_add_one have "x + (- 1) < (x + 1) + (- 1)"
     by (rule add_strict_right_mono)
   hence "x - 1 < x + 1 - 1" by simp
   hence "x - 1 < x" by (simp add: algebra_simps)
   thus "\<exists>y. y < x" ..
   show "x < y \<Longrightarrow> \<exists>z>x. z < y" by (blast intro!: less_half_sum gt_half_sum)
 qed
 
 
 lemma dense_le_bounded:
   fixes x y z :: 'a
   assumes "x < y"
     and *: "\<And>w. \<lbrakk> x < w ; w < y \<rbrakk> \<Longrightarrow> w \<le> z"
   shows "y \<le> z"
 proof (rule dense_le)
   fix w assume "w < y"
   from dense[OF \<open>x < y\<close>] obtain u where "x < u" "u < y" by safe
   have "u \<le> w \<or> w \<le> u"
     using \<open>u < y\<close> \<open>w < y\<close> comparable local.order.strict_implies_order by blast
   thus "w \<le> z"
     using "*" \<open>u < y\<close> \<open>w < y\<close> \<open>x < u\<close> local.dual_order.trans local.order.strict_trans2 by blast
 qed
 
 subclass field_abs_sgn ..
 
 
 lemma nonzero_abs_inverse:
   "a \<noteq> 0 \<Longrightarrow> \<bar>inverse a\<bar> = inverse \<bar>a\<bar>"
   by (rule abs_inverse)
 
 lemma nonzero_abs_divide:
   "b \<noteq> 0 \<Longrightarrow> \<bar>a / b\<bar> = \<bar>a\<bar> / \<bar>b\<bar>"
   by (rule abs_divide)
 
 lemma field_le_epsilon:
   assumes e: "\<And>e. 0 < e \<Longrightarrow> x \<le> y + e"
   shows "x \<le> y"
 proof (rule dense_le)
   fix t assume "t < x"
   hence "0 < x - t" by (simp add: less_diff_eq)
   from e [OF this] have "x + 0 \<le> x + (y - t)" by (simp add: algebra_simps)
   hence "0 \<le> y - t" by (simp only: add_le_cancel_left)
   thus "t \<le> y" by (simp add: algebra_simps)
 qed
 
 lemma inverse_positive_iff_positive [simp]:
   "(0 < inverse a) = (0 < a)"
   using local.positive_imp_inverse_positive by fastforce
 
 lemma inverse_negative_iff_negative [simp]:
   "(inverse a < 0) = (a < 0)"
   using local.negative_imp_inverse_negative by fastforce
 
 lemma inverse_nonnegative_iff_nonnegative [simp]:
   "0 \<le> inverse a \<longleftrightarrow> 0 \<le> a"
   by (simp add: local.dual_order.order_iff_strict)
 
 lemma inverse_nonpositive_iff_nonpositive [simp]:
   "inverse a \<le> 0 \<longleftrightarrow> a \<le> 0"
   using local.inverse_nonnegative_iff_nonnegative local.neg_0_le_iff_le by fastforce
 
 lemma one_less_inverse_iff: "1 < inverse x \<longleftrightarrow> 0 < x \<and> x < 1"
   using less_trans[of 1 x 0 for x]
   by (metis local.dual_order.strict_trans local.inverse_1 local.inverse_less_imp_less local.inverse_positive_iff_positive local.one_less_inverse local.zero_less_one)
 
 lemma one_le_inverse_iff: "1 \<le> inverse x \<longleftrightarrow> 0 < x \<and> x \<le> 1"
   by (metis local.dual_order.strict_trans1 local.inverse_1 local.inverse_le_imp_le local.inverse_positive_iff_positive local.one_le_inverse local.zero_less_one)
 
 lemma inverse_less_1_iff: "inverse x < 1 \<longleftrightarrow> x \<le> 0 \<or> 1 < x"
 proof (rule)
   assume invx1: "inverse x < 1"
   have "inverse x \<le> 0 \<or> inverse x \<ge> 0"
     using comparable invx1 local.order.strict_implies_order local.zero_less_one by blast
   then consider (leq0) "inverse x \<le> 0" | (pos) "inverse x > 0" | (zero) "inverse x = 0"
     using local.antisym_conv1 by blast
   thus "x \<le> 0 \<or> 1 < x"
-    by (metis invx1 local.eq_iff local.inverse_1 local.inverse_less_imp_less 
-        local.inverse_nonpositive_iff_nonpositive local.inverse_positive_imp_positive)
+    by (metis invx1 local.eq_refl local.inverse_1 inverse_less_imp_less
+              inverse_nonpositive_iff_nonpositive inverse_positive_iff_positive)
 next
   assume "x \<le> 0 \<or> 1 < x"
   then consider (neg) "x \<le> 0" | (g1) "1 < x" by auto
   thus "inverse x < 1"
     by (metis local.dual_order.not_eq_order_implies_strict local.dual_order.strict_trans
-        local.inverse_1 local.inverse_negative_iff_negative local.inverse_zero 
-        local.less_imp_inverse_less local.zero_less_one)  
+        local.inverse_1 local.inverse_negative_iff_negative local.inverse_zero
+        local.less_imp_inverse_less local.zero_less_one)
 qed
 
 lemma inverse_le_1_iff: "inverse x \<le> 1 \<longleftrightarrow> x \<le> 0 \<or> 1 \<le> x"
-  by (metis local.dual_order.order_iff_strict local.inverse_1 local.inverse_le_iff_le 
+  by (metis local.dual_order.order_iff_strict local.inverse_1 local.inverse_le_iff_le
       local.inverse_less_1_iff local.one_le_inverse_iff)
 
 text\<open>Simplify expressions such as \<open>0 < 1/x\<close> to \<open>0 < x\<close>\<close>
 
 lemma zero_le_divide_1_iff [simp]:
   "0 \<le> 1 / a \<longleftrightarrow> 0 \<le> a"
-  using local.dual_order.order_iff_strict local.inverse_eq_divide 
+  using local.dual_order.order_iff_strict local.inverse_eq_divide
     local.inverse_positive_iff_positive by auto
 
 lemma zero_less_divide_1_iff [simp]:
   "0 < 1 / a \<longleftrightarrow> 0 < a"
   by (simp add: local.dual_order.strict_iff_order)
 
 lemma divide_le_0_1_iff [simp]:
   "1 / a \<le> 0 \<longleftrightarrow> a \<le> 0"
-  by (smt local.abs_0 local.abs_1 local.abs_divide local.abs_neg local.abs_nn 
+  by (smt local.abs_0 local.abs_1 local.abs_divide local.abs_neg local.abs_nn
       local.divide_cancel_left local.le_minus_iff local.minus_divide_right local.zero_neq_one)
 
 lemma divide_less_0_1_iff [simp]:
   "1 / a < 0 \<longleftrightarrow> a < 0"
   using local.dual_order.strict_iff_order by auto
 
 lemma divide_right_mono:
   "a \<le> b \<Longrightarrow> 0 \<le> c \<Longrightarrow> a/c \<le> b/c"
   using local.divide_cancel_right local.divide_strict_right_mono local.dual_order.order_iff_strict by blast
 
 lemma divide_right_mono_neg: "a \<le> b
     \<Longrightarrow> c \<le> 0 \<Longrightarrow> b / c \<le> a / c"
   by (metis local.divide_cancel_right local.divide_strict_right_mono_neg local.dual_order.strict_implies_order local.eq_refl local.le_imp_less_or_eq)
 
 lemma divide_left_mono_neg: "a \<le> b
-    \<Longrightarrow> c \<le> 0 \<Longrightarrow> 0 < a * b \<Longrightarrow> c / a \<le> c / b"  
+    \<Longrightarrow> c \<le> 0 \<Longrightarrow> 0 < a * b \<Longrightarrow> c / a \<le> c / b"
   by (metis local.divide_left_mono local.minus_divide_left local.neg_0_le_iff_le local.neg_le_iff_le mult_commute)
 
 lemma divide_nonneg_nonneg [simp]:
   "0 \<le> x \<Longrightarrow> 0 \<le> y \<Longrightarrow> 0 \<le> x / y"
   using local.divide_eq_0_iff local.divide_nonneg_pos local.dual_order.order_iff_strict by blast
 
 lemma divide_nonpos_nonpos:
   "x \<le> 0 \<Longrightarrow> y \<le> 0 \<Longrightarrow> 0 \<le> x / y"
   using local.divide_nonpos_neg local.dual_order.order_iff_strict by auto
 
 lemma divide_nonneg_nonpos:
   "0 \<le> x \<Longrightarrow> y \<le> 0 \<Longrightarrow> x / y \<le> 0"
   by (metis local.divide_eq_0_iff local.divide_nonneg_neg local.dual_order.order_iff_strict)
 
 lemma divide_nonpos_nonneg:
   "x \<le> 0 \<Longrightarrow> 0 \<le> y \<Longrightarrow> x / y \<le> 0"
   using local.divide_nonpos_pos local.dual_order.order_iff_strict by auto
 
 text \<open>Conditional Simplification Rules: No Case Splits\<close>
 
 lemma le_divide_eq_1_pos [simp]:
   "0 < a \<Longrightarrow> (1 \<le> b/a) = (a \<le> b)"
   by (simp add: local.pos_le_divide_eq)
 
 lemma le_divide_eq_1_neg [simp]:
   "a < 0 \<Longrightarrow> (1 \<le> b/a) = (b \<le> a)"
   by (metis local.le_divide_eq_1_pos local.minus_divide_divide local.neg_0_less_iff_less local.neg_le_iff_le)
 
 lemma divide_le_eq_1_pos [simp]:
   "0 < a \<Longrightarrow> (b/a \<le> 1) = (b \<le> a)"
   using local.pos_divide_le_eq by auto
 
 lemma divide_le_eq_1_neg [simp]:
   "a < 0 \<Longrightarrow> (b/a \<le> 1) = (a \<le> b)"
-  by (metis local.divide_le_eq_1_pos local.minus_divide_divide local.neg_0_less_iff_less 
+  by (metis local.divide_le_eq_1_pos local.minus_divide_divide local.neg_0_less_iff_less
       local.neg_le_iff_le)
 
 lemma less_divide_eq_1_pos [simp]:
   "0 < a \<Longrightarrow> (1 < b/a) = (a < b)"
   by (simp add: local.dual_order.strict_iff_order)
 
 lemma less_divide_eq_1_neg [simp]:
   "a < 0 \<Longrightarrow> (1 < b/a) = (b < a)"
   using local.dual_order.strict_iff_order by auto
 
 lemma divide_less_eq_1_pos [simp]:
   "0 < a \<Longrightarrow> (b/a < 1) = (b < a)"
   using local.divide_le_eq_1_pos local.dual_order.strict_iff_order by auto
 
 lemma divide_less_eq_1_neg [simp]:
   "a < 0 \<Longrightarrow> b/a < 1 \<longleftrightarrow> a < b"
   using local.dual_order.strict_iff_order by auto
 
 lemma abs_div_pos: "0 < y \<Longrightarrow>
     \<bar>x\<bar> / y = \<bar>x / y\<bar>"
   by (simp add: local.abs_pos)
 
 lemma zero_le_divide_abs_iff [simp]: "(0 \<le> a / \<bar>b\<bar>) = (0 \<le> a | b = 0)"
-proof 
+proof
   assume assm: "0 \<le> a / \<bar>b\<bar>"
   have absb: "abs b \<ge> 0" by (fact abs_nn)
   thus "0 \<le> a \<or> b = 0"
     using absb assm local.abs_eq_0_iff local.mult_nonneg_nonneg by fastforce
 next
   assume "0 \<le> a \<or> b = 0"
   then consider (a) "0 \<le> a" | (b) "b = 0" by atomize_elim auto
   thus "0 \<le> a / \<bar>b\<bar>"
     by (metis local.abs_eq_0_iff local.abs_nn local.divide_eq_0_iff local.divide_nonneg_nonneg)
 qed
 
 
 lemma divide_le_0_abs_iff [simp]: "(a / \<bar>b\<bar> \<le> 0) = (a \<le> 0 | b = 0)"
   by (metis local.minus_divide_left local.neg_0_le_iff_le local.zero_le_divide_abs_iff)
 
 text\<open>For creating values between \<^term>\<open>u\<close> and \<^term>\<open>v\<close>.\<close>
 lemma scaling_mono:
   assumes "u \<le> v" and "0 \<le> r" and "r \<le> s"
   shows "u + r * (v - u) / s \<le> v"
 proof -
   have "r/s \<le> 1" using assms
-    by (metis local.divide_le_eq_1_pos local.division_ring_divide_zero 
+    by (metis local.divide_le_eq_1_pos local.division_ring_divide_zero
         local.dual_order.order_iff_strict local.dual_order.trans local.zero_less_one)
   hence "(r/s) * (v - u) \<le> 1 * (v - u)"
     using assms(1) local.diff_ge_0_iff_ge local.mult_right_mono by blast
   thus ?thesis
     by (simp add: field_simps)
 qed
 
 end (* class nice_ordered_field *)
 
 
 code_identifier
   code_module Ordered_Fields \<rightharpoonup> (SML) Arith and (OCaml) Arith and (Haskell) Arith
 
 subsection\<open>Ordered Complex\<close>
 
 declare Conjugate.less_eq_complex_def[simp del]
 declare Conjugate.less_complex_def[simp del]
 
 subsection \<open>Ordering on complex numbers\<close>
 
 instantiation complex :: nice_ordered_field begin
 instance
 proof intro_classes
   note defs = less_eq_complex_def less_complex_def abs_complex_def
   fix x y z a b c :: complex
   show "a \<le> 0 \<Longrightarrow> \<bar>a\<bar> = - a" unfolding defs
     by (simp add: cmod_eq_Re complex_is_Real_iff)
   show "0 \<le> a \<Longrightarrow> \<bar>a\<bar> = a"
     unfolding defs
     by (metis abs_of_nonneg cmod_eq_Re comp_apply complex.exhaust_sel complex_of_real_def zero_complex.simps(1) zero_complex.simps(2))
   show "a < b \<Longrightarrow> 0 < c \<Longrightarrow> c * a < c * b" unfolding defs by auto
   show "0 < (1::complex)" unfolding defs by simp
   show "0 < a \<Longrightarrow> 0 < inverse a" unfolding defs by auto
   define ra ia rb ib rc ic where "ra = Re a" "ia = Im a" "rb = Re b" "ib = Im b" "rc = Re c" "ic = Im c"
   note ri = this[symmetric]
   hence "a = Complex ra ia" "b = Complex rb ib" "c = Complex rc ic" by auto
   note ri = this ri
   have "rb \<le> ra"
-    if "1 / ra \<le> (if rb = 0 then 0 else 1 / rb)" 
+    if "1 / ra \<le> (if rb = 0 then 0 else 1 / rb)"
       and "ia = 0" and "0 < ra" and "ib = 0"
   proof(cases "rb = 0")
     case True
     thus ?thesis
-      using that(3) by auto 
+      using that(3) by auto
   next
     case False
     thus ?thesis
-      by (smt nice_ordered_field_class.frac_less2 that(1) that(3)) 
+      by (smt nice_ordered_field_class.frac_less2 that(1) that(3))
   qed
   thus "inverse a \<le> inverse b \<Longrightarrow> 0 < a \<Longrightarrow> b \<le> a" unfolding defs ri
-    by (auto simp: power2_eq_square) 
+    by (auto simp: power2_eq_square)
   show "(\<And>a. a < b \<Longrightarrow> a \<le> c) \<Longrightarrow> b \<le> c" unfolding defs ri
-    by (metis complex.sel(1) complex.sel(2) dense less_le_not_le 
-        nice_ordered_field_class.linordered_field_no_lb not_le_imp_less)    
+    by (metis complex.sel(1) complex.sel(2) dense less_le_not_le
+        nice_ordered_field_class.linordered_field_no_lb not_le_imp_less)
   show "0 \<le> a \<Longrightarrow> 0 \<le> b \<Longrightarrow> a \<le> b \<or> b \<le> a" unfolding defs by auto
   show "0 \<le> \<bar>x\<bar>" unfolding defs by auto
 qed
 end
 
-lemma less_eq_complexI: "Re x \<le> Re y \<Longrightarrow> Im x = Im y \<Longrightarrow> x\<le>y" unfolding less_eq_complex_def 
+lemma less_eq_complexI: "Re x \<le> Re y \<Longrightarrow> Im x = Im y \<Longrightarrow> x\<le>y" unfolding less_eq_complex_def
   by simp
-lemma less_complexI: "Re x < Re y \<Longrightarrow> Im x = Im y \<Longrightarrow> x<y" unfolding less_complex_def 
+lemma less_complexI: "Re x < Re y \<Longrightarrow> Im x = Im y \<Longrightarrow> x<y" unfolding less_complex_def
   by simp
 
 lemma complex_of_real_mono:
   "x \<le> y \<Longrightarrow> complex_of_real x \<le> complex_of_real y"
   unfolding less_eq_complex_def by auto
 
 lemma complex_of_real_mono_iff[simp]:
   "complex_of_real x \<le> complex_of_real y \<longleftrightarrow> x \<le> y"
   unfolding less_eq_complex_def by auto
 
 lemma complex_of_real_strict_mono_iff[simp]:
   "complex_of_real x < complex_of_real y \<longleftrightarrow> x < y"
   unfolding less_complex_def by auto
 
 lemma complex_of_real_nn_iff[simp]:
   "0 \<le> complex_of_real y \<longleftrightarrow> 0 \<le> y"
   unfolding less_eq_complex_def by auto
 
 lemma complex_of_real_pos_iff[simp]:
   "0 < complex_of_real y \<longleftrightarrow> 0 < y"
   unfolding less_complex_def by auto
 
 lemma Re_mono: "x \<le> y \<Longrightarrow> Re x \<le> Re y"
   unfolding less_eq_complex_def by simp
 
 lemma comp_Im_same: "x \<le> y \<Longrightarrow> Im x = Im y"
   unfolding less_eq_complex_def by simp
 
 lemma Re_strict_mono: "x < y \<Longrightarrow> Re x < Re y"
   unfolding less_complex_def by simp
 
 lemma complex_of_real_cmod: assumes "x \<ge> 0" shows "complex_of_real (cmod x) = x"
   by (metis Reals_cases abs_of_nonneg assms comp_Im_same complex_is_Real_iff complex_of_real_nn_iff norm_of_real zero_complex.simps(2))
 
 
 end
diff --git a/thys/Complex_Bounded_Operators/extra/Extra_Pretty_Code_Examples.thy b/thys/Complex_Bounded_Operators/extra/Extra_Pretty_Code_Examples.thy
--- a/thys/Complex_Bounded_Operators/extra/Extra_Pretty_Code_Examples.thy
+++ b/thys/Complex_Bounded_Operators/extra/Extra_Pretty_Code_Examples.thy
@@ -1,73 +1,73 @@
 section \<open>\<open>Extra_Pretty_Code_Examples\<close> -- Setup for nicer output of \<open>value\<close>\<close>
 
 theory Extra_Pretty_Code_Examples
   imports 
-    "HOL-ex.Sqrt"
+    "HOL-Examples.Sqrt"
     Real_Impl.Real_Impl
     "HOL-Library.Code_Target_Numeral" 
     Jordan_Normal_Form.Matrix_Impl
 begin
 
 text \<open>Some setup that makes the output of the \<open>value\<close> command more readable
       if matrices and complex numbers are involved.
 
       It is not recommended to import this theory in theories that get included in actual
       developments (because of the changes to the code generation setup).
 
       It is meant for inclusion in example theories only.\<close>
 
 lemma two_sqrt_irrat[simp]: "2 \<in> sqrt_irrat"
   using sqrt_prime_irrational[OF two_is_prime_nat]
   unfolding Rats_def sqrt_irrat_def image_def apply auto
 proof - (* Sledgehammer proof *)
   fix p :: rat
   assume "p * p = 2"
   hence f1: "(Ratreal p)\<^sup>2 = real 2"
     by (metis Ratreal_def of_nat_numeral of_rat_numeral_eq power2_eq_square real_times_code)
   have "\<forall>r. if 0 \<le> r then sqrt (r\<^sup>2) = r else r + sqrt (r\<^sup>2) = 0"
     by simp
   hence f2: "Ratreal p + sqrt ((Ratreal p)\<^sup>2) = 0"
     using f1 by (metis Ratreal_def Rats_def \<open>sqrt (real 2) \<notin> \<rat>\<close> range_eqI)
   have f3: "sqrt (real 2) + - 1 * sqrt ((Ratreal p)\<^sup>2) \<le> 0"
     using f1 by fastforce
   have f4: "0 \<le> sqrt (real 2) + - 1 * sqrt ((Ratreal p)\<^sup>2)"
     using f1 by force
   have f5: "(- 1 * sqrt (real 2) = real_of_rat p) = (sqrt (real 2) + real_of_rat p = 0)"
     by linarith
   have "\<forall>x0. - (x0::real) = - 1 * x0"
     by auto
   hence "sqrt (real 2) + real_of_rat p \<noteq> 0"
     using f5 by (metis (no_types) Rats_def Rats_minus_iff \<open>sqrt (real 2) \<notin> \<rat>\<close> range_eqI)
   thus False
     using f4 f3 f2 by simp
 qed
 
 (* Ensure that complex numbers with zero-imaginary part are rendered as reals *)
 lemma complex_number_code_post[code_post]: 
   shows "Complex a 0 = complex_of_real a"
     and "complex_of_real 0 = 0"
     and "complex_of_real 1 = 1"
     and "complex_of_real (a/b) = complex_of_real a / complex_of_real b"
     and "complex_of_real (numeral n) = numeral n"
     and "complex_of_real (-r) = - complex_of_real r"
   using complex_eq_cancel_iff2 by auto
 
 (* Make real number implementation more readable *)
 lemma real_number_code_post[code_post]:
   shows "real_of (Abs_mini_alg (p, 0, b)) = real_of_rat p"
     and "real_of (Abs_mini_alg (p, q, 2)) = real_of_rat p + real_of_rat q * sqrt 2"
     and "sqrt 0 = 0"
     and "sqrt (real 0) = 0"
     and "x * (0::real) = 0"
     and "(0::real) * x = 0"
     and "(0::real) + x = x"
     and "x + (0::real) = x"
     and "(1::real) * x = x"
     and "x * (1::real) = x"
   by (auto simp add: eq_onp_same_args real_of.abs_eq)
 
 (* Hide IArray in output *)
 translations "x" \<leftharpoondown> "CONST IArray x"
 
 
 end