src/HOL/Tools/inductive_realizer.ML
author wenzelm
Thu Mar 20 00:20:44 2008 +0100 (2008-03-20)
changeset 26343 0dd2eab7b296
parent 26336 a0e2b706ce73
child 26477 ecf06644f6cb
permissions -rw-r--r--
simplified get_thm(s): back to plain name argument;
     1 (*  Title:      HOL/Tools/inductive_realizer.ML
     2     ID:         $Id$
     3     Author:     Stefan Berghofer, TU Muenchen
     4 
     5 Porgram extraction from proofs involving inductive predicates:
     6 Realizers for induction and elimination rules
     7 *)
     8 
     9 signature INDUCTIVE_REALIZER =
    10 sig
    11   val add_ind_realizers: string -> string list -> theory -> theory
    12   val setup: theory -> theory
    13 end;
    14 
    15 structure InductiveRealizer : INDUCTIVE_REALIZER =
    16 struct
    17 
    18 (* FIXME: LocalTheory.note should return theorems with proper names! *)
    19 fun name_of_thm thm =
    20   (case Symtab.dest (Proofterm.thms_of_proof' (proof_of thm) Symtab.empty) of
    21      [(name, _)] => name
    22    | _ => error ("name_of_thm: bad proof of theorem\n" ^ string_of_thm thm));
    23 
    24 val all_simps = map (symmetric o mk_meta_eq) (thms "HOL.all_simps");
    25 
    26 fun prf_of thm =
    27   let val {thy, prop, der = (_, prf), ...} = rep_thm thm
    28   in Reconstruct.expand_proof thy [("", NONE)] (Reconstruct.reconstruct_proof thy prop prf) end; (* FIXME *)
    29 
    30 fun forall_intr_prf (t, prf) =
    31   let val (a, T) = (case t of Var ((a, _), T) => (a, T) | Free p => p)
    32   in Abst (a, SOME T, Proofterm.prf_abstract_over t prf) end;
    33 
    34 fun forall_intr_term (t, u) =
    35   let val (a, T) = (case t of Var ((a, _), T) => (a, T) | Free p => p)
    36   in all T $ Abs (a, T, abstract_over (t, u)) end;
    37 
    38 fun subsets [] = [[]]
    39   | subsets (x::xs) =
    40       let val ys = subsets xs
    41       in ys @ map (cons x) ys end;
    42 
    43 val pred_of = fst o dest_Const o head_of;
    44 
    45 fun strip_all' used names (Const ("all", _) $ Abs (s, T, t)) =
    46       let val (s', names') = (case names of
    47           [] => (Name.variant used s, [])
    48         | name :: names' => (name, names'))
    49       in strip_all' (s'::used) names' (subst_bound (Free (s', T), t)) end
    50   | strip_all' used names ((t as Const ("==>", _) $ P) $ Q) =
    51       t $ strip_all' used names Q
    52   | strip_all' _ _ t = t;
    53 
    54 fun strip_all t = strip_all' (add_term_free_names (t, [])) [] t;
    55 
    56 fun strip_one name (Const ("all", _) $ Abs (s, T, Const ("==>", _) $ P $ Q)) =
    57       (subst_bound (Free (name, T), P), subst_bound (Free (name, T), Q))
    58   | strip_one _ (Const ("==>", _) $ P $ Q) = (P, Q);
    59 
    60 fun relevant_vars prop = foldr (fn
    61       (Var ((a, i), T), vs) => (case strip_type T of
    62         (_, Type (s, _)) => if s mem ["bool"] then (a, T) :: vs else vs
    63       | _ => vs)
    64     | (_, vs) => vs) [] (term_vars prop);
    65 
    66 fun dt_of_intrs thy vs nparms intrs =
    67   let
    68     val iTs = term_tvars (prop_of (hd intrs));
    69     val Tvs = map TVar iTs;
    70     val (Const (s, _), ts) = strip_comb (HOLogic.dest_Trueprop
    71       (Logic.strip_imp_concl (prop_of (hd intrs))));
    72     val params = map dest_Var (Library.take (nparms, ts));
    73     val tname = space_implode "_" (Sign.base_name s ^ "T" :: vs);
    74     fun constr_of_intr intr = (Sign.base_name (name_of_thm intr),
    75       map (Logic.unvarifyT o snd) (rev (Term.add_vars (prop_of intr) []) \\ params) @
    76         filter_out (equal Extraction.nullT) (map
    77           (Logic.unvarifyT o Extraction.etype_of thy vs []) (prems_of intr)),
    78             NoSyn);
    79   in (map (fn a => "'" ^ a) vs @ map (fst o fst) iTs, tname, NoSyn,
    80     map constr_of_intr intrs)
    81   end;
    82 
    83 fun mk_rlz T = Const ("realizes", [T, HOLogic.boolT] ---> HOLogic.boolT);
    84 
    85 (** turn "P" into "%r x. realizes r (P x)" **)
    86 
    87 fun gen_rvar vs (t as Var ((a, 0), T)) =
    88       if body_type T <> HOLogic.boolT then t else
    89         let
    90           val U = TVar (("'" ^ a, 0), HOLogic.typeS)
    91           val Ts = binder_types T;
    92           val i = length Ts;
    93           val xs = map (pair "x") Ts;
    94           val u = list_comb (t, map Bound (i - 1 downto 0))
    95         in 
    96           if a mem vs then
    97             list_abs (("r", U) :: xs, mk_rlz U $ Bound i $ u)
    98           else list_abs (xs, mk_rlz Extraction.nullT $ Extraction.nullt $ u)
    99         end
   100   | gen_rvar _ t = t;
   101 
   102 fun mk_realizes_eqn n vs nparms intrs =
   103   let
   104     val concl = HOLogic.dest_Trueprop (concl_of (hd intrs));
   105     val iTs = term_tvars concl;
   106     val Tvs = map TVar iTs;
   107     val (h as Const (s, T), us) = strip_comb concl;
   108     val params = List.take (us, nparms);
   109     val elTs = List.drop (binder_types T, nparms);
   110     val predT = elTs ---> HOLogic.boolT;
   111     val used = map (fst o fst o dest_Var) params;
   112     val xs = map (Var o apfst (rpair 0))
   113       (Name.variant_list used (replicate (length elTs) "x") ~~ elTs);
   114     val rT = if n then Extraction.nullT
   115       else Type (space_implode "_" (s ^ "T" :: vs),
   116         map (fn a => TVar (("'" ^ a, 0), HOLogic.typeS)) vs @ Tvs);
   117     val r = if n then Extraction.nullt else Var ((Sign.base_name s, 0), rT);
   118     val S = list_comb (h, params @ xs);
   119     val rvs = relevant_vars S;
   120     val vs' = map fst rvs \\ vs;
   121     val rname = space_implode "_" (s ^ "R" :: vs);
   122 
   123     fun mk_Tprem n v =
   124       let val T = (the o AList.lookup (op =) rvs) v
   125       in (Const ("typeof", T --> Type ("Type", [])) $ Var ((v, 0), T),
   126         Extraction.mk_typ (if n then Extraction.nullT
   127           else TVar (("'" ^ v, 0), HOLogic.typeS)))
   128       end;
   129 
   130     val prems = map (mk_Tprem true) vs' @ map (mk_Tprem false) vs;
   131     val ts = map (gen_rvar vs) params;
   132     val argTs = map fastype_of ts;
   133 
   134   in ((prems, (Const ("typeof", HOLogic.boolT --> Type ("Type", [])) $ S,
   135        Extraction.mk_typ rT)),
   136     (prems, (mk_rlz rT $ r $ S,
   137        if n then list_comb (Const (rname, argTs ---> predT), ts @ xs)
   138        else list_comb (Const (rname, argTs @ [rT] ---> predT), ts @ [r] @ xs))))
   139   end;
   140 
   141 fun fun_of_prem thy rsets vs params rule ivs intr =
   142   let
   143     val ctxt = ProofContext.init thy
   144     val args = map (Free o apfst fst o dest_Var) ivs;
   145     val args' = map (Free o apfst fst)
   146       (Term.add_vars (prop_of intr) [] \\ params);
   147     val rule' = strip_all rule;
   148     val conclT = Extraction.etype_of thy vs [] (Logic.strip_imp_concl rule');
   149     val used = map (fst o dest_Free) args;
   150 
   151     fun is_rec t = not (null (term_consts t inter rsets));
   152 
   153     fun is_meta (Const ("all", _) $ Abs (s, _, P)) = is_meta P
   154       | is_meta (Const ("==>", _) $ _ $ Q) = is_meta Q
   155       | is_meta (Const ("Trueprop", _) $ t) = (case head_of t of
   156           Const (s, _) => can (InductivePackage.the_inductive ctxt) s
   157         | _ => true)
   158       | is_meta _ = false;
   159 
   160     fun fun_of ts rts args used (prem :: prems) =
   161           let
   162             val T = Extraction.etype_of thy vs [] prem;
   163             val [x, r] = Name.variant_list used ["x", "r"]
   164           in if T = Extraction.nullT
   165             then fun_of ts rts args used prems
   166             else if is_rec prem then
   167               if is_meta prem then
   168                 let
   169                   val prem' :: prems' = prems;
   170                   val U = Extraction.etype_of thy vs [] prem';
   171                 in if U = Extraction.nullT
   172                   then fun_of (Free (x, T) :: ts)
   173                     (Free (r, binder_types T ---> HOLogic.unitT) :: rts)
   174                     (Free (x, T) :: args) (x :: r :: used) prems'
   175                   else fun_of (Free (x, T) :: ts) (Free (r, U) :: rts)
   176                     (Free (r, U) :: Free (x, T) :: args) (x :: r :: used) prems'
   177                 end
   178               else (case strip_type T of
   179                   (Ts, Type ("*", [T1, T2])) =>
   180                     let
   181                       val fx = Free (x, Ts ---> T1);
   182                       val fr = Free (r, Ts ---> T2);
   183                       val bs = map Bound (length Ts - 1 downto 0);
   184                       val t = list_abs (map (pair "z") Ts,
   185                         HOLogic.mk_prod (list_comb (fx, bs), list_comb (fr, bs)))
   186                     in fun_of (fx :: ts) (fr :: rts) (t::args)
   187                       (x :: r :: used) prems
   188                     end
   189                 | (Ts, U) => fun_of (Free (x, T) :: ts)
   190                     (Free (r, binder_types T ---> HOLogic.unitT) :: rts)
   191                     (Free (x, T) :: args) (x :: r :: used) prems)
   192             else fun_of (Free (x, T) :: ts) rts (Free (x, T) :: args)
   193               (x :: used) prems
   194           end
   195       | fun_of ts rts args used [] =
   196           let val xs = rev (rts @ ts)
   197           in if conclT = Extraction.nullT
   198             then list_abs_free (map dest_Free xs, HOLogic.unit)
   199             else list_abs_free (map dest_Free xs, list_comb
   200               (Free ("r" ^ Sign.base_name (name_of_thm intr),
   201                 map fastype_of (rev args) ---> conclT), rev args))
   202           end
   203 
   204   in fun_of args' [] (rev args) used (Logic.strip_imp_prems rule') end;
   205 
   206 fun indrule_realizer thy induct raw_induct rsets params vs rec_names rss intrs dummies =
   207   let
   208     val concls = HOLogic.dest_conj (HOLogic.dest_Trueprop (concl_of raw_induct));
   209     val premss = List.mapPartial (fn (s, rs) => if s mem rsets then
   210       SOME (rs, map (fn (_, r) => List.nth (prems_of raw_induct,
   211         find_index_eq (prop_of r) (map prop_of intrs))) rs) else NONE) rss;
   212     val fs = maps (fn ((intrs, prems), dummy) =>
   213       let
   214         val fs = map (fn (rule, (ivs, intr)) =>
   215           fun_of_prem thy rsets vs params rule ivs intr) (prems ~~ intrs)
   216       in if dummy then Const ("arbitrary",
   217           HOLogic.unitT --> body_type (fastype_of (hd fs))) :: fs
   218         else fs
   219       end) (premss ~~ dummies);
   220     val frees = fold Term.add_frees fs [];
   221     val Ts = map fastype_of fs;
   222     fun name_of_fn intr = "r" ^ Sign.base_name (name_of_thm intr)
   223   in
   224     fst (fold_map (fn concl => fn names =>
   225       let val T = Extraction.etype_of thy vs [] concl
   226       in if T = Extraction.nullT then (Extraction.nullt, names) else
   227         let
   228           val Type ("fun", [U, _]) = T;
   229           val a :: names' = names
   230         in (list_abs_free (("x", U) :: List.mapPartial (fn intr =>
   231           Option.map (pair (name_of_fn intr))
   232             (AList.lookup (op =) frees (name_of_fn intr))) intrs,
   233           list_comb (Const (a, Ts ---> T), fs) $ Free ("x", U)), names')
   234         end
   235       end) concls rec_names)
   236   end;
   237 
   238 fun add_dummy name dname (x as (_, (vs, s, mfx, cs))) =
   239   if (name: string) = s then (true, (vs, s, mfx, (dname, [HOLogic.unitT], NoSyn) :: cs))
   240   else x;
   241 
   242 fun add_dummies f [] _ thy =
   243       (([], NONE), thy)
   244   | add_dummies f dts used thy =
   245       thy
   246       |> f (map snd dts)
   247       |-> (fn dtinfo => pair ((map fst dts), SOME dtinfo))
   248     handle DatatypeAux.Datatype_Empty name' =>
   249       let
   250         val name = Sign.base_name name';
   251         val dname = Name.variant used "Dummy"
   252       in
   253         thy
   254         |> add_dummies f (map (add_dummy name dname) dts) (dname :: used)
   255       end;
   256 
   257 fun mk_realizer thy vs (name, rule, rrule, rlz, rt) =
   258   let
   259     val rvs = map fst (relevant_vars (prop_of rule));
   260     val xs = rev (Term.add_vars (prop_of rule) []);
   261     val vs1 = map Var (filter_out (fn ((a, _), _) => a mem rvs) xs);
   262     val rlzvs = rev (Term.add_vars (prop_of rrule) []);
   263     val vs2 = map (fn (ixn, _) => Var (ixn, (the o AList.lookup (op =) rlzvs) ixn)) xs;
   264     val rs = map Var (subtract (op = o pairself fst) xs rlzvs);
   265     val rlz' = foldr forall_intr_term (prop_of rrule) (vs2 @ rs);
   266     val rlz'' = foldr forall_intr_term rlz vs2
   267   in (name, (vs,
   268     if rt = Extraction.nullt then rt else
   269       foldr (uncurry lambda) rt vs1,
   270     ProofRewriteRules.un_hhf_proof rlz' rlz''
   271       (foldr forall_intr_prf (prf_of rrule) (vs2 @ rs))))
   272   end;
   273 
   274 fun rename tab = map (fn x => the_default x (AList.lookup op = tab x));
   275 
   276 fun add_ind_realizer rsets intrs induct raw_induct elims (thy, vs) =
   277   let
   278     val qualifier = NameSpace.qualifier (name_of_thm induct);
   279     val inducts = PureThy.get_thms thy (NameSpace.qualified qualifier "inducts");
   280     val iTs = term_tvars (prop_of (hd intrs));
   281     val ar = length vs + length iTs;
   282     val params = InductivePackage.params_of raw_induct;
   283     val arities = InductivePackage.arities_of raw_induct;
   284     val nparms = length params;
   285     val params' = map dest_Var params;
   286     val rss = InductivePackage.partition_rules raw_induct intrs;
   287     val rss' = map (fn (((s, rs), (_, arity)), elim) =>
   288       (s, (InductivePackage.infer_intro_vars elim arity rs ~~ rs)))
   289         (rss ~~ arities ~~ elims);
   290     val (prfx, _) = split_last (NameSpace.explode (fst (hd rss)));
   291     val tnames = map (fn s => space_implode "_" (s ^ "T" :: vs)) rsets;
   292 
   293     val thy1 = thy |>
   294       Sign.root_path |>
   295       Sign.add_path (NameSpace.implode prfx);
   296     val (ty_eqs, rlz_eqs) = split_list
   297       (map (fn (s, rs) => mk_realizes_eqn (not (s mem rsets)) vs nparms rs) rss);
   298 
   299     val thy1' = thy1 |>
   300       Theory.copy |>
   301       Sign.add_types (map (fn s => (Sign.base_name s, ar, NoSyn)) tnames) |>
   302       fold (fn s => AxClass.axiomatize_arity
   303         (s, replicate ar HOLogic.typeS, HOLogic.typeS)) tnames |>
   304         Extraction.add_typeof_eqns_i ty_eqs;
   305     val dts = List.mapPartial (fn (s, rs) => if s mem rsets then
   306       SOME (dt_of_intrs thy1' vs nparms rs) else NONE) rss;
   307 
   308     (** datatype representing computational content of inductive set **)
   309 
   310     val ((dummies, dt_info), thy2) =
   311       thy1
   312       |> add_dummies
   313            (DatatypePackage.add_datatype_i false false (map #2 dts))
   314            (map (pair false) dts) []
   315       ||> Extraction.add_typeof_eqns_i ty_eqs
   316       ||> Extraction.add_realizes_eqns_i rlz_eqs;
   317     fun get f = (these oo Option.map) f;
   318     val rec_names = distinct (op =) (map (fst o dest_Const o head_of o fst o
   319       HOLogic.dest_eq o HOLogic.dest_Trueprop o prop_of) (get #rec_thms dt_info));
   320     val (_, constrss) = foldl_map (fn ((recs, dummies), (s, rs)) =>
   321       if s mem rsets then
   322         let
   323           val (d :: dummies') = dummies;
   324           val (recs1, recs2) = chop (length rs) (if d then tl recs else recs)
   325         in ((recs2, dummies'), map (head_of o hd o rev o snd o strip_comb o
   326           fst o HOLogic.dest_eq o HOLogic.dest_Trueprop o prop_of) recs1)
   327         end
   328       else ((recs, dummies), replicate (length rs) Extraction.nullt))
   329         ((get #rec_thms dt_info, dummies), rss);
   330     val rintrs = map (fn (intr, c) => Envir.eta_contract
   331       (Extraction.realizes_of thy2 vs
   332         (if c = Extraction.nullt then c else list_comb (c, map Var (rev
   333           (Term.add_vars (prop_of intr) []) \\ params'))) (prop_of intr)))
   334             (maps snd rss ~~ List.concat constrss);
   335     val (rlzpreds, rlzpreds') = split_list
   336       (distinct (op = o pairself (#1 o #1)) (map (fn rintr =>
   337         let
   338           val Const (s, T) = head_of (HOLogic.dest_Trueprop
   339             (Logic.strip_assums_concl rintr));
   340           val s' = Sign.base_name s;
   341           val T' = Logic.unvarifyT T
   342         in (((s', T'), NoSyn),
   343           (Const (s, T'), Free (s', T')))
   344         end) rintrs));
   345     val rlzparams = map (fn Var ((s, _), T) => (s, Logic.unvarifyT T))
   346       (List.take (snd (strip_comb
   347         (HOLogic.dest_Trueprop (Logic.strip_assums_concl (hd rintrs)))), nparms));
   348 
   349     (** realizability predicate **)
   350 
   351     val (ind_info, thy3') = thy2 |>
   352       InductivePackage.add_inductive_global (serial_string ())
   353         {verbose = false, kind = Thm.theoremK, alt_name = "",
   354           coind = false, no_elim = false, no_ind = false}
   355         rlzpreds rlzparams (map (fn (rintr, intr) =>
   356           ((Sign.base_name (name_of_thm intr), []),
   357            subst_atomic rlzpreds' (Logic.unvarify rintr)))
   358              (rintrs ~~ maps snd rss)) [] ||>
   359       Sign.absolute_path;
   360     val thy3 = PureThy.hide_thms false
   361       (map name_of_thm (#intrs ind_info)) thy3';
   362 
   363     (** realizer for induction rule **)
   364 
   365     val Ps = List.mapPartial (fn _ $ M $ P => if pred_of M mem rsets then
   366       SOME (fst (fst (dest_Var (head_of P)))) else NONE)
   367         (HOLogic.dest_conj (HOLogic.dest_Trueprop (concl_of raw_induct)));
   368 
   369     fun add_ind_realizer (thy, Ps) =
   370       let
   371         val vs' = rename (map (pairself (fst o fst o dest_Var))
   372           (params ~~ List.take (snd (strip_comb (HOLogic.dest_Trueprop
   373             (hd (prems_of (hd inducts))))), nparms))) vs;
   374         val rs = indrule_realizer thy induct raw_induct rsets params'
   375           (vs' @ Ps) rec_names rss' intrs dummies;
   376         val rlzs = map (fn (r, ind) => Extraction.realizes_of thy (vs' @ Ps) r
   377           (prop_of ind)) (rs ~~ inducts);
   378         val used = foldr add_term_free_names [] rlzs;
   379         val rnames = Name.variant_list used (replicate (length inducts) "r");
   380         val rnames' = Name.variant_list
   381           (used @ rnames) (replicate (length intrs) "s");
   382         val rlzs' as (prems, _, _) :: _ = map (fn (rlz, name) =>
   383           let
   384             val (P, Q) = strip_one name (Logic.unvarify rlz);
   385             val Q' = strip_all' [] rnames' Q
   386           in
   387             (Logic.strip_imp_prems Q', P, Logic.strip_imp_concl Q')
   388           end) (rlzs ~~ rnames);
   389         val concl = HOLogic.mk_Trueprop (foldr1 HOLogic.mk_conj (map
   390           (fn (_, _ $ P, _ $ Q) => HOLogic.mk_imp (P, Q)) rlzs'));
   391         val rews = map mk_meta_eq
   392           (fst_conv :: snd_conv :: get #rec_thms dt_info);
   393         val thm = Goal.prove_global thy [] prems concl (fn prems => EVERY
   394           [rtac (#raw_induct ind_info) 1,
   395            rewrite_goals_tac rews,
   396            REPEAT ((resolve_tac prems THEN_ALL_NEW EVERY'
   397              [K (rewrite_goals_tac rews), ObjectLogic.atomize_prems_tac,
   398               DEPTH_SOLVE_1 o FIRST' [atac, etac allE, etac impE]]) 1)]);
   399         val (thm', thy') = PureThy.store_thm ((space_implode "_"
   400           (NameSpace.qualified qualifier "induct" :: vs' @ Ps @
   401              ["correctness"]), thm), []) thy;
   402         val thms = map (fn th => zero_var_indexes (rotate_prems ~1 (th RS mp)))
   403           (DatatypeAux.split_conj_thm thm');
   404         val ([thms'], thy'') = PureThy.add_thmss
   405           [((space_implode "_"
   406              (NameSpace.qualified qualifier "inducts" :: vs' @ Ps @
   407                ["correctness"]), thms), [])] thy';
   408         val realizers = inducts ~~ thms' ~~ rlzs ~~ rs;
   409       in
   410         Extraction.add_realizers_i
   411           (map (fn (((ind, corr), rlz), r) =>
   412               mk_realizer thy' (vs' @ Ps) (Thm.get_name ind, ind, corr, rlz, r))
   413             realizers @ (case realizers of
   414              [(((ind, corr), rlz), r)] =>
   415                [mk_realizer thy' (vs' @ Ps) (NameSpace.qualified qualifier "induct",
   416                   ind, corr, rlz, r)]
   417            | _ => [])) thy''
   418       end;
   419 
   420     (** realizer for elimination rules **)
   421 
   422     val case_names = map (fst o dest_Const o head_of o fst o HOLogic.dest_eq o
   423       HOLogic.dest_Trueprop o prop_of o hd) (get #case_thms dt_info);
   424 
   425     fun add_elim_realizer Ps
   426       (((((elim, elimR), intrs), case_thms), case_name), dummy) thy =
   427       let
   428         val (prem :: prems) = prems_of elim;
   429         fun reorder1 (p, (_, intr)) =
   430           Library.foldl (fn (t, ((s, _), T)) => all T $ lambda (Free (s, T)) t)
   431             (strip_all p, Term.add_vars (prop_of intr) [] \\ params');
   432         fun reorder2 ((ivs, intr), i) =
   433           let val fs = Term.add_vars (prop_of intr) [] \\ params'
   434           in Library.foldl (fn (t, x) => lambda (Var x) t)
   435             (list_comb (Bound (i + length ivs), ivs), fs)
   436           end;
   437         val p = Logic.list_implies
   438           (map reorder1 (prems ~~ intrs) @ [prem], concl_of elim);
   439         val T' = Extraction.etype_of thy (vs @ Ps) [] p;
   440         val T = if dummy then (HOLogic.unitT --> body_type T') --> T' else T';
   441         val Ts = map (Extraction.etype_of thy (vs @ Ps) []) (prems_of elim);
   442         val r = if null Ps then Extraction.nullt
   443           else list_abs (map (pair "x") Ts, list_comb (Const (case_name, T),
   444             (if dummy then
   445                [Abs ("x", HOLogic.unitT, Const ("arbitrary", body_type T))]
   446              else []) @
   447             map reorder2 (intrs ~~ (length prems - 1 downto 0)) @
   448             [Bound (length prems)]));
   449         val rlz = Extraction.realizes_of thy (vs @ Ps) r (prop_of elim);
   450         val rlz' = strip_all (Logic.unvarify rlz);
   451         val rews = map mk_meta_eq case_thms;
   452         val thm = Goal.prove_global thy []
   453           (Logic.strip_imp_prems rlz') (Logic.strip_imp_concl rlz') (fn prems => EVERY
   454           [cut_facts_tac [hd prems] 1,
   455            etac elimR 1,
   456            ALLGOALS (asm_simp_tac HOL_basic_ss),
   457            rewrite_goals_tac rews,
   458            REPEAT ((resolve_tac prems THEN_ALL_NEW (ObjectLogic.atomize_prems_tac THEN'
   459              DEPTH_SOLVE_1 o FIRST' [atac, etac allE, etac impE])) 1)]);
   460         val (thm', thy') = PureThy.store_thm ((space_implode "_"
   461           (name_of_thm elim :: vs @ Ps @ ["correctness"]), thm), []) thy
   462       in
   463         Extraction.add_realizers_i
   464           [mk_realizer thy' (vs @ Ps) (name_of_thm elim, elim, thm', rlz, r)] thy'
   465       end;
   466 
   467     (** add realizers to theory **)
   468 
   469     val thy4 = Library.foldl add_ind_realizer (thy3, subsets Ps);
   470     val thy5 = Extraction.add_realizers_i
   471       (map (mk_realizer thy4 vs) (map (fn (((rule, rrule), rlz), c) =>
   472          (name_of_thm rule, rule, rrule, rlz,
   473             list_comb (c, map Var (rev (Term.add_vars (prop_of rule) []) \\ params'))))
   474               (List.concat (map snd rss) ~~ #intrs ind_info ~~ rintrs ~~
   475                  List.concat constrss))) thy4;
   476     val elimps = List.mapPartial (fn ((s, intrs), p) =>
   477       if s mem rsets then SOME (p, intrs) else NONE)
   478         (rss' ~~ (elims ~~ #elims ind_info));
   479     val thy6 = Library.foldl (fn (thy, p as (((((elim, _), _), _), _), _)) => thy |>
   480       add_elim_realizer [] p |> add_elim_realizer [fst (fst (dest_Var
   481         (HOLogic.dest_Trueprop (concl_of elim))))] p) (thy5,
   482            elimps ~~ get #case_thms dt_info ~~ case_names ~~ dummies)
   483 
   484   in Sign.restore_naming thy thy6 end;
   485 
   486 fun add_ind_realizers name rsets thy =
   487   let
   488     val (_, {intrs, induct, raw_induct, elims, ...}) =
   489       InductivePackage.the_inductive (ProofContext.init thy) name;
   490     val vss = sort (int_ord o pairself length)
   491       (subsets (map fst (relevant_vars (concl_of (hd intrs)))))
   492   in
   493     Library.foldl (add_ind_realizer rsets intrs induct raw_induct elims) (thy, vss)
   494   end
   495 
   496 fun rlz_attrib arg = Thm.declaration_attribute (fn thm => Context.mapping
   497   let
   498     fun err () = error "ind_realizer: bad rule";
   499     val sets =
   500       (case HOLogic.dest_conj (HOLogic.dest_Trueprop (concl_of thm)) of
   501            [_] => [pred_of (HOLogic.dest_Trueprop (hd (prems_of thm)))]
   502          | xs => map (pred_of o fst o HOLogic.dest_imp) xs)
   503          handle TERM _ => err () | Empty => err ();
   504   in 
   505     add_ind_realizers (hd sets)
   506       (case arg of
   507         NONE => sets | SOME NONE => []
   508       | SOME (SOME sets') => sets \\ sets')
   509   end I);
   510 
   511 val ind_realizer = Attrib.syntax
   512  ((Scan.option (Scan.lift (Args.$$$ "irrelevant") |--
   513     Scan.option (Scan.lift (Args.colon) |--
   514       Scan.repeat1 Args.const))) >> rlz_attrib);
   515 
   516 val setup =
   517   Attrib.add_attributes [("ind_realizer", ind_realizer, "add realizers for inductive set")];
   518 
   519 end;
   520