src/HOL/Tools/BNF/bnf_fp_util.ML
author wenzelm
Wed, 08 Oct 2014 17:09:07 +0200
changeset 58634 9f10d82e8188
parent 58585 efc8b2c54a38
child 59058 a78612c67ec0
permissions -rw-r--r--
added parameterized ML antiquotations @{map N}, @{fold N}, @{fold_map N}, @{split_list N};
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
55061
a0adf838e2d1 adjusted comments
blanchet
parents: 55060
diff changeset
     1
(*  Title:      HOL/Tools/BNF/bnf_fp_util.ML
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
     2
    Author:     Dmitriy Traytel, TU Muenchen
51823
38996458bc5c create data structure for storing (co)datatype information
blanchet
parents: 51819
diff changeset
     3
    Author:     Jasmin Blanchette, TU Muenchen
57668
blanchet
parents: 57563
diff changeset
     4
    Author:     Martin Desharnais, TU Muenchen
58256
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
     5
    Author:     Stefan Berghofer, TU Muenchen
57668
blanchet
parents: 57563
diff changeset
     6
    Copyright   2012, 2013, 2014
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
     7
49389
blanchet
parents: 49368
diff changeset
     8
Shared library for the datatype and codatatype constructions.
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
     9
*)
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    10
51850
106afdf5806c renamed a few FP-related files, to make it clear that these are not the sum of LFP + GFP but rather shared basic libraries
blanchet
parents: 51839
diff changeset
    11
signature BNF_FP_UTIL =
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    12
sig
49591
91b228e26348 generate high-level "coinduct" and "strong_coinduct" properties
blanchet
parents: 49589
diff changeset
    13
  type fp_result =
51859
09d24ea3f140 rationalized data structure
blanchet
parents: 51858
diff changeset
    14
    {Ts: typ list,
09d24ea3f140 rationalized data structure
blanchet
parents: 51858
diff changeset
    15
     bnfs: BNF_Def.bnf list,
51839
5c552de1d8d1 added constructors to data structure
blanchet
parents: 51837
diff changeset
    16
     ctors: term list,
51819
9df935196be9 use record instead of big tuple
blanchet
parents: 51805
diff changeset
    17
     dtors: term list,
55868
37b99986d435 rationalized internals
blanchet
parents: 55856
diff changeset
    18
     xtor_co_recs: term list,
53106
d81211f61a1b moved derivation of strong coinduction to sugar
traytel
parents: 53105
diff changeset
    19
     xtor_co_induct: thm,
51819
9df935196be9 use record instead of big tuple
blanchet
parents: 51805
diff changeset
    20
     dtor_ctors: thm list,
9df935196be9 use record instead of big tuple
blanchet
parents: 51805
diff changeset
    21
     ctor_dtors: thm list,
9df935196be9 use record instead of big tuple
blanchet
parents: 51805
diff changeset
    22
     ctor_injects: thm list,
53203
222ea6acbdd6 moved derivation of ctor_dtor_unfold to sugar (streamlines fp_result interface)
traytel
parents: 53202
diff changeset
    23
     dtor_injects: thm list,
58583
1dd83cbba636 rename 'xtor_map_thms' to 'xtor_maps'
desharna
parents: 58581
diff changeset
    24
     xtor_maps: thm list,
58584
b6492a7abb59 rename 'xtor_set_thmss' to 'xtor_setss'
desharna
parents: 58583
diff changeset
    25
     xtor_setss: thm list list,
58585
efc8b2c54a38 rename 'xtor_rel_thms' to 'xtor_rels'
desharna
parents: 58584
diff changeset
    26
     xtor_rels: thm list,
55868
37b99986d435 rationalized internals
blanchet
parents: 55856
diff changeset
    27
     xtor_co_rec_thms: thm list,
58578
9ff8ca957c02 rename 'xtor_co_rec_o_map_thms' to 'xtor_co_rec_o_maps'
desharna
parents: 58448
diff changeset
    28
     xtor_co_rec_o_maps: thm list,
58579
b7bc5ba2f3fb rename 'rel_xtor_co_induct_thm' to 'xtor_rel_co_induct'
desharna
parents: 58578
diff changeset
    29
     xtor_rel_co_induct: thm,
58580
8ee2d984caa8 rename 'dtor_set_induct_thms' to 'dtor_set_inducts'
desharna
parents: 58579
diff changeset
    30
     dtor_set_inducts: thm list,
58581
e2e2d775869c rename 'xtor_co_rec_transfer_thms' to 'xtor_co_rec_transfers'
desharna
parents: 58580
diff changeset
    31
     xtor_co_rec_transfers: thm list}
49591
91b228e26348 generate high-level "coinduct" and "strong_coinduct" properties
blanchet
parents: 49589
diff changeset
    32
51823
38996458bc5c create data structure for storing (co)datatype information
blanchet
parents: 51819
diff changeset
    33
  val morph_fp_result: morphism -> fp_result -> fp_result
38996458bc5c create data structure for storing (co)datatype information
blanchet
parents: 51819
diff changeset
    34
53143
ba80154a1118 configuration option to control timing output for (co)datatypes
traytel
parents: 53138
diff changeset
    35
  val time: Proof.context -> Timer.real_timer -> string -> Timer.real_timer
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    36
55851
3d40cf74726c optimize cardinal bounds involving natLeq (omega)
blanchet
parents: 55811
diff changeset
    37
  val fixpoint: ('a * 'a -> bool) -> ('a list -> 'a list) -> 'a list -> 'a list
3d40cf74726c optimize cardinal bounds involving natLeq (omega)
blanchet
parents: 55811
diff changeset
    38
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    39
  val IITN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    40
  val LevN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    41
  val algN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    42
  val behN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    43
  val bisN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    44
  val carTN: string
49338
blanchet
parents: 49337
diff changeset
    45
  val caseN: string
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    46
  val coN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    47
  val coinductN: string
57983
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
    48
  val coinduct_strongN: string
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    49
  val corecN: string
57983
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
    50
  val corec_discN: string
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
    51
  val corec_disc_iffN: string
49501
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
    52
  val ctorN: string
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
    53
  val ctor_dtorN: string
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
    54
  val ctor_exhaustN: string
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
    55
  val ctor_induct2N: string
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
    56
  val ctor_inductN: string
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
    57
  val ctor_injectN: string
49504
df9b897fb254 renamed "iter"/"coiter" to "fold"/"unfold" (cf. Wadler)
blanchet
parents: 49502
diff changeset
    58
  val ctor_foldN: string
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
    59
  val ctor_fold_o_mapN: string
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
    60
  val ctor_fold_transferN: string
49504
df9b897fb254 renamed "iter"/"coiter" to "fold"/"unfold" (cf. Wadler)
blanchet
parents: 49502
diff changeset
    61
  val ctor_fold_uniqueN: string
49541
32fb6e4c7f4b renamed "map_simps" to "{c,d}tor_maps"
blanchet
parents: 49536
diff changeset
    62
  val ctor_mapN: string
49543
53b3c532a082 renamed low-level "map_unique" to have "ctor" or "dtor" in the name
blanchet
parents: 49542
diff changeset
    63
  val ctor_map_uniqueN: string
49501
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
    64
  val ctor_recN: string
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
    65
  val ctor_rec_o_mapN: string
58444
ed95293f14b6 generate 'ctor_rec_transfer' for datatypes
desharna
parents: 58443
diff changeset
    66
  val ctor_rec_transferN: string
51739
3514b90d0a8b (co)rec is (just as the (un)fold) the unique morphism;
traytel
parents: 49635
diff changeset
    67
  val ctor_rec_uniqueN: string
49518
b377da40244b renamed LFP low-level rel property to have ctor not dtor in its name
blanchet
parents: 49516
diff changeset
    68
  val ctor_relN: string
55901
8c6d49dd8ae1 renamed a pair of low-level theorems to have c/dtor in their names (like the others)
blanchet
parents: 55899
diff changeset
    69
  val ctor_rel_inductN: string
49544
24094fa47e0d renamed "set_incl" etc. to have "ctor" or "dtor" in the name
blanchet
parents: 49543
diff changeset
    70
  val ctor_set_inclN: string
24094fa47e0d renamed "set_incl" etc. to have "ctor" or "dtor" in the name
blanchet
parents: 49543
diff changeset
    71
  val ctor_set_set_inclN: string
49501
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
    72
  val dtorN: string
49582
557302525778 renamed "dtor_rel_coinduct" etc. to "dtor_coinduct"
blanchet
parents: 49581
diff changeset
    73
  val dtor_coinductN: string
49501
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
    74
  val dtor_corecN: string
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
    75
  val dtor_corec_o_mapN: string
58445
86b5b02ef33a generate 'dtor_corec_transfer' for codatatypes
desharna
parents: 58444
diff changeset
    76
  val dtor_corec_transferN: string
51739
3514b90d0a8b (co)rec is (just as the (un)fold) the unique morphism;
traytel
parents: 49635
diff changeset
    77
  val dtor_corec_uniqueN: string
49518
b377da40244b renamed LFP low-level rel property to have ctor not dtor in its name
blanchet
parents: 49516
diff changeset
    78
  val dtor_ctorN: string
49501
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
    79
  val dtor_exhaustN: string
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
    80
  val dtor_injectN: string
49545
8bb6e2d7346b renamed coinduction principles to have "dtor" in the name
blanchet
parents: 49544
diff changeset
    81
  val dtor_mapN: string
49581
4e5bd3883429 renamed "dtor_coinduct" etc. to "dtor_map_coinduct"
blanchet
parents: 49545
diff changeset
    82
  val dtor_map_coinductN: string
57983
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
    83
  val dtor_map_coinduct_strongN: string
49543
53b3c532a082 renamed low-level "map_unique" to have "ctor" or "dtor" in the name
blanchet
parents: 49542
diff changeset
    84
  val dtor_map_uniqueN: string
49545
8bb6e2d7346b renamed coinduction principles to have "dtor" in the name
blanchet
parents: 49544
diff changeset
    85
  val dtor_relN: string
55901
8c6d49dd8ae1 renamed a pair of low-level theorems to have c/dtor in their names (like the others)
blanchet
parents: 55899
diff changeset
    86
  val dtor_rel_coinductN: string
49544
24094fa47e0d renamed "set_incl" etc. to have "ctor" or "dtor" in the name
blanchet
parents: 49543
diff changeset
    87
  val dtor_set_inclN: string
24094fa47e0d renamed "set_incl" etc. to have "ctor" or "dtor" in the name
blanchet
parents: 49543
diff changeset
    88
  val dtor_set_set_inclN: string
57983
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
    89
  val dtor_coinduct_strongN: string
49516
d4859efc1096 renamed "rel_simp" to "dtor_rel" and similarly for "srel"
blanchet
parents: 49510
diff changeset
    90
  val dtor_unfoldN: string
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
    91
  val dtor_unfold_o_mapN: string
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
    92
  val dtor_unfold_transferN: string
49516
d4859efc1096 renamed "rel_simp" to "dtor_rel" and similarly for "srel"
blanchet
parents: 49510
diff changeset
    93
  val dtor_unfold_uniqueN: string
49020
f379cf5d71bd more work on BNF sugar -- up to derivation of nchotomy
blanchet
parents: 49019
diff changeset
    94
  val exhaustN: string
56113
e3b8f8319d73 simplified internal codatatype construction
traytel
parents: 55990
diff changeset
    95
  val colN: string
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    96
  val inductN: string
49019
fc4decdba5ce more work on BNF sugar
blanchet
parents: 48975
diff changeset
    97
  val injectN: string
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    98
  val isNodeN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
    99
  val lsbisN: string
49594
55e798614c45 tweaked theorem names (in particular, dropped s's)
blanchet
parents: 49592
diff changeset
   100
  val mapN: string
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   101
  val map_uniqueN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   102
  val min_algN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   103
  val morN: string
49020
f379cf5d71bd more work on BNF sugar -- up to derivation of nchotomy
blanchet
parents: 49019
diff changeset
   104
  val nchotomyN: string
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   105
  val recN: string
57525
f9dd8a33f820 generate 'rel_cases' theorem for (co)datatypes
desharna
parents: 57493
diff changeset
   106
  val rel_casesN: string
51918
3c152334f794 relator induction for datatypes
traytel
parents: 51893
diff changeset
   107
  val rel_coinductN: string
3c152334f794 relator induction for datatypes
traytel
parents: 51893
diff changeset
   108
  val rel_inductN: string
49592
b859a02c1150 fixed "rels" + split them into injectivity and distinctness
blanchet
parents: 49591
diff changeset
   109
  val rel_injectN: string
57493
554592fb795a generate 'rel_intros' theorem for (co)datatypes
desharna
parents: 57489
diff changeset
   110
  val rel_introsN: string
49592
b859a02c1150 fixed "rels" + split them into injectivity and distinctness
blanchet
parents: 49591
diff changeset
   111
  val rel_distinctN: string
57563
e3e7c86168b4 generate 'rel_sel' theorem for (co)datatypes
desharna
parents: 57529
diff changeset
   112
  val rel_selN: string
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   113
  val rvN: string
57983
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
   114
  val corec_selN: string
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   115
  val set_inclN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   116
  val set_set_inclN: string
53694
7b453b619b5f use singular to avoid confusion
blanchet
parents: 53566
diff changeset
   117
  val setN: string
49438
5bc80d96241e group "simps" together
blanchet
parents: 49425
diff changeset
   118
  val simpsN: string
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   119
  val strTN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   120
  val str_initN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   121
  val sum_bdN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   122
  val sum_bdTN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   123
  val uniqueN: string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   124
49585
5c4a12550491 generate high-level "maps", "sets", and "rels" properties
blanchet
parents: 49584
diff changeset
   125
  (* TODO: Don't index set facts. Isabelle packages traditionally generate uniform names. *)
49584
4339aa335355 use singular since there is always only one theorem
blanchet
parents: 49582
diff changeset
   126
  val mk_ctor_setN: int -> string
4339aa335355 use singular since there is always only one theorem
blanchet
parents: 49582
diff changeset
   127
  val mk_dtor_setN: int -> string
49542
b39354db8629 renamed low-level "set_simps" and "set_induct" to have "ctor" or "dtor" in the name
blanchet
parents: 49541
diff changeset
   128
  val mk_dtor_set_inductN: int -> string
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   129
  val mk_set_inductN: int -> string
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   130
55575
a5e33e18fb5c moved 'primrec' up (for real this time) and removed temporary 'old_primrec'
blanchet
parents: 55570
diff changeset
   131
  val co_prefix: BNF_Util.fp_kind -> string
51863
d77cf35c27ac tuning names
blanchet
parents: 51862
diff changeset
   132
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   133
  val split_conj_thm: thm -> thm list
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   134
  val split_conj_prems: int -> thm -> thm
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   135
49255
2ecc533d6697 use balanced sums for constructors (to gracefully handle 100 constructors or more)
blanchet
parents: 49240
diff changeset
   136
  val mk_sumTN: typ list -> typ
58159
blanchet
parents: 58117
diff changeset
   137
  val mk_sumTN_balanced: typ list -> typ
55969
8820ddb8f9f4 use balanced tuples in 'primcorec'
blanchet
parents: 55968
diff changeset
   138
  val mk_tupleT_balanced: typ list -> typ
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   139
  val mk_sumprodT_balanced: typ list list -> typ
49255
2ecc533d6697 use balanced sums for constructors (to gracefully handle 100 constructors or more)
blanchet
parents: 49240
diff changeset
   140
54923
ffed2452f5f6 instantiate schematics as projections to avoid HOU trouble
blanchet
parents: 54171
diff changeset
   141
  val mk_proj: typ -> int -> int -> term
ffed2452f5f6 instantiate schematics as projections to avoid HOU trouble
blanchet
parents: 54171
diff changeset
   142
53032
traytel
parents: 52987
diff changeset
   143
  val mk_convol: term * term -> term
58443
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   144
  val mk_rel_prod: term -> term -> term
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   145
  val mk_rel_sum: term -> term -> term
49368
df359ce891ac added induct tactic
blanchet
parents: 49342
diff changeset
   146
49121
9e0acaa470ab more work on FP sugar
blanchet
parents: 49119
diff changeset
   147
  val Inl_const: typ -> typ -> term
9e0acaa470ab more work on FP sugar
blanchet
parents: 49119
diff changeset
   148
  val Inr_const: typ -> typ -> term
55969
8820ddb8f9f4 use balanced tuples in 'primcorec'
blanchet
parents: 55968
diff changeset
   149
  val mk_tuple_balanced: term list -> term
8820ddb8f9f4 use balanced tuples in 'primcorec'
blanchet
parents: 55968
diff changeset
   150
  val mk_tuple1_balanced: typ list -> term list -> term
49121
9e0acaa470ab more work on FP sugar
blanchet
parents: 49119
diff changeset
   151
55414
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   152
  val mk_case_sum: term * term -> term
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   153
  val mk_case_sumN: term list -> term
55968
blanchet
parents: 55966
diff changeset
   154
  val mk_case_absumprod: typ -> term -> term list -> term list list -> term list list -> term
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   155
49255
2ecc533d6697 use balanced sums for constructors (to gracefully handle 100 constructors or more)
blanchet
parents: 49240
diff changeset
   156
  val mk_Inl: typ -> term -> term
2ecc533d6697 use balanced sums for constructors (to gracefully handle 100 constructors or more)
blanchet
parents: 49240
diff changeset
   157
  val mk_Inr: typ -> term -> term
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   158
  val mk_absumprod: typ -> term -> int -> int -> term list -> term
49121
9e0acaa470ab more work on FP sugar
blanchet
parents: 49119
diff changeset
   159
49255
2ecc533d6697 use balanced sums for constructors (to gracefully handle 100 constructors or more)
blanchet
parents: 49240
diff changeset
   160
  val dest_sumT: typ -> typ * typ
58159
blanchet
parents: 58117
diff changeset
   161
  val dest_sumTN_balanced: int -> typ -> typ list
blanchet
parents: 58117
diff changeset
   162
  val dest_tupleT_balanced: int -> typ -> typ list
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   163
  val dest_absumprodT: typ -> typ -> int -> int list -> typ -> typ list list
49176
6d29d2db5f88 construct high-level iterator RHS
blanchet
parents: 49169
diff changeset
   164
53202
2333fae25719 export one more ML function, needed for primcorec
blanchet
parents: 53143
diff changeset
   165
  val If_const: typ -> term
2333fae25719 export one more ML function, needed for primcorec
blanchet
parents: 53143
diff changeset
   166
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   167
  val mk_Field: term -> term
49275
ce87d6a901eb split sum types in corecursor definition
blanchet
parents: 49264
diff changeset
   168
  val mk_If: term -> term -> term -> term
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   169
  val mk_union: term * term -> term
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   170
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   171
  val mk_absumprodE: thm -> int list -> thm
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   172
55414
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   173
  val mk_sum_caseN: int -> int -> thm
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   174
  val mk_sum_caseN_balanced: int -> int -> thm
49125
5fc5211cf104 implemented "mk_exhaust_tac"
blanchet
parents: 49121
diff changeset
   175
55851
3d40cf74726c optimize cardinal bounds involving natLeq (omega)
blanchet
parents: 55811
diff changeset
   176
  val mk_sum_Cinfinite: thm list -> thm
3d40cf74726c optimize cardinal bounds involving natLeq (omega)
blanchet
parents: 55811
diff changeset
   177
  val mk_sum_card_order: thm list -> thm
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   178
58579
b7bc5ba2f3fb rename 'rel_xtor_co_induct_thm' to 'xtor_rel_co_induct'
desharna
parents: 58578
diff changeset
   179
  val mk_xtor_rel_co_induct_thm: BNF_Util.fp_kind -> term list -> term list -> term list ->
55575
a5e33e18fb5c moved 'primrec' up (for real this time) and removed temporary 'old_primrec'
blanchet
parents: 55570
diff changeset
   180
    term list -> term list -> term list -> term list -> term list ->
52505
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   181
    ({prems: thm list, context: Proof.context} -> tactic) -> Proof.context -> thm
58443
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   182
  val mk_co_iter_transfer_thms: BNF_Util.fp_kind -> term list -> term list -> term list ->
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   183
    term list -> term list -> term list -> term list ->
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   184
    ({prems: thm list, context: Proof.context} -> tactic) -> Proof.context -> thm list
55575
a5e33e18fb5c moved 'primrec' up (for real this time) and removed temporary 'old_primrec'
blanchet
parents: 55570
diff changeset
   185
  val mk_xtor_un_fold_o_map_thms: BNF_Util.fp_kind -> bool -> int -> thm -> thm list -> thm list ->
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   186
    thm list -> thm list -> thm list
52505
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   187
57983
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
   188
  val mk_coinduct_strong_thm: thm -> thm list -> thm list -> (thm -> thm) -> Proof.context -> thm
53105
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   189
51867
6d756057e736 signature tuning
blanchet
parents: 51866
diff changeset
   190
  val fp_bnf: (binding list -> (string * sort) list -> typ list * typ list list ->
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   191
      BNF_Def.bnf list -> BNF_Comp.absT_info list -> local_theory -> 'a) ->
55701
38f75365fc2a added explicit killing
blanchet
parents: 55642
diff changeset
   192
    binding list -> (string * sort) list -> (string * sort) list -> ((string * sort) * typ) list ->
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   193
    local_theory -> (BNF_Def.bnf list * BNF_Comp.absT_info list) * 'a
58256
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   194
  val fp_antiquote_setup: binding -> theory -> theory
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   195
end;
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   196
51850
106afdf5806c renamed a few FP-related files, to make it clear that these are not the sum of LFP + GFP but rather shared basic libraries
blanchet
parents: 51839
diff changeset
   197
structure BNF_FP_Util : BNF_FP_UTIL =
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   198
struct
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   199
56650
1f9ab71d43a5 no need to make 'size' generation an interpretation -- overkill
blanchet
parents: 56113
diff changeset
   200
open Ctr_Sugar
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   201
open BNF_Comp
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   202
open BNF_Def
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   203
open BNF_Util
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   204
49591
91b228e26348 generate high-level "coinduct" and "strong_coinduct" properties
blanchet
parents: 49589
diff changeset
   205
type fp_result =
51859
09d24ea3f140 rationalized data structure
blanchet
parents: 51858
diff changeset
   206
  {Ts: typ list,
09d24ea3f140 rationalized data structure
blanchet
parents: 51858
diff changeset
   207
   bnfs: BNF_Def.bnf list,
51839
5c552de1d8d1 added constructors to data structure
blanchet
parents: 51837
diff changeset
   208
   ctors: term list,
51819
9df935196be9 use record instead of big tuple
blanchet
parents: 51805
diff changeset
   209
   dtors: term list,
55868
37b99986d435 rationalized internals
blanchet
parents: 55856
diff changeset
   210
   xtor_co_recs: term list,
53106
d81211f61a1b moved derivation of strong coinduction to sugar
traytel
parents: 53105
diff changeset
   211
   xtor_co_induct: thm,
51819
9df935196be9 use record instead of big tuple
blanchet
parents: 51805
diff changeset
   212
   dtor_ctors: thm list,
9df935196be9 use record instead of big tuple
blanchet
parents: 51805
diff changeset
   213
   ctor_dtors: thm list,
9df935196be9 use record instead of big tuple
blanchet
parents: 51805
diff changeset
   214
   ctor_injects: thm list,
53203
222ea6acbdd6 moved derivation of ctor_dtor_unfold to sugar (streamlines fp_result interface)
traytel
parents: 53202
diff changeset
   215
   dtor_injects: thm list,
58583
1dd83cbba636 rename 'xtor_map_thms' to 'xtor_maps'
desharna
parents: 58581
diff changeset
   216
   xtor_maps: thm list,
58584
b6492a7abb59 rename 'xtor_set_thmss' to 'xtor_setss'
desharna
parents: 58583
diff changeset
   217
   xtor_setss: thm list list,
58585
efc8b2c54a38 rename 'xtor_rel_thms' to 'xtor_rels'
desharna
parents: 58584
diff changeset
   218
   xtor_rels: thm list,
55868
37b99986d435 rationalized internals
blanchet
parents: 55856
diff changeset
   219
   xtor_co_rec_thms: thm list,
58578
9ff8ca957c02 rename 'xtor_co_rec_o_map_thms' to 'xtor_co_rec_o_maps'
desharna
parents: 58448
diff changeset
   220
   xtor_co_rec_o_maps: thm list,
58579
b7bc5ba2f3fb rename 'rel_xtor_co_induct_thm' to 'xtor_rel_co_induct'
desharna
parents: 58578
diff changeset
   221
   xtor_rel_co_induct: thm,
58580
8ee2d984caa8 rename 'dtor_set_induct_thms' to 'dtor_set_inducts'
desharna
parents: 58579
diff changeset
   222
   dtor_set_inducts: thm list,
58581
e2e2d775869c rename 'xtor_co_rec_transfer_thms' to 'xtor_co_rec_transfers'
desharna
parents: 58580
diff changeset
   223
   xtor_co_rec_transfers: thm list};
49591
91b228e26348 generate high-level "coinduct" and "strong_coinduct" properties
blanchet
parents: 49589
diff changeset
   224
55899
8c0a13e84963 N2M does not use the low-level 'fold'; removed the latter from the fp_result interface;
traytel
parents: 55869
diff changeset
   225
fun morph_fp_result phi {Ts, bnfs, ctors, dtors, xtor_co_recs, xtor_co_induct,
58584
b6492a7abb59 rename 'xtor_set_thmss' to 'xtor_setss'
desharna
parents: 58583
diff changeset
   226
    dtor_ctors, ctor_dtors, ctor_injects, dtor_injects, xtor_maps, xtor_setss,
58585
efc8b2c54a38 rename 'xtor_rel_thms' to 'xtor_rels'
desharna
parents: 58584
diff changeset
   227
    xtor_rels, xtor_co_rec_thms, xtor_co_rec_o_maps, xtor_rel_co_induct,
58581
e2e2d775869c rename 'xtor_co_rec_transfer_thms' to 'xtor_co_rec_transfers'
desharna
parents: 58580
diff changeset
   228
    dtor_set_inducts, xtor_co_rec_transfers} =
51859
09d24ea3f140 rationalized data structure
blanchet
parents: 51858
diff changeset
   229
  {Ts = map (Morphism.typ phi) Ts,
09d24ea3f140 rationalized data structure
blanchet
parents: 51858
diff changeset
   230
   bnfs = map (morph_bnf phi) bnfs,
51839
5c552de1d8d1 added constructors to data structure
blanchet
parents: 51837
diff changeset
   231
   ctors = map (Morphism.term phi) ctors,
51823
38996458bc5c create data structure for storing (co)datatype information
blanchet
parents: 51819
diff changeset
   232
   dtors = map (Morphism.term phi) dtors,
55868
37b99986d435 rationalized internals
blanchet
parents: 55856
diff changeset
   233
   xtor_co_recs = map (Morphism.term phi) xtor_co_recs,
53106
d81211f61a1b moved derivation of strong coinduction to sugar
traytel
parents: 53105
diff changeset
   234
   xtor_co_induct = Morphism.thm phi xtor_co_induct,
51823
38996458bc5c create data structure for storing (co)datatype information
blanchet
parents: 51819
diff changeset
   235
   dtor_ctors = map (Morphism.thm phi) dtor_ctors,
38996458bc5c create data structure for storing (co)datatype information
blanchet
parents: 51819
diff changeset
   236
   ctor_dtors = map (Morphism.thm phi) ctor_dtors,
38996458bc5c create data structure for storing (co)datatype information
blanchet
parents: 51819
diff changeset
   237
   ctor_injects = map (Morphism.thm phi) ctor_injects,
53203
222ea6acbdd6 moved derivation of ctor_dtor_unfold to sugar (streamlines fp_result interface)
traytel
parents: 53202
diff changeset
   238
   dtor_injects = map (Morphism.thm phi) dtor_injects,
58583
1dd83cbba636 rename 'xtor_map_thms' to 'xtor_maps'
desharna
parents: 58581
diff changeset
   239
   xtor_maps = map (Morphism.thm phi) xtor_maps,
58584
b6492a7abb59 rename 'xtor_set_thmss' to 'xtor_setss'
desharna
parents: 58583
diff changeset
   240
   xtor_setss = map (map (Morphism.thm phi)) xtor_setss,
58585
efc8b2c54a38 rename 'xtor_rel_thms' to 'xtor_rels'
desharna
parents: 58584
diff changeset
   241
   xtor_rels = map (Morphism.thm phi) xtor_rels,
55868
37b99986d435 rationalized internals
blanchet
parents: 55856
diff changeset
   242
   xtor_co_rec_thms = map (Morphism.thm phi) xtor_co_rec_thms,
58578
9ff8ca957c02 rename 'xtor_co_rec_o_map_thms' to 'xtor_co_rec_o_maps'
desharna
parents: 58448
diff changeset
   243
   xtor_co_rec_o_maps = map (Morphism.thm phi) xtor_co_rec_o_maps,
58579
b7bc5ba2f3fb rename 'rel_xtor_co_induct_thm' to 'xtor_rel_co_induct'
desharna
parents: 58578
diff changeset
   244
   xtor_rel_co_induct = Morphism.thm phi xtor_rel_co_induct,
58580
8ee2d984caa8 rename 'dtor_set_induct_thms' to 'dtor_set_inducts'
desharna
parents: 58579
diff changeset
   245
   dtor_set_inducts = map (Morphism.thm phi) dtor_set_inducts,
58581
e2e2d775869c rename 'xtor_co_rec_transfer_thms' to 'xtor_co_rec_transfers'
desharna
parents: 58580
diff changeset
   246
   xtor_co_rec_transfers = map (Morphism.thm phi) xtor_co_rec_transfers};
51823
38996458bc5c create data structure for storing (co)datatype information
blanchet
parents: 51819
diff changeset
   247
53143
ba80154a1118 configuration option to control timing output for (co)datatypes
traytel
parents: 53138
diff changeset
   248
fun time ctxt timer msg = (if Config.get ctxt bnf_timing
55811
aa1acc25126b load Metis a little later
traytel
parents: 55803
diff changeset
   249
  then warning (msg ^ ": " ^ string_of_int (Time.toMilliseconds (Timer.checkRealTimer timer)) ^
aa1acc25126b load Metis a little later
traytel
parents: 55803
diff changeset
   250
    "ms")
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   251
  else (); Timer.startRealTimer ());
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   252
49223
blanchet
parents: 49222
diff changeset
   253
val preN = "pre_"
blanchet
parents: 49222
diff changeset
   254
val rawN = "raw_"
49218
d01a5c918298 renamed xxxBNF to pre_xxx
blanchet
parents: 49207
diff changeset
   255
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   256
val coN = "co"
49504
df9b897fb254 renamed "iter"/"coiter" to "fold"/"unfold" (cf. Wadler)
blanchet
parents: 49502
diff changeset
   257
val unN = "un"
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   258
val algN = "alg"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   259
val IITN = "IITN"
49504
df9b897fb254 renamed "iter"/"coiter" to "fold"/"unfold" (cf. Wadler)
blanchet
parents: 49502
diff changeset
   260
val foldN = "fold"
df9b897fb254 renamed "iter"/"coiter" to "fold"/"unfold" (cf. Wadler)
blanchet
parents: 49502
diff changeset
   261
val unfoldN = unN ^ foldN
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   262
val uniqueN = "_unique"
52731
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   263
val transferN = "_transfer"
49438
5bc80d96241e group "simps" together
blanchet
parents: 49425
diff changeset
   264
val simpsN = "simps"
49501
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
   265
val ctorN = "ctor"
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
   266
val dtorN = "dtor"
49504
df9b897fb254 renamed "iter"/"coiter" to "fold"/"unfold" (cf. Wadler)
blanchet
parents: 49502
diff changeset
   267
val ctor_foldN = ctorN ^ "_" ^ foldN
df9b897fb254 renamed "iter"/"coiter" to "fold"/"unfold" (cf. Wadler)
blanchet
parents: 49502
diff changeset
   268
val dtor_unfoldN = dtorN ^ "_" ^ unfoldN
df9b897fb254 renamed "iter"/"coiter" to "fold"/"unfold" (cf. Wadler)
blanchet
parents: 49502
diff changeset
   269
val ctor_fold_uniqueN = ctor_foldN ^ uniqueN
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   270
val ctor_fold_o_mapN = ctor_foldN ^ "_o_" ^ mapN
49504
df9b897fb254 renamed "iter"/"coiter" to "fold"/"unfold" (cf. Wadler)
blanchet
parents: 49502
diff changeset
   271
val dtor_unfold_uniqueN = dtor_unfoldN ^ uniqueN
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   272
val dtor_unfold_o_mapN = dtor_unfoldN ^ "_o_" ^ mapN
52731
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   273
val ctor_fold_transferN = ctor_foldN ^ transferN
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   274
val dtor_unfold_transferN = dtor_unfoldN ^ transferN
49541
32fb6e4c7f4b renamed "map_simps" to "{c,d}tor_maps"
blanchet
parents: 49536
diff changeset
   275
val ctor_mapN = ctorN ^ "_" ^ mapN
32fb6e4c7f4b renamed "map_simps" to "{c,d}tor_maps"
blanchet
parents: 49536
diff changeset
   276
val dtor_mapN = dtorN ^ "_" ^ mapN
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   277
val map_uniqueN = mapN ^ uniqueN
49543
53b3c532a082 renamed low-level "map_unique" to have "ctor" or "dtor" in the name
blanchet
parents: 49542
diff changeset
   278
val ctor_map_uniqueN = ctorN ^ "_" ^ map_uniqueN
53b3c532a082 renamed low-level "map_unique" to have "ctor" or "dtor" in the name
blanchet
parents: 49542
diff changeset
   279
val dtor_map_uniqueN = dtorN ^ "_" ^ map_uniqueN
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   280
val min_algN = "min_alg"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   281
val morN = "mor"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   282
val bisN = "bis"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   283
val lsbisN = "lsbis"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   284
val sum_bdTN = "sbdT"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   285
val sum_bdN = "sbd"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   286
val carTN = "carT"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   287
val strTN = "strT"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   288
val isNodeN = "isNode"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   289
val LevN = "Lev"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   290
val rvN = "recover"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   291
val behN = "beh"
53694
7b453b619b5f use singular to avoid confusion
blanchet
parents: 53566
diff changeset
   292
val setN = "set"
49584
4339aa335355 use singular since there is always only one theorem
blanchet
parents: 49582
diff changeset
   293
val mk_ctor_setN = prefix (ctorN ^ "_") o mk_setN
4339aa335355 use singular since there is always only one theorem
blanchet
parents: 49582
diff changeset
   294
val mk_dtor_setN = prefix (dtorN ^ "_") o mk_setN
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   295
fun mk_set_inductN i = mk_setN i ^ "_induct"
49542
b39354db8629 renamed low-level "set_simps" and "set_induct" to have "ctor" or "dtor" in the name
blanchet
parents: 49541
diff changeset
   296
val mk_dtor_set_inductN = prefix (dtorN ^ "_") o mk_set_inductN
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   297
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   298
val str_initN = "str_init"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   299
val recN = "rec"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   300
val corecN = coN ^ recN
49501
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
   301
val ctor_recN = ctorN ^ "_" ^ recN
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   302
val ctor_rec_o_mapN = ctor_recN ^ "_o_" ^ mapN
58444
ed95293f14b6 generate 'ctor_rec_transfer' for datatypes
desharna
parents: 58443
diff changeset
   303
val ctor_rec_transferN = ctor_recN ^ transferN
51739
3514b90d0a8b (co)rec is (just as the (un)fold) the unique morphism;
traytel
parents: 49635
diff changeset
   304
val ctor_rec_uniqueN = ctor_recN ^ uniqueN
49501
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
   305
val dtor_corecN = dtorN ^ "_" ^ corecN
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   306
val dtor_corec_o_mapN = dtor_corecN ^ "_o_" ^ mapN
58445
86b5b02ef33a generate 'dtor_corec_transfer' for codatatypes
desharna
parents: 58444
diff changeset
   307
val dtor_corec_transferN = dtor_corecN ^ transferN
51739
3514b90d0a8b (co)rec is (just as the (un)fold) the unique morphism;
traytel
parents: 49635
diff changeset
   308
val dtor_corec_uniqueN = dtor_corecN ^ uniqueN
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   309
49501
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
   310
val ctor_dtorN = ctorN ^ "_" ^ dtorN
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
   311
val dtor_ctorN = dtorN ^ "_" ^ ctorN
49020
f379cf5d71bd more work on BNF sugar -- up to derivation of nchotomy
blanchet
parents: 49019
diff changeset
   312
val nchotomyN = "nchotomy"
49019
fc4decdba5ce more work on BNF sugar
blanchet
parents: 48975
diff changeset
   313
val injectN = "inject"
49020
f379cf5d71bd more work on BNF sugar -- up to derivation of nchotomy
blanchet
parents: 49019
diff changeset
   314
val exhaustN = "exhaust"
49585
5c4a12550491 generate high-level "maps", "sets", and "rels" properties
blanchet
parents: 49584
diff changeset
   315
val ctor_injectN = ctorN ^ "_" ^ injectN
5c4a12550491 generate high-level "maps", "sets", and "rels" properties
blanchet
parents: 49584
diff changeset
   316
val ctor_exhaustN = ctorN ^ "_" ^ exhaustN
5c4a12550491 generate high-level "maps", "sets", and "rels" properties
blanchet
parents: 49584
diff changeset
   317
val dtor_injectN = dtorN ^ "_" ^ injectN
5c4a12550491 generate high-level "maps", "sets", and "rels" properties
blanchet
parents: 49584
diff changeset
   318
val dtor_exhaustN = dtorN ^ "_" ^ exhaustN
49545
8bb6e2d7346b renamed coinduction principles to have "dtor" in the name
blanchet
parents: 49544
diff changeset
   319
val ctor_relN = ctorN ^ "_" ^ relN
8bb6e2d7346b renamed coinduction principles to have "dtor" in the name
blanchet
parents: 49544
diff changeset
   320
val dtor_relN = dtorN ^ "_" ^ relN
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   321
val inductN = "induct"
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   322
val coinductN = coN ^ inductN
49501
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
   323
val ctor_inductN = ctorN ^ "_" ^ inductN
acc9635a644a renamed "fld"/"unf" to "ctor"/"dtor"
blanchet
parents: 49499
diff changeset
   324
val ctor_induct2N = ctor_inductN ^ "2"
49581
4e5bd3883429 renamed "dtor_coinduct" etc. to "dtor_map_coinduct"
blanchet
parents: 49545
diff changeset
   325
val dtor_map_coinductN = dtor_mapN ^ "_" ^ coinductN
49582
557302525778 renamed "dtor_rel_coinduct" etc. to "dtor_coinduct"
blanchet
parents: 49581
diff changeset
   326
val dtor_coinductN = dtorN ^ "_" ^ coinductN
57983
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
   327
val coinduct_strongN = coinductN ^ "_strong"
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
   328
val dtor_map_coinduct_strongN = dtor_mapN ^ "_" ^ coinduct_strongN
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
   329
val dtor_coinduct_strongN = dtorN ^ "_" ^ coinduct_strongN
56113
e3b8f8319d73 simplified internal codatatype construction
traytel
parents: 55990
diff changeset
   330
val colN = "col"
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   331
val set_inclN = "set_incl"
49544
24094fa47e0d renamed "set_incl" etc. to have "ctor" or "dtor" in the name
blanchet
parents: 49543
diff changeset
   332
val ctor_set_inclN = ctorN ^ "_" ^ set_inclN
24094fa47e0d renamed "set_incl" etc. to have "ctor" or "dtor" in the name
blanchet
parents: 49543
diff changeset
   333
val dtor_set_inclN = dtorN ^ "_" ^ set_inclN
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   334
val set_set_inclN = "set_set_incl"
49544
24094fa47e0d renamed "set_incl" etc. to have "ctor" or "dtor" in the name
blanchet
parents: 49543
diff changeset
   335
val ctor_set_set_inclN = ctorN ^ "_" ^ set_set_inclN
24094fa47e0d renamed "set_incl" etc. to have "ctor" or "dtor" in the name
blanchet
parents: 49543
diff changeset
   336
val dtor_set_set_inclN = dtorN ^ "_" ^ set_set_inclN
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   337
49338
blanchet
parents: 49337
diff changeset
   338
val caseN = "case"
49342
8ea4bad49ed5 rough and ready induction
blanchet
parents: 49338
diff changeset
   339
val discN = "disc"
57983
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
   340
val corec_discN = corecN ^ "_" ^ discN
49594
55e798614c45 tweaked theorem names (in particular, dropped s's)
blanchet
parents: 49592
diff changeset
   341
val iffN = "_iff"
57983
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
   342
val corec_disc_iffN = corec_discN ^ iffN
49592
b859a02c1150 fixed "rels" + split them into injectivity and distinctness
blanchet
parents: 49591
diff changeset
   343
val distinctN = "distinct"
b859a02c1150 fixed "rels" + split them into injectivity and distinctness
blanchet
parents: 49591
diff changeset
   344
val rel_distinctN = relN ^ "_" ^ distinctN
b859a02c1150 fixed "rels" + split them into injectivity and distinctness
blanchet
parents: 49591
diff changeset
   345
val injectN = "inject"
57525
f9dd8a33f820 generate 'rel_cases' theorem for (co)datatypes
desharna
parents: 57493
diff changeset
   346
val rel_casesN = relN ^ "_cases"
49592
b859a02c1150 fixed "rels" + split them into injectivity and distinctness
blanchet
parents: 49591
diff changeset
   347
val rel_injectN = relN ^ "_" ^ injectN
57493
554592fb795a generate 'rel_intros' theorem for (co)datatypes
desharna
parents: 57489
diff changeset
   348
val rel_introsN = relN ^ "_intros"
51918
3c152334f794 relator induction for datatypes
traytel
parents: 51893
diff changeset
   349
val rel_coinductN = relN ^ "_" ^ coinductN
57563
e3e7c86168b4 generate 'rel_sel' theorem for (co)datatypes
desharna
parents: 57529
diff changeset
   350
val rel_selN = relN ^ "_sel"
55901
8c6d49dd8ae1 renamed a pair of low-level theorems to have c/dtor in their names (like the others)
blanchet
parents: 55899
diff changeset
   351
val dtor_rel_coinductN = dtorN ^ "_" ^ rel_coinductN
51918
3c152334f794 relator induction for datatypes
traytel
parents: 51893
diff changeset
   352
val rel_inductN = relN ^ "_" ^ inductN
55901
8c6d49dd8ae1 renamed a pair of low-level theorems to have c/dtor in their names (like the others)
blanchet
parents: 55899
diff changeset
   353
val ctor_rel_inductN = ctorN ^ "_" ^ rel_inductN
49342
8ea4bad49ed5 rough and ready induction
blanchet
parents: 49338
diff changeset
   354
val selN = "sel"
57983
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
   355
val corec_selN = corecN ^ "_" ^ selN
49338
blanchet
parents: 49337
diff changeset
   356
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   357
fun co_prefix fp = case_fp fp "" "co";
51863
d77cf35c27ac tuning names
blanchet
parents: 51862
diff changeset
   358
49264
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   359
fun dest_sumT (Type (@{type_name sum}, [T, T'])) = (T, T');
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   360
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   361
val dest_sumTN_balanced = Balanced_Tree.dest dest_sumT;
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   362
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   363
fun dest_tupleT_balanced 0 @{typ unit} = []
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   364
  | dest_tupleT_balanced n T = Balanced_Tree.dest HOLogic.dest_prodT n T;
49264
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   365
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   366
fun dest_absumprodT absT repT n ms =
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   367
  map2 dest_tupleT_balanced ms o dest_sumTN_balanced n o mk_repT absT repT;
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   368
49264
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   369
val mk_sumTN = Library.foldr1 mk_sumT;
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   370
val mk_sumTN_balanced = Balanced_Tree.make mk_sumT;
49255
2ecc533d6697 use balanced sums for constructors (to gracefully handle 100 constructors or more)
blanchet
parents: 49240
diff changeset
   371
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   372
fun mk_tupleT_balanced [] = HOLogic.unitT
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   373
  | mk_tupleT_balanced Ts = Balanced_Tree.make HOLogic.mk_prodT Ts;
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   374
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   375
val mk_sumprodT_balanced = mk_sumTN_balanced o map mk_tupleT_balanced;
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   376
54923
ffed2452f5f6 instantiate schematics as projections to avoid HOU trouble
blanchet
parents: 54171
diff changeset
   377
fun mk_proj T n k =
ffed2452f5f6 instantiate schematics as projections to avoid HOU trouble
blanchet
parents: 54171
diff changeset
   378
  let val (binders, _) = strip_typeN n T in
ffed2452f5f6 instantiate schematics as projections to avoid HOU trouble
blanchet
parents: 54171
diff changeset
   379
    fold_rev (fn T => fn t => Abs (Name.uu, T, t)) binders (Bound (n - k - 1))
ffed2452f5f6 instantiate schematics as projections to avoid HOU trouble
blanchet
parents: 54171
diff changeset
   380
  end;
ffed2452f5f6 instantiate schematics as projections to avoid HOU trouble
blanchet
parents: 54171
diff changeset
   381
53032
traytel
parents: 52987
diff changeset
   382
fun mk_convol (f, g) =
traytel
parents: 52987
diff changeset
   383
  let
traytel
parents: 52987
diff changeset
   384
    val (fU, fTU) = `range_type (fastype_of f);
traytel
parents: 52987
diff changeset
   385
    val ((gT, gU), gTU) = `dest_funT (fastype_of g);
traytel
parents: 52987
diff changeset
   386
    val convolT = fTU --> gTU --> gT --> HOLogic.mk_prodT (fU, gU);
traytel
parents: 52987
diff changeset
   387
  in Const (@{const_name convol}, convolT) $ f $ g end;
49368
df359ce891ac added induct tactic
blanchet
parents: 49342
diff changeset
   388
58443
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   389
fun mk_rel_prod R S =
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   390
  let
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   391
    val ((A1, A2), RT) = `dest_pred2T (fastype_of R);
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   392
    val ((B1, B2), ST) = `dest_pred2T (fastype_of S);
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   393
    val rel_prodT = RT --> ST --> mk_pred2T (HOLogic.mk_prodT (A1, B1)) (HOLogic.mk_prodT (A2, B2));
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   394
  in Const (@{const_name rel_prod}, rel_prodT) $ R $ S end;
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   395
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   396
fun mk_rel_sum R S =
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   397
  let
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   398
    val ((A1, A2), RT) = `dest_pred2T (fastype_of R);
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   399
    val ((B1, B2), ST) = `dest_pred2T (fastype_of S);
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   400
    val rel_sumT = RT --> ST --> mk_pred2T (mk_sumT (A1, B1)) (mk_sumT (A2, B2));
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   401
  in Const (@{const_name rel_sum}, rel_sumT) $ R $ S end;
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   402
49121
9e0acaa470ab more work on FP sugar
blanchet
parents: 49119
diff changeset
   403
fun Inl_const LT RT = Const (@{const_name Inl}, LT --> mk_sumT (LT, RT));
49255
2ecc533d6697 use balanced sums for constructors (to gracefully handle 100 constructors or more)
blanchet
parents: 49240
diff changeset
   404
fun mk_Inl RT t = Inl_const (fastype_of t) RT $ t;
49121
9e0acaa470ab more work on FP sugar
blanchet
parents: 49119
diff changeset
   405
9e0acaa470ab more work on FP sugar
blanchet
parents: 49119
diff changeset
   406
fun Inr_const LT RT = Const (@{const_name Inr}, RT --> mk_sumT (LT, RT));
49255
2ecc533d6697 use balanced sums for constructors (to gracefully handle 100 constructors or more)
blanchet
parents: 49240
diff changeset
   407
fun mk_Inr LT t = Inr_const LT (fastype_of t) $ t;
49121
9e0acaa470ab more work on FP sugar
blanchet
parents: 49119
diff changeset
   408
55969
8820ddb8f9f4 use balanced tuples in 'primcorec'
blanchet
parents: 55968
diff changeset
   409
fun mk_prod1 bound_Ts (t, u) =
8820ddb8f9f4 use balanced tuples in 'primcorec'
blanchet
parents: 55968
diff changeset
   410
  HOLogic.pair_const (fastype_of1 (bound_Ts, t)) (fastype_of1 (bound_Ts, u)) $ t $ u;
8820ddb8f9f4 use balanced tuples in 'primcorec'
blanchet
parents: 55968
diff changeset
   411
8820ddb8f9f4 use balanced tuples in 'primcorec'
blanchet
parents: 55968
diff changeset
   412
fun mk_tuple1_balanced _ [] = HOLogic.unit
8820ddb8f9f4 use balanced tuples in 'primcorec'
blanchet
parents: 55968
diff changeset
   413
  | mk_tuple1_balanced bound_Ts ts = Balanced_Tree.make (mk_prod1 bound_Ts) ts;
8820ddb8f9f4 use balanced tuples in 'primcorec'
blanchet
parents: 55968
diff changeset
   414
8820ddb8f9f4 use balanced tuples in 'primcorec'
blanchet
parents: 55968
diff changeset
   415
val mk_tuple_balanced = mk_tuple1_balanced [];
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   416
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   417
fun mk_absumprod absT abs0 n k ts =
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   418
  let val abs = mk_abs absT abs0;
55968
blanchet
parents: 55966
diff changeset
   419
  in abs $ Sum_Tree.mk_inj (domain_type (fastype_of abs)) n k (mk_tuple_balanced ts) end;
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   420
55414
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   421
fun mk_case_sum (f, g) =
49129
b5413cb7d860 define "case" constant
blanchet
parents: 49128
diff changeset
   422
  let
55968
blanchet
parents: 55966
diff changeset
   423
    val (fT, T') = dest_funT (fastype_of f);
blanchet
parents: 55966
diff changeset
   424
    val (gT, _) = dest_funT (fastype_of g);
49129
b5413cb7d860 define "case" constant
blanchet
parents: 49128
diff changeset
   425
  in
55968
blanchet
parents: 55966
diff changeset
   426
    Sum_Tree.mk_sumcase fT gT T' f g
49129
b5413cb7d860 define "case" constant
blanchet
parents: 49128
diff changeset
   427
  end;
b5413cb7d860 define "case" constant
blanchet
parents: 49128
diff changeset
   428
55414
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   429
val mk_case_sumN = Library.foldr1 mk_case_sum;
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   430
val mk_case_sumN_balanced = Balanced_Tree.make mk_case_sum;
49176
6d29d2db5f88 construct high-level iterator RHS
blanchet
parents: 49169
diff changeset
   431
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   432
fun mk_tupled_fun f x xs =
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   433
  if xs = [x] then f else HOLogic.tupled_lambda x (Term.list_comb (f, xs));
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   434
55968
blanchet
parents: 55966
diff changeset
   435
fun mk_case_absumprod absT rep fs xss xss' =
58634
9f10d82e8188 added parameterized ML antiquotations @{map N}, @{fold N}, @{fold_map N}, @{split_list N};
wenzelm
parents: 58585
diff changeset
   436
  HOLogic.mk_comp (mk_case_sumN_balanced (@{map 3} mk_tupled_fun fs (map mk_tuple_balanced xss) xss'),
55968
blanchet
parents: 55966
diff changeset
   437
    mk_rep absT rep);
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   438
53202
2333fae25719 export one more ML function, needed for primcorec
blanchet
parents: 53143
diff changeset
   439
fun If_const T = Const (@{const_name If}, HOLogic.boolT --> T --> T --> T);
2333fae25719 export one more ML function, needed for primcorec
blanchet
parents: 53143
diff changeset
   440
fun mk_If p t f = let val T = fastype_of t in If_const T $ p $ t $ f end;
49275
ce87d6a901eb split sum types in corecursor definition
blanchet
parents: 49264
diff changeset
   441
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   442
fun mk_Field r =
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   443
  let val T = fst (dest_relT (fastype_of r));
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   444
  in Const (@{const_name Field}, mk_relT (T, T) --> HOLogic.mk_setT T) $ r end;
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   445
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   446
val mk_union = HOLogic.mk_binop @{const_name sup};
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   447
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   448
(*dangerous; use with monotonic, converging functions only!*)
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   449
fun fixpoint eq f X = if subset eq (f X, X) then X else fixpoint eq f (f X);
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   450
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   451
(* stolen from "~~/src/HOL/Tools/Datatype/datatype_aux.ML" *)
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   452
fun split_conj_thm th =
49119
1f605c36869c more work on FP sugar
blanchet
parents: 49075
diff changeset
   453
  ((th RS conjunct1) :: split_conj_thm (th RS conjunct2)) handle THM _ => [th];
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   454
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   455
fun split_conj_prems limit th =
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   456
  let
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   457
    fun split n i th =
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   458
      if i = n then th else split n (i + 1) (conjI RSN (i, th)) handle THM _ => th;
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   459
  in split limit 1 th end;
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   460
49335
096967bf3940 added sumEN_tupled_balanced
blanchet
parents: 49330
diff changeset
   461
fun mk_obj_sumEN_balanced n =
096967bf3940 added sumEN_tupled_balanced
blanchet
parents: 49330
diff changeset
   462
  Balanced_Tree.make (fn (thm1, thm2) => thm1 RSN (1, thm2 RSN (2, @{thm obj_sumE_f})))
096967bf3940 added sumEN_tupled_balanced
blanchet
parents: 49330
diff changeset
   463
    (replicate n asm_rl);
096967bf3940 added sumEN_tupled_balanced
blanchet
parents: 49330
diff changeset
   464
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   465
fun mk_tupled_allIN_balanced 0 = @{thm unit_all_impI}
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   466
  | mk_tupled_allIN_balanced n =
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   467
    let
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   468
      val (tfrees, _) = BNF_Util.mk_TFrees n @{context};
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   469
      val T = mk_tupleT_balanced tfrees;
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   470
    in
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   471
      @{thm asm_rl[of "ALL x. P x --> Q x" for P Q]}
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   472
      |> Drule.instantiate' [SOME (ctyp_of @{theory} T)] []
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   473
      |> Raw_Simplifier.rewrite_goals_rule @{context} @{thms split_paired_All[THEN eq_reflection]}
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   474
      |> (fn thm => impI RS funpow n (fn th => allI RS th) thm)
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   475
      |> Thm.varifyT_global
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   476
    end;
49335
096967bf3940 added sumEN_tupled_balanced
blanchet
parents: 49330
diff changeset
   477
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   478
fun mk_absumprodE type_definition ms =
49335
096967bf3940 added sumEN_tupled_balanced
blanchet
parents: 49330
diff changeset
   479
  let val n = length ms in
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   480
    mk_obj_sumEN_balanced n OF map mk_tupled_allIN_balanced ms RS
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   481
      (type_definition RS @{thm type_copy_obj_one_point_absE})
49335
096967bf3940 added sumEN_tupled_balanced
blanchet
parents: 49330
diff changeset
   482
  end;
49264
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   483
55414
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   484
fun mk_sum_caseN 1 1 = refl
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   485
  | mk_sum_caseN _ 1 = @{thm sum.case(1)}
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   486
  | mk_sum_caseN 2 2 = @{thm sum.case(2)}
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   487
  | mk_sum_caseN n k = trans OF [@{thm case_sum_step(2)}, mk_sum_caseN (n - 1) (k - 1)];
49264
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   488
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   489
fun mk_sum_step base step thm =
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   490
  if Thm.eq_thm_prop (thm, refl) then base else trans OF [step, thm];
9059e0dbdbc1 implemented and use "mk_sum_casesN_balanced"
blanchet
parents: 49255
diff changeset
   491
55414
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   492
fun mk_sum_caseN_balanced 1 1 = refl
eab03e9cee8a renamed '{prod,sum,bool,unit}_case' to 'case_...'
blanchet
parents: 55394
diff changeset
   493
  | mk_sum_caseN_balanced n k =
55642
63beb38e9258 adapted to renaming of datatype 'cases' and 'recs' to 'case' and 'rec'
blanchet
parents: 55575
diff changeset
   494
    Balanced_Tree.access {left = mk_sum_step @{thm sum.case(1)} @{thm case_sum_step(1)},
63beb38e9258 adapted to renaming of datatype 'cases' and 'recs' to 'case' and 'rec'
blanchet
parents: 55575
diff changeset
   495
      right = mk_sum_step @{thm sum.case(2)} @{thm case_sum_step(2)}, init = refl} n k;
49130
3c26e17b2849 implemented "mk_case_tac" -- and got rid of "cheat_tac"
blanchet
parents: 49129
diff changeset
   496
55851
3d40cf74726c optimize cardinal bounds involving natLeq (omega)
blanchet
parents: 55811
diff changeset
   497
fun mk_sum_Cinfinite [thm] = thm
3d40cf74726c optimize cardinal bounds involving natLeq (omega)
blanchet
parents: 55811
diff changeset
   498
  | mk_sum_Cinfinite (thm :: thms) = @{thm Cinfinite_csum_weak} OF [thm, mk_sum_Cinfinite thms];
3d40cf74726c optimize cardinal bounds involving natLeq (omega)
blanchet
parents: 55811
diff changeset
   499
3d40cf74726c optimize cardinal bounds involving natLeq (omega)
blanchet
parents: 55811
diff changeset
   500
fun mk_sum_card_order [thm] = thm
3d40cf74726c optimize cardinal bounds involving natLeq (omega)
blanchet
parents: 55811
diff changeset
   501
  | mk_sum_card_order (thm :: thms) = @{thm card_order_csum} OF [thm, mk_sum_card_order thms];
3d40cf74726c optimize cardinal bounds involving natLeq (omega)
blanchet
parents: 55811
diff changeset
   502
58579
b7bc5ba2f3fb rename 'rel_xtor_co_induct_thm' to 'xtor_rel_co_induct'
desharna
parents: 58578
diff changeset
   503
fun mk_xtor_rel_co_induct_thm fp pre_rels pre_phis rels phis xs ys xtors xtor's tac lthy =
52505
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   504
  let
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   505
    val pre_relphis = map (fn rel => Term.list_comb (rel, phis @ pre_phis)) pre_rels;
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   506
    val relphis = map (fn rel => Term.list_comb (rel, phis)) rels;
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   507
    fun mk_xtor fp' xtor x = if fp = fp' then xtor $ x else x;
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   508
    val dtor = mk_xtor Greatest_FP;
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   509
    val ctor = mk_xtor Least_FP;
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   510
    fun flip f x y = if fp = Greatest_FP then f y x else f x y;
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   511
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   512
    fun mk_prem pre_relphi phi x y xtor xtor' =
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   513
      HOLogic.mk_Trueprop (list_all_free [x, y] (flip (curry HOLogic.mk_imp)
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   514
        (pre_relphi $ (dtor xtor x) $ (dtor xtor' y)) (phi $ (ctor xtor x) $ (ctor xtor' y))));
58634
9f10d82e8188 added parameterized ML antiquotations @{map N}, @{fold N}, @{fold_map N}, @{split_list N};
wenzelm
parents: 58585
diff changeset
   515
    val prems = @{map 6} mk_prem pre_relphis pre_phis xs ys xtors xtor's;
52505
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   516
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   517
    val concl = HOLogic.mk_Trueprop (Library.foldr1 HOLogic.mk_conj
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   518
      (map2 (flip mk_leq) relphis pre_phis));
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   519
  in
52506
eb80a16a2b72 use long goal format in rel_induct theorem
traytel
parents: 52505
diff changeset
   520
    Goal.prove_sorry lthy (map (fst o dest_Free) (phis @ pre_phis)) prems concl tac
52505
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   521
    |> Thm.close_derivation
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   522
    |> (fn thm => thm OF (replicate (length pre_rels) @{thm allI[OF allI[OF impI]]}))
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   523
  end;
e62f3fd2035e share some code between codatatypes, datatypes and eventually prim(co)rec
traytel
parents: 52344
diff changeset
   524
58443
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   525
fun mk_co_iter_transfer_thms fp pre_rels pre_iphis pre_ophis rels phis un_folds un_folds' tac lthy =
52731
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   526
  let
58443
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   527
    val pre_relphis = map (fn rel => Term.list_comb (rel, phis @ pre_iphis)) pre_rels;
52731
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   528
    val relphis = map (fn rel => Term.list_comb (rel, phis)) rels;
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   529
    fun flip f x y = if fp = Greatest_FP then f y x else f x y;
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   530
58443
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   531
    val arg_rels = map2 (flip mk_rel_fun) pre_relphis pre_ophis;
52731
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   532
    fun mk_transfer relphi pre_phi un_fold un_fold' =
55945
e96383acecf9 renamed 'fun_rel' to 'rel_fun'
blanchet
parents: 55932
diff changeset
   533
      fold_rev mk_rel_fun arg_rels (flip mk_rel_fun relphi pre_phi) $ un_fold $ un_fold';
58634
9f10d82e8188 added parameterized ML antiquotations @{map N}, @{fold N}, @{fold_map N}, @{split_list N};
wenzelm
parents: 58585
diff changeset
   534
    val transfers = @{map 4} mk_transfer relphis pre_ophis un_folds un_folds';
52731
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   535
58443
a23780c22245 goal generation for xtor_co_rec_transfer
traytel
parents: 58439
diff changeset
   536
    val goal = fold_rev Logic.all (phis @ pre_ophis)
52731
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   537
      (HOLogic.mk_Trueprop (Library.foldr1 HOLogic.mk_conj transfers));
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   538
  in
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   539
    Goal.prove_sorry lthy [] [] goal tac
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   540
    |> Thm.close_derivation
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   541
    |> split_conj_thm
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   542
  end;
dacd47a0633f transfer rule for {c,d}tor_{,un}fold
traytel
parents: 52660
diff changeset
   543
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   544
fun mk_xtor_un_fold_o_map_thms fp is_rec m un_fold_unique xtor_maps xtor_un_folds sym_map_comps
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   545
    map_cong0s =
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   546
  let
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   547
    val n = length sym_map_comps;
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   548
    val rewrite_comp_comp2 = case_fp fp @{thm rewriteR_comp_comp2} @{thm rewriteL_comp_comp2};
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   549
    val rewrite_comp_comp = case_fp fp @{thm rewriteR_comp_comp} @{thm rewriteL_comp_comp};
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   550
    val map_cong_passive_args1 = replicate m (case_fp fp @{thm id_comp} @{thm comp_id} RS fun_cong);
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   551
    val map_cong_active_args1 = replicate n (if is_rec
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   552
      then case_fp fp @{thm convol_o} @{thm o_case_sum} RS fun_cong
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   553
      else refl);
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   554
    val map_cong_passive_args2 = replicate m (case_fp fp @{thm comp_id} @{thm id_comp} RS fun_cong);
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   555
    val map_cong_active_args2 = replicate n (if is_rec
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   556
      then case_fp fp @{thm map_prod_o_convol_id} @{thm case_sum_o_map_sum_id}
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   557
      else case_fp fp @{thm id_comp} @{thm comp_id} RS fun_cong);
55990
41c6b99c5fb7 more antiquotations;
wenzelm
parents: 55969
diff changeset
   558
    fun mk_map_congs passive active =
41c6b99c5fb7 more antiquotations;
wenzelm
parents: 55969
diff changeset
   559
      map (fn thm => thm OF (passive @ active) RS @{thm ext}) map_cong0s;
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   560
    val map_cong1s = mk_map_congs map_cong_passive_args1 map_cong_active_args1;
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   561
    val map_cong2s = mk_map_congs map_cong_passive_args2 map_cong_active_args2;
57489
8f0ba9f2d10f generate 'corec_code' theorem for codatatypes
desharna
parents: 57397
diff changeset
   562
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   563
    fun mk_rewrites map_congs = map2 (fn sym_map_comp => fn map_cong =>
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   564
      mk_trans sym_map_comp map_cong RS rewrite_comp_comp) sym_map_comps map_congs;
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   565
    val rewrite1s = mk_rewrites map_cong1s;
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   566
    val rewrite2s = mk_rewrites map_cong2s;
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   567
    val unique_prems =
58634
9f10d82e8188 added parameterized ML antiquotations @{map N}, @{fold N}, @{fold_map N}, @{split_list N};
wenzelm
parents: 58585
diff changeset
   568
      @{map 4} (fn xtor_map => fn un_fold => fn rewrite1 => fn rewrite2 =>
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   569
        mk_trans (rewrite_comp_comp2 OF [xtor_map, un_fold])
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   570
          (mk_trans rewrite1 (mk_sym rewrite2)))
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   571
      xtor_maps xtor_un_folds rewrite1s rewrite2s;
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   572
  in
55966
972f0aa7091b balance tuples that represent curried functions
blanchet
parents: 55945
diff changeset
   573
    split_conj_thm (un_fold_unique OF map (case_fp fp I mk_sym) unique_prems)
52913
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   574
  end;
2d2d9d1de1a9 theorems relating {c,d}tor_(un)fold/(co)rec and {c,d}tor_map
traytel
parents: 52899
diff changeset
   575
57983
6edc3529bb4e reordered some (co)datatype property names for more consistency
blanchet
parents: 57700
diff changeset
   576
fun mk_coinduct_strong_thm coind rel_eqs rel_monos mk_vimage2p ctxt =
53105
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   577
  let
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   578
    val n = Thm.nprems_of coind;
53106
d81211f61a1b moved derivation of strong coinduction to sugar
traytel
parents: 53105
diff changeset
   579
    val m = Thm.nprems_of (hd rel_monos) - n;
53105
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   580
    fun mk_inst phi = (phi, mk_union (phi, HOLogic.eq_const (fst (dest_pred2T (fastype_of phi)))))
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   581
      |> pairself (certify ctxt);
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   582
    val insts = Term.add_vars (Thm.prop_of coind) [] |> rev |> take n |> map (mk_inst o Var);
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   583
    fun mk_unfold rel_eq rel_mono =
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   584
      let
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   585
        val eq = iffD2 OF [rel_eq RS @{thm predicate2_eqD}, refl];
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   586
        val mono = rel_mono OF (replicate m @{thm order_refl} @ replicate n @{thm eq_subset});
57529
5e83df79eaa0 refactor some tactics
desharna
parents: 57525
diff changeset
   587
      in mk_vimage2p (eq RS (mono RS @{thm predicate2D})) RS eqTrueI end;
53105
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   588
    val unfolds = map2 mk_unfold rel_eqs rel_monos @ @{thms sup_fun_def sup_bool_def
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   589
      imp_disjL all_conj_distrib subst_eq_imp simp_thms(18,21,35)};
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   590
  in
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   591
    Thm.instantiate ([], insts) coind
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   592
    |> unfold_thms ctxt unfolds
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   593
  end;
ec38e9f4352f simpler (forward) derivation of strong (up-to equality) coinduction properties
traytel
parents: 53037
diff changeset
   594
55701
38f75365fc2a added explicit killing
blanchet
parents: 55642
diff changeset
   595
fun fp_bnf construct_fp bs resBs Ds0 fp_eqs lthy =
51868
4ab609682752 code tuning
blanchet
parents: 51867
diff changeset
   596
  let
53143
ba80154a1118 configuration option to control timing output for (co)datatypes
traytel
parents: 53138
diff changeset
   597
    val time = time lthy;
51868
4ab609682752 code tuning
blanchet
parents: 51867
diff changeset
   598
    val timer = time (Timer.startRealTimer ());
58332
be0f5d8d511b imported patch phantoms
blanchet
parents: 58284
diff changeset
   599
be0f5d8d511b imported patch phantoms
blanchet
parents: 58284
diff changeset
   600
    val nn = length fp_eqs;
53222
8b159677efb5 better error message
blanchet
parents: 53221
diff changeset
   601
    val (Xs, rhsXs) = split_list fp_eqs;
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   602
58332
be0f5d8d511b imported patch phantoms
blanchet
parents: 58284
diff changeset
   603
    fun flatten_tyargs Ass =
53222
8b159677efb5 better error message
blanchet
parents: 53221
diff changeset
   604
      subtract (op =) Xs (filter (fn T => exists (fn Ts => member (op =) Ts T) Ass) resBs) @ Xs;
51868
4ab609682752 code tuning
blanchet
parents: 51867
diff changeset
   605
53263
d4784d3d3a54 rationalized bindings
blanchet
parents: 53258
diff changeset
   606
    fun raw_qualify base_b =
53264
1973b821168c qualify generated constants uniformly
blanchet
parents: 53263
diff changeset
   607
      let val (_, qs, n) = Binding.dest base_b;
1973b821168c qualify generated constants uniformly
blanchet
parents: 53263
diff changeset
   608
      in
1973b821168c qualify generated constants uniformly
blanchet
parents: 53263
diff changeset
   609
        Binding.prefix_name rawN
1973b821168c qualify generated constants uniformly
blanchet
parents: 53263
diff changeset
   610
        #> fold_rev (fn (s, mand) => Binding.qualify mand s) (qs @ [(n, true)])
53566
5ff3a2d112d7 conceal internal bindings
traytel
parents: 53264
diff changeset
   611
        #> Binding.conceal
53264
1973b821168c qualify generated constants uniformly
blanchet
parents: 53263
diff changeset
   612
      end;
51868
4ab609682752 code tuning
blanchet
parents: 51867
diff changeset
   613
55904
0ef30d52c5e4 more caching in composition pipeline
blanchet
parents: 55901
diff changeset
   614
    val ((bnfs, (deadss, livess)), accum) =
55706
064c7c249f55 added BNF cache (within one definition)
blanchet
parents: 55703
diff changeset
   615
      apfst (apsnd split_list o split_list)
58634
9f10d82e8188 added parameterized ML antiquotations @{map N}, @{fold N}, @{fold_map N}, @{split_list N};
wenzelm
parents: 58585
diff changeset
   616
        (@{fold_map 2}
9f10d82e8188 added parameterized ML antiquotations @{map N}, @{fold N}, @{fold_map N}, @{split_list N};
wenzelm
parents: 58585
diff changeset
   617
          (fn b => bnf_of_typ Smart_Inline (raw_qualify b) flatten_tyargs Xs Ds0) bs rhsXs
55706
064c7c249f55 added BNF cache (within one definition)
blanchet
parents: 55703
diff changeset
   618
          ((empty_comp_cache, empty_unfolds), lthy));
51868
4ab609682752 code tuning
blanchet
parents: 51867
diff changeset
   619
53566
5ff3a2d112d7 conceal internal bindings
traytel
parents: 53264
diff changeset
   620
    fun norm_qualify i = Binding.qualify true (Binding.name_of (nth bs (Int.max (0, i - 1))))
5ff3a2d112d7 conceal internal bindings
traytel
parents: 53264
diff changeset
   621
      #> Binding.conceal;
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   622
49132
81487fc17185 added robustness
blanchet
parents: 49130
diff changeset
   623
    val Ass = map (map dest_TFree) livess;
58332
be0f5d8d511b imported patch phantoms
blanchet
parents: 58284
diff changeset
   624
    val Ds' = fold (fold Term.add_tfreesT) deadss [];
be0f5d8d511b imported patch phantoms
blanchet
parents: 58284
diff changeset
   625
    val Ds = union (op =) Ds' Ds0;
be0f5d8d511b imported patch phantoms
blanchet
parents: 58284
diff changeset
   626
    val missing = resBs |> fold (subtract (op =)) (Ds' :: Ass);
be0f5d8d511b imported patch phantoms
blanchet
parents: 58284
diff changeset
   627
    val (dead_phantoms, live_phantoms) = List.partition (member (op =) Ds0) missing;
be0f5d8d511b imported patch phantoms
blanchet
parents: 58284
diff changeset
   628
    val resBs' = resBs |> fold (subtract (op =)) [dead_phantoms, Ds];
49132
81487fc17185 added robustness
blanchet
parents: 49130
diff changeset
   629
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   630
    val timer = time (timer "Construction of BNFs");
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   631
55904
0ef30d52c5e4 more caching in composition pipeline
blanchet
parents: 55901
diff changeset
   632
    val ((kill_poss, _), (bnfs', ((_, unfold_set'), lthy'))) =
58332
be0f5d8d511b imported patch phantoms
blanchet
parents: 58284
diff changeset
   633
      normalize_bnfs norm_qualify Ass Ds (K (resBs' @ Xs)) bnfs accum;
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   634
58634
9f10d82e8188 added parameterized ML antiquotations @{map N}, @{fold N}, @{fold_map N}, @{split_list N};
wenzelm
parents: 58585
diff changeset
   635
    val Dss = @{map 3} (uncurry append oo curry swap oo map o nth) livess kill_poss deadss;
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   636
53566
5ff3a2d112d7 conceal internal bindings
traytel
parents: 53264
diff changeset
   637
    fun pre_qualify b = Binding.qualify false (Binding.name_of b)
58208
blanchet
parents: 58180
diff changeset
   638
      #> not (Config.get lthy' bnf_note_all) ? Binding.conceal;
53264
1973b821168c qualify generated constants uniformly
blanchet
parents: 53263
diff changeset
   639
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   640
    val ((pre_bnfs, (deadss, absT_infos)), lthy'') =
58634
9f10d82e8188 added parameterized ML antiquotations @{map N}, @{fold N}, @{fold_map N}, @{split_list N};
wenzelm
parents: 58585
diff changeset
   641
      @{fold_map 4} (fn b => seal_bnf (pre_qualify b) unfold_set' (Binding.prefix_name preN b))
58332
be0f5d8d511b imported patch phantoms
blanchet
parents: 58284
diff changeset
   642
        bs (not (null live_phantoms) :: replicate (nn - 1) false) Dss bnfs' lthy'
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   643
      |>> split_list
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   644
      |>> apsnd split_list;
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   645
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   646
    val timer = time (timer "Normalization & sealing of BNFs");
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   647
58332
be0f5d8d511b imported patch phantoms
blanchet
parents: 58284
diff changeset
   648
    val res = construct_fp bs resBs (map TFree dead_phantoms, deadss) pre_bnfs absT_infos lthy'';
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   649
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   650
    val timer = time (timer "FP construction in total");
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   651
  in
55803
74d3fe9031d8 joint work with blanchet: intermediate typedef for the input to fp-operations
traytel
parents: 55706
diff changeset
   652
    timer; ((pre_bnfs, absT_infos), res)
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   653
  end;
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   654
58256
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   655
fun fp_antiquote_setup binding =
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   656
  Thy_Output.antiquotation binding (Args.type_name {proper = true, strict = true})
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   657
    (fn {source = src, context = ctxt, ...} => fn fcT_name =>
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   658
       (case Ctr_Sugar.ctr_sugar_of ctxt fcT_name of
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   659
         NONE => error ("Not a known freely generated type name: " ^ quote fcT_name)
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   660
       | SOME {T = T0, ctrs = ctrs0, ...} =>
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   661
         let
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   662
           val freezeT = Term.map_atyps (fn TVar ((s, _), S) => TFree (s, S) | T => T);
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   663
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   664
           val T = freezeT T0;
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   665
           val ctrs = map (Term.map_types freezeT) ctrs0;
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   666
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   667
           val pretty_typ_bracket = Syntax.pretty_typ (Config.put pretty_priority 1001 ctxt);
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   668
           fun pretty_ctr ctr =
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   669
             Pretty.block (Pretty.breaks (Syntax.pretty_term ctxt ctr ::
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   670
               map pretty_typ_bracket (binder_types (fastype_of ctr))));
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   671
           val pretty_co_datatype =
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   672
             Pretty.block (Pretty.keyword1 (Binding.name_of binding) :: Pretty.brk 1 ::
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   673
               Syntax.pretty_typ ctxt T :: Pretty.str " =" :: Pretty.brk 1 ::
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   674
               flat (separate [Pretty.brk 1, Pretty.str "| "] (map (single o pretty_ctr) ctrs)));
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   675
         in
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   676
           Thy_Output.output ctxt
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   677
             (Thy_Output.maybe_pretty_source (K (K pretty_co_datatype)) ctxt src [()])
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   678
         end));
08c0f0d4b9f4 generalized 'datatype' LaTeX antiquotation and added 'codatatype'
blanchet
parents: 58208
diff changeset
   679
48975
7f79f94a432c added new (co)datatype package + theories of ordinals and cardinals (with Dmitriy and Andrei)
blanchet
parents:
diff changeset
   680
end;