src/HOL/BCV/Listn.ML
changeset 11360 45f837f8889d
parent 11359 29f8b00d7e1f
child 11361 879e53d92f51
equal deleted inserted replaced
11359:29f8b00d7e1f 11360:45f837f8889d
     1 (*  Title:      HOL/BCV/Listn.ML
       
     2     ID:         $Id$
       
     3     Author:     Tobias Nipkow
       
     4     Copyright   2000 TUM
       
     5 *)
       
     6 
       
     7 Addsimps [set_update_subsetI];
       
     8 
       
     9 Goalw [lesub_def] "xs <=[r] ys == Listn.le r xs ys";
       
    10 by (Simp_tac 1);
       
    11 qed "unfold_lesub_list";
       
    12 
       
    13 Goalw [lesub_def,Listn.le_def] "([] <=[r] ys) = (ys = [])";
       
    14 by (Simp_tac 1);
       
    15 qed "Nil_le_conv";
       
    16 
       
    17 Goalw [lesub_def,Listn.le_def] "~ x#xs <=[r] []";
       
    18 by (Simp_tac 1);
       
    19 qed "Cons_notle_Nil";
       
    20 
       
    21 AddIffs [Nil_le_conv,Cons_notle_Nil];
       
    22 
       
    23 Goalw [lesub_def,Listn.le_def] "x#xs <=[r] y#ys = (x <=_r y & xs <=[r] ys)";
       
    24 by (Simp_tac 1);
       
    25 qed "Cons_le_Cons";
       
    26 AddIffs [Cons_le_Cons];
       
    27 
       
    28 Goalw [lesssub_def] "order r ==> \
       
    29 \ x#xs <_(Listn.le r) y#ys = \
       
    30 \ (x <_r y & xs <=[r] ys  |  x = y & xs <_(Listn.le r) ys)";
       
    31 by (Blast_tac 1);
       
    32 qed "Cons_less_Cons";
       
    33 Addsimps [Cons_less_Cons];
       
    34 
       
    35 Goalw [unfold_lesub_list]
       
    36  "[| i<size xs; xs <=[r] ys; x <=_r y |] ==> xs[i:=x] <=[r] ys[i:=y]";
       
    37 by (rewtac Listn.le_def);
       
    38 by (asm_full_simp_tac (simpset() addsimps [list_all2_conv_all_nth,nth_list_update]) 1);
       
    39 qed "list_update_le_cong";
       
    40 
       
    41 
       
    42 Goalw [Listn.le_def,lesub_def]
       
    43  "[| xs <=[r] ys; p < size xs |] ==> xs!p <=_r ys!p";
       
    44 by (asm_full_simp_tac (simpset() addsimps [list_all2_conv_all_nth]) 1);
       
    45 qed "le_listD";
       
    46 
       
    47 Goalw [unfold_lesub_list] "!x. x <=_r x ==> xs <=[r] xs";
       
    48 by (asm_simp_tac (simpset() addsimps [Listn.le_def,list_all2_conv_all_nth]) 1);
       
    49 qed "le_list_refl";
       
    50 
       
    51 Goalw [unfold_lesub_list]
       
    52  "[| order r; xs <=[r] ys; ys <=[r] zs |] ==> xs <=[r] zs";
       
    53 by (asm_full_simp_tac(simpset()addsimps[Listn.le_def,list_all2_conv_all_nth])1);
       
    54 by (Clarify_tac 1);
       
    55 by (Asm_full_simp_tac 1);
       
    56 by (blast_tac (claset() addIs [order_trans]) 1);
       
    57 qed "le_list_trans";
       
    58 
       
    59 Goalw [unfold_lesub_list]
       
    60  "[| order r; xs <=[r] ys; ys <=[r] xs |] ==> xs = ys";
       
    61 by (asm_full_simp_tac(simpset()addsimps[Listn.le_def,list_all2_conv_all_nth])1);
       
    62 by (rtac nth_equalityI 1);
       
    63  by (Blast_tac 1);
       
    64 by (Clarify_tac 1);
       
    65 by (Asm_full_simp_tac 1);
       
    66 by (blast_tac (claset() addIs [order_antisym]) 1);
       
    67 qed "le_list_antisym";
       
    68 
       
    69 Goal "order r ==> order(Listn.le r)";
       
    70 by (stac order_def 1);
       
    71 by (blast_tac (claset() addIs [le_list_refl,le_list_trans,le_list_antisym]
       
    72                        addDs [order_refl]) 1);
       
    73 qed "order_listI";
       
    74 Addsimps [order_listI];
       
    75 AddSIs [order_listI];
       
    76 
       
    77 
       
    78 Goalw [Listn.le_def,lesub_def] "xs <=[r] ys ==> size ys = size xs";
       
    79 by (asm_full_simp_tac(simpset()addsimps[list_all2_conv_all_nth])1);
       
    80 qed "lesub_list_impl_same_size";
       
    81 Addsimps [lesub_list_impl_same_size];
       
    82 
       
    83 Goalw [lesssub_def] "xs <_(Listn.le r) ys ==> size ys = size xs";
       
    84 by (Auto_tac);
       
    85 qed "lesssub_list_impl_same_size";
       
    86 
       
    87 Goalw [list_def] "[| length xs = n; set xs <= A |] ==> xs : list n A";
       
    88 by (Blast_tac 1);
       
    89 qed "listI";
       
    90 
       
    91 Goalw [list_def] "xs : list n A ==> length xs = n";
       
    92 by (Blast_tac 1);
       
    93 qed "listE_length";
       
    94 Addsimps [listE_length];
       
    95 
       
    96 Goal "[| xs : list n A; p < n |] ==> p < length xs";
       
    97 by (Asm_simp_tac 1);
       
    98 qed "less_lengthI";
       
    99 
       
   100 Goalw [list_def] "xs : list n A ==> set xs <= A";
       
   101 by (Blast_tac 1);
       
   102 qed "listE_set";
       
   103 Addsimps [listE_set];
       
   104 
       
   105 Goalw [list_def] "list 0 A = {[]}";
       
   106 by (Auto_tac); 
       
   107 qed "list_0";
       
   108 Addsimps [list_0];
       
   109 
       
   110 Goalw [list_def]
       
   111  "(xs : list (Suc n) A) = (? y:A. ? ys:list n A. xs = y#ys)";
       
   112 by (case_tac "xs" 1);
       
   113 by (Auto_tac);
       
   114 qed "in_list_Suc_iff";
       
   115 
       
   116 Goal "(x#xs : list (Suc n) A) = (x:A & xs : list n A)";
       
   117 by (simp_tac (simpset() addsimps [in_list_Suc_iff]) 1);
       
   118 qed "Cons_in_list_Suc";
       
   119 AddIffs [Cons_in_list_Suc];
       
   120 
       
   121 Goal "? a. a:A ==> ? xs. xs : list n A";
       
   122 by (induct_tac "n" 1);
       
   123  by (Simp_tac 1);
       
   124 by (asm_simp_tac (simpset() addsimps [in_list_Suc_iff]) 1);
       
   125 by (Blast_tac 1);
       
   126 qed "list_not_empty";
       
   127 
       
   128 
       
   129 Goal "!i n. length xs = n --> set xs <= A --> i < n --> (xs!i) : A";
       
   130 by (induct_tac "xs" 1);
       
   131  by (Simp_tac 1);
       
   132 by (asm_full_simp_tac (simpset() addsimps [nth_Cons] addsplits [nat.split]) 1);
       
   133 qed_spec_mp "nth_in";
       
   134 Addsimps [nth_in];
       
   135 
       
   136 Goal "[| xs : list n A; i < n |] ==> (xs!i) : A";
       
   137 by (blast_tac (HOL_cs addIs [nth_in,listE_length,listE_set]) 1);
       
   138 qed "listE_nth_in";
       
   139 
       
   140 Goalw [list_def]
       
   141  "[| xs : list n A; x:A |] ==> xs[i := x] : list n A";
       
   142 by (Asm_full_simp_tac 1);
       
   143 qed "list_update_in_list";
       
   144 Addsimps [list_update_in_list];
       
   145 AddSIs [list_update_in_list];
       
   146 
       
   147 Goalw [plussub_def,map2_def] "[] +[f] xs = []";
       
   148 by (Simp_tac 1);
       
   149 qed "plus_list_Nil";
       
   150 Addsimps [plus_list_Nil];
       
   151 
       
   152 Goal
       
   153  "(x#xs) +[f] ys = (case ys of [] => [] | y#ys => (x +_f y)#(xs +[f] ys))";
       
   154 by (simp_tac (simpset() addsimps [plussub_def,map2_def] addsplits [list.split]) 1);
       
   155 qed "plus_list_Cons";
       
   156 Addsimps [plus_list_Cons];
       
   157 
       
   158 Goal "!ys. length(xs +[f] ys) = min(length xs) (length ys)";
       
   159 by (induct_tac "xs" 1);
       
   160  by (Simp_tac 1);
       
   161 by (Clarify_tac 1);
       
   162 by (asm_simp_tac (simpset() addsplits [list.split]) 1);
       
   163 qed_spec_mp "length_plus_list";
       
   164 Addsimps [length_plus_list];
       
   165 
       
   166 Goal
       
   167  "!xs ys i. length xs = n --> length ys = n --> i<n --> \
       
   168 \           (xs +[f] ys)!i = (xs!i) +_f (ys!i)";
       
   169 by (induct_tac "n" 1);
       
   170  by (Simp_tac 1);
       
   171 by (Clarify_tac 1);
       
   172 by (case_tac "xs" 1);
       
   173  by (Asm_full_simp_tac 1);
       
   174 by (force_tac (claset(),simpset() addsimps [nth_Cons]
       
   175        addsplits [list.split,nat.split]) 1);
       
   176 qed_spec_mp "nth_plus_list";
       
   177 Addsimps [nth_plus_list];
       
   178 
       
   179 Goalw [unfold_lesub_list]
       
   180  "[| semilat(A,r,f); set xs <= A; set ys <= A; size xs = size ys |] \
       
   181 \ ==> xs <=[r] xs +[f] ys";
       
   182 by (asm_full_simp_tac(simpset()addsimps[Listn.le_def,list_all2_conv_all_nth])1);
       
   183 qed_spec_mp "plus_list_ub1";
       
   184 
       
   185 Goalw [unfold_lesub_list]
       
   186  "[| semilat(A,r,f); set xs <= A; set ys <= A; size xs = size ys |] \
       
   187 \ ==> ys <=[r] xs +[f] ys";
       
   188 by (asm_full_simp_tac(simpset()addsimps[Listn.le_def,list_all2_conv_all_nth])1);
       
   189 qed_spec_mp "plus_list_ub2";
       
   190 
       
   191 Goalw [unfold_lesub_list]
       
   192  "semilat(A,r,f) ==> !xs ys zs. set xs <= A --> set ys <= A --> set zs <= A \
       
   193 \ --> size xs = n & size ys = n --> \
       
   194 \              xs <=[r] zs & ys <=[r] zs --> xs +[f] ys <=[r] zs";
       
   195 by (asm_full_simp_tac(simpset()addsimps[Listn.le_def,list_all2_conv_all_nth])1);
       
   196 qed_spec_mp "plus_list_lub";
       
   197 
       
   198 Goalw [unfold_lesub_list]
       
   199  "[| semilat(A,r,f); x:A |] ==> set xs <= A --> \
       
   200 \ (!i. i<size xs --> xs <=[r] xs[i := x +_f xs!i])";
       
   201 by (simp_tac(simpset()addsimps[Listn.le_def,list_all2_conv_all_nth])1);
       
   202 by (induct_tac "xs" 1);
       
   203  by (Simp_tac 1);
       
   204 by (asm_simp_tac (simpset() addsimps [in_list_Suc_iff]) 1);
       
   205 by (Clarify_tac 1);
       
   206 by (asm_simp_tac (simpset() addsimps [nth_Cons] addsplits [nat.split]) 1);
       
   207 qed_spec_mp "list_update_incr";
       
   208 
       
   209 Goalw [acc_def] "[| order r; acc r |] ==> acc(Listn.le r)";
       
   210 by (subgoal_tac
       
   211  "wf(UN n. {(ys,xs). size xs = n & size ys = n & xs <_(Listn.le r) ys})" 1);
       
   212  by (etac wf_subset 1);
       
   213  by (blast_tac (claset() addIs [lesssub_list_impl_same_size]) 1);
       
   214 by (rtac wf_UN 1);
       
   215  by (Clarify_tac 2);
       
   216  by (rename_tac "m n" 2);
       
   217  by (case_tac "m=n" 2);
       
   218   by (Asm_full_simp_tac 2);
       
   219  by (rtac conjI 2);
       
   220   by (fast_tac (claset() addSIs [equals0I] addDs [not_sym]) 2);
       
   221  by (fast_tac (claset() addSIs [equals0I] addDs [not_sym]) 2);
       
   222 by (Clarify_tac 1);
       
   223 by (rename_tac "n" 1);
       
   224 by (induct_tac "n" 1);
       
   225  by (simp_tac (simpset() addsimps [lesssub_def] addcongs [conj_cong]) 1);
       
   226 by (rename_tac "k" 1);
       
   227 by (asm_full_simp_tac (simpset() addsimps [wf_eq_minimal]) 1);
       
   228 by (simp_tac (simpset() addsimps [length_Suc_conv] addcongs [conj_cong]) 1);
       
   229 by (Clarify_tac 1);
       
   230 by (rename_tac "M m" 1);
       
   231 by (case_tac "? x xs. size xs = k & x#xs : M" 1);
       
   232  by (etac thin_rl 2);
       
   233  by (etac thin_rl 2);
       
   234  by (Blast_tac 2);
       
   235 by (eres_inst_tac [("x","{a. ? xs. size xs = k & a#xs:M}")] allE 1);
       
   236 by (etac impE 1);
       
   237  by (Blast_tac 1);
       
   238 by (thin_tac "? x xs. ?P x xs" 1);
       
   239 by (Clarify_tac 1);
       
   240 by (rename_tac "maxA xs" 1);
       
   241 by (eres_inst_tac [("x","{ys. size ys = size xs & maxA#ys : M}")] allE 1);
       
   242 by (etac impE 1);
       
   243  by (Blast_tac 1);
       
   244 by (Clarify_tac 1);
       
   245 by (thin_tac "m : M" 1);
       
   246 by (thin_tac "maxA#xs : M" 1);
       
   247 by (rtac bexI 1);
       
   248  by (assume_tac 2);
       
   249 by (Clarify_tac 1);
       
   250 by (Asm_full_simp_tac 1);
       
   251 by (Blast_tac 1);
       
   252 qed "acc_le_listI";
       
   253 AddSIs [acc_le_listI];
       
   254 
       
   255 
       
   256 Goalw [closed_def]
       
   257  "closed S f ==> closed (list n S) (map2 f)";
       
   258 by (induct_tac "n" 1);
       
   259  by (Simp_tac 1);
       
   260 by (Clarify_tac 1);
       
   261 by (asm_full_simp_tac (simpset() addsimps [in_list_Suc_iff]) 1);
       
   262 by (Clarify_tac 1);
       
   263 by (Simp_tac 1);
       
   264 by (Blast_tac 1);
       
   265 qed "closed_listI";
       
   266 
       
   267 
       
   268 Goalw [Listn.sl_def]
       
   269  "!!L. semilat L ==> semilat (Listn.sl n L)";
       
   270 by (split_all_tac 1);
       
   271 by (simp_tac (HOL_basic_ss addsimps [semilat_Def, split_conv]) 1);
       
   272 by (rtac conjI 1);
       
   273  by (Asm_simp_tac 1);
       
   274 by (rtac conjI 1);
       
   275  by (asm_simp_tac(HOL_basic_ss addsimps [semilatDclosedI,closed_listI]) 1);
       
   276 by (simp_tac (HOL_basic_ss addsimps [list_def]) 1);
       
   277 by (asm_simp_tac (simpset() addsimps [plus_list_ub1,plus_list_ub2,plus_list_lub]) 1);
       
   278 qed "semilat_Listn_sl";
       
   279 
       
   280 
       
   281 Goal "!xes. xes : list n (err A) --> coalesce xes : err(list n A)";
       
   282 by (induct_tac "n" 1);
       
   283  by (Simp_tac 1);
       
   284 by (Clarify_tac 1);
       
   285 by (asm_full_simp_tac (simpset() addsimps [in_list_Suc_iff]) 1);
       
   286 by (Clarify_tac 1);
       
   287 by (simp_tac (simpset() addsimps [plussub_def,Err.sup_def,lift2_def] addsplits [err.split]) 1);
       
   288 by (Force_tac 1);
       
   289 qed_spec_mp "coalesce_in_err_list";
       
   290 
       
   291 
       
   292 Goal "x +_(op #) xs = x#xs";
       
   293 by (simp_tac (simpset() addsimps [plussub_def]) 1);
       
   294 val lemma = result();
       
   295 
       
   296 Goal
       
   297  "semilat(err A, Err.le r, lift2 f) ==> \
       
   298 \ !xs. xs : list n A --> (!ys. ys : list n A --> \
       
   299 \      (!zs. coalesce (xs +[f] ys) = OK zs --> xs <=[r] zs))";
       
   300 by (induct_tac "n" 1);
       
   301  by (Simp_tac 1);
       
   302 by (Clarify_tac 1);
       
   303 by (asm_full_simp_tac (simpset() addsimps [in_list_Suc_iff]) 1);
       
   304 by (Clarify_tac 1);
       
   305 by (full_simp_tac (simpset() addsplits [err.split_asm] addsimps [lemma,Err.sup_def,lift2_def]) 1);
       
   306 by (force_tac (claset(), simpset() addsimps [semilat_le_err_OK1]) 1);
       
   307 qed_spec_mp "coalesce_eq_OK1_D";
       
   308 
       
   309 Goal
       
   310  "semilat(err A, Err.le r, lift2 f) ==> \
       
   311 \ !xs. xs : list n A --> (!ys. ys : list n A --> \
       
   312 \      (!zs. coalesce (xs +[f] ys) = OK zs --> ys <=[r] zs))";
       
   313 by (induct_tac "n" 1);
       
   314  by (Simp_tac 1);
       
   315 by (Clarify_tac 1);
       
   316 by (asm_full_simp_tac (simpset() addsimps [in_list_Suc_iff]) 1);
       
   317 by (Clarify_tac 1);
       
   318 by (full_simp_tac (simpset() addsplits [err.split_asm] addsimps [lemma,Err.sup_def,lift2_def]) 1);
       
   319 by (force_tac (claset(), simpset() addsimps [semilat_le_err_OK2]) 1);
       
   320 qed_spec_mp "coalesce_eq_OK2_D";
       
   321 
       
   322 Goalw [semilat_Def,plussub_def,err_def]
       
   323  "[| semilat(err A, Err.le r, lift2 f); x:A; y:A; x +_f y = OK z; \
       
   324 \    u:A; x <=_r u; y <=_r u |] ==> z <=_r u";
       
   325 by (asm_full_simp_tac (simpset() addsimps [lift2_def]) 1);
       
   326 by (Clarify_tac 1);
       
   327 by (rotate_tac ~3 1);
       
   328 by (etac thin_rl 1);
       
   329 by (etac thin_rl 1);
       
   330 by (Force_tac 1);
       
   331 qed "lift2_le_ub";
       
   332 
       
   333 Goal
       
   334  "semilat(err A, Err.le r, lift2 f) ==> \
       
   335 \ !xs. xs : list n A --> (!ys. ys : list n A --> \
       
   336 \      (!zs us. coalesce (xs +[f] ys) = OK zs & xs <=[r] us & ys <=[r] us \
       
   337 \               & us : list n A --> zs <=[r] us))";
       
   338 by (induct_tac "n" 1);
       
   339  by (Simp_tac 1);
       
   340 by (Clarify_tac 1);
       
   341 by (asm_full_simp_tac (simpset() addsimps [in_list_Suc_iff]) 1);
       
   342 by (Clarify_tac 1);
       
   343 by (full_simp_tac (simpset() addsplits [err.split_asm] addsimps [lemma,Err.sup_def,lift2_def]) 1);
       
   344 by (Clarify_tac 1);
       
   345 by (rtac conjI 1);
       
   346  by (Blast_tac 2);
       
   347 by (blast_tac (claset() addIs [lift2_le_ub]) 1);
       
   348 qed_spec_mp "coalesce_eq_OK_ub_D";
       
   349 
       
   350 Goal
       
   351  "[| x +_f y = Err; semilat(err A, Err.le r, lift2 f); x:A; y:A |] \
       
   352 \ ==> ~(? u:A. x <=_r u & y <=_r u)";
       
   353 by (asm_simp_tac (simpset() addsimps [OK_plus_OK_eq_Err_conv RS iffD1]) 1);
       
   354 qed "lift2_eq_ErrD";
       
   355 
       
   356 Goal
       
   357  "[| semilat(err A, Err.le r, lift2 f)  \
       
   358 \ |] ==> !xs. xs:list n A --> (!ys. ys:list n A --> \
       
   359 \  coalesce (xs +[f] ys) = Err --> \
       
   360 \ ~(? zs:list n A. xs <=[r] zs & ys <=[r] zs))";
       
   361 by (induct_tac "n" 1);
       
   362  by (Simp_tac 1);
       
   363 by (Clarify_tac 1);
       
   364 by (asm_full_simp_tac (simpset() addsimps [in_list_Suc_iff]) 1);
       
   365 by (Clarify_tac 1);
       
   366 by (full_simp_tac (simpset() addsplits [err.split_asm] addsimps [lemma,Err.sup_def,lift2_def]) 1);
       
   367  by (blast_tac (claset() addDs [lift2_eq_ErrD]) 1);
       
   368 by (Blast_tac 1);
       
   369 qed_spec_mp "coalesce_eq_Err_D";
       
   370 
       
   371 
       
   372 Goalw [closed_def]
       
   373  "closed (err A) (lift2 f) = (!x:A. !y:A. x +_f y : err A)";
       
   374 by (simp_tac (simpset() addsimps [err_def]) 1);
       
   375 qed "closed_err_lift2_conv";
       
   376 
       
   377 Goalw [map2_def]
       
   378  "closed (err A) (lift2 f) ==> \
       
   379 \ !xs. xs : list n A --> (!ys. ys : list n A --> \
       
   380 \     map2 f xs ys : list n (err A))";
       
   381 by (induct_tac "n" 1);
       
   382  by (Simp_tac 1);
       
   383 by (Clarify_tac 1);
       
   384 by (asm_full_simp_tac (simpset() addsimps [in_list_Suc_iff]) 1);
       
   385 by (Clarify_tac 1);
       
   386 by (full_simp_tac (simpset() addsimps [plussub_def,closed_err_lift2_conv]) 1);
       
   387 by (Blast_tac 1);
       
   388 qed_spec_mp "closed_map2_list";
       
   389 
       
   390 Goal
       
   391  "closed (err A) (lift2 f) ==> \
       
   392 \ closed (err (list n A)) (lift2 (sup f))";
       
   393 by (fast_tac (claset() addss (simpset() addsimps
       
   394  [closed_def,plussub_def,sup_def,lift2_def,
       
   395   coalesce_in_err_list,closed_map2_list]
       
   396  addsplits [err.split])) 1);
       
   397 qed "closed_lift2_sup";
       
   398 
       
   399 Goalw [Err.sl_def]
       
   400  "err_semilat (A,r,f) ==> \
       
   401 \ err_semilat (list n A, Listn.le r, sup f)";
       
   402 by (asm_full_simp_tac (HOL_basic_ss addsimps [split_conv]) 1);
       
   403 by (simp_tac (HOL_basic_ss addsimps [semilat_Def,plussub_def]) 1);
       
   404 by (asm_simp_tac(HOL_basic_ss addsimps [semilatDclosedI,closed_lift2_sup]) 1);
       
   405 by (rtac conjI 1);
       
   406  by (dtac semilatDorderI 1);
       
   407  by (Asm_full_simp_tac 1);
       
   408 by (simp_tac (HOL_basic_ss addsimps
       
   409      [unfold_lesub_err,Err.le_def,err_def,sup_def,lift2_def]) 1);
       
   410 by (asm_simp_tac (simpset() addsimps
       
   411      [coalesce_eq_OK1_D,coalesce_eq_OK2_D] addsplits [err.split]) 1);
       
   412 by (blast_tac (claset()addIs[coalesce_eq_OK_ub_D] addDs [coalesce_eq_Err_D]) 1);
       
   413 qed "err_semilat_sup";
       
   414 
       
   415 Goalw [Listn.upto_esl_def]
       
   416  "!!L. err_semilat L ==> err_semilat(upto_esl m L)";
       
   417 by (split_all_tac 1);
       
   418 by (Asm_full_simp_tac 1);
       
   419 by (fast_tac (claset()
       
   420   addSIs [err_semilat_UnionI,err_semilat_sup]
       
   421   addDs [lesub_list_impl_same_size] addss (simpset()
       
   422   addsimps [plussub_def,Listn.sup_def])) 1);
       
   423 qed "err_semilat_upto_esl";