src/HOL/Tools/BNF/bnf_fp_def_sugar.ML

 
 val EqN = "Eq_";
 
 val case_transferN = "case_transfer";
 val ctr_transferN = "ctr_transfer";
+val disc_transferN = "disc_transfer";
 val corec_codeN = "corec_code";
 val map_disc_iffN = "map_disc_iff";
 val map_selN = "map_sel";
 val set_casesN = "set_cases";
 val set_introsN = "set_intros";

             free_constructors tacss ((((discs_sels, no_code), standard_binding), ctr_specs),
               sel_default_eqs) lthy
           end;
 
         fun derive_maps_sets_rels (ctr_sugar as {casex, case_cong, case_thms, discs, selss, ctrs,
-            exhaust, disc_thmss, sel_thmss, injects, distincts, ...} : ctr_sugar, lthy) =
+            exhaust, exhaust_discs, disc_thmss, sel_thmss, injects, distincts, distinct_discsss,
+            ...} : ctr_sugar, lthy) =
           if live = 0 then
             ((([], [], [], []), ctr_sugar), lthy)
           else
             let
               val rel_flip = rel_flip_of_bnf fp_bnf;

                 map (fn th => th RS @{thm eq_False[THEN iffD2]}) rel_distinct_thms @
                 map2 (fn th => fn 0 => th RS @{thm eq_True[THEN iffD2]} | _ => th)
                   rel_inject_thms ms;
 
               val (map_disc_iff_thms, map_sel_thms, set_sel_thms, rel_sel_thms, set_intros_thms,
-                   case_transfer_thms, ctr_transfer_thms, (set_cases_thms, set_cases_attrss),
-                   (rel_cases_thm, rel_cases_attrs)) =
+                   case_transfer_thms, ctr_transfer_thms, disc_transfer_thms,
+                   (set_cases_thms, set_cases_attrss), (rel_cases_thm, rel_cases_attrs)) =
                 let
                   val live_AsBs = filter (op <>) (As ~~ Bs);
                   val fTs = map (op -->) live_AsBs;
                   val (((((fs, Rs), ta), tb), thesis), names_lthy) = names_lthy
                     |> mk_Frees "f" fTs

                   val ctrAs = map (mk_ctr As) ctrs;
                   val ctrBs = map (mk_ctr Bs) ctrs;
                   val relAsBs = mk_rel live As Bs (rel_of_bnf fp_bnf);
                   val setAs = map (mk_set As) (sets_of_bnf fp_bnf);
                   val discAs = map (mk_disc_or_sel As) discs;
+                  val discBs = map (mk_disc_or_sel Bs) discs;
                   val selAss = map (map (mk_disc_or_sel As)) selss;
                   val discAs_selAss = flat (map2 (map o pair) discAs selAss);
 
                   val ctr_transfer_thms =
                     let

                         |> map Thm.close_derivation
                     end;
 
                   val rel_sel_thms =
                     let
-                      val discBs = map (mk_disc_or_sel Bs) discs;
                       val selBss = map (map (mk_disc_or_sel Bs)) selss;
                       val n = length discAs;
 
                       fun mk_rhs n k discA selAs discB selBs =
                         (if k = n then [] else [HOLogic.mk_eq (discA $ ta, discB $ tb)]) @

                       Goal.prove_sorry lthy [] [] goal
                         (fn {context = ctxt, prems = _} =>
                           mk_case_transfer_tac ctxt rel_cases_thm case_thms)
                       |> singleton (Proof_Context.export names_lthy lthy)
                       |> Thm.close_derivation
+                    end;
+
+                  val disc_transfer_thms =
+                    let
+                      val goals = map2 (mk_parametricity_goal names_lthy Rs) discAs discBs;
+                    in
+                      if null goals then []
+                      else
+                        Goal.prove_sorry lthy [] [] (Logic.mk_conjunction_balanced goals)
+                          (fn {context = ctxt, prems = _} =>
+                            mk_disc_transfer_tac ctxt (the_single rel_sel_thms)
+                              (the_single exhaust_discs) (flat (flat distinct_discsss)))
+                          |> Conjunction.elim_balanced (length goals)
+                        |> Proof_Context.export names_lthy lthy
+                        |> map Thm.close_derivation
                     end;
 
                   val map_disc_iff_thms =
                     let
                       val discsB = map (mk_disc_or_sel Bs) discs;

                         |> Proof_Context.export names_lthy lthy
                         |> map Thm.close_derivation
                     end;
                 in
                   (map_disc_iff_thms, map_sel_thms, set_sel_thms, rel_sel_thms, set_intros_thms,
-                    case_transfer_thms, ctr_transfer_thms, (set_cases_thms, set_cases_attrss),
-                    (rel_cases_thm, rel_cases_attrs))
+                    case_transfer_thms, ctr_transfer_thms, disc_transfer_thms,
+                    (set_cases_thms, set_cases_attrss), (rel_cases_thm, rel_cases_attrs))
                 end;
 
               val anonymous_notes =
                 [([case_cong], fundefcong_attrs),
                  (rel_eq_thms, code_nitpicksimp_attrs)]
                 |> map (fn (thms, attrs) => ((Binding.empty, attrs), [(thms, [])]));
 
               val notes =
                 [(case_transferN, [case_transfer_thms], K []),
                  (ctr_transferN, ctr_transfer_thms, K []),
+                 (disc_transferN, disc_transfer_thms, K []),
                  (mapN, map_thms, K (code_nitpicksimp_attrs @ simp_attrs)),
                  (map_disc_iffN, map_disc_iff_thms, K simp_attrs),
                  (map_selN, map_sel_thms, K []),
                  (rel_casesN, [rel_cases_thm], K rel_cases_attrs),
                  (rel_distinctN, rel_distinct_thms, K simp_attrs),