-requires="helm-urimanager helm-pxp"
+requires="helm-urimanager helm-pxp helm-xml"
version="0.0.1"
archive(byte)="cic.cma"
archive(native)="cic.cmxa"
PACKAGE = cic
-REQUIRES = helm-urimanager helm-pxp
+REQUIRES = helm-urimanager helm-pxp helm-xml
PREDICATES =
INTERFACE_FILES = \
* http://cs.unibo.it/helm/.
*)
-(******************************************************************************)
-(* *)
-(* PROJECT HELM *)
-(* *)
-(* Enrico Tassi <tassi@cs.unibo.it> *)
-(* 23/04/2004 *)
-(* *)
-(* This module implements the aciclic graph of universes. *)
-(* *)
-(******************************************************************************)
+(*****************************************************************************)
+(* *)
+(* PROJECT HELM *)
+(* *)
+(* Enrico Tassi <tassi@cs.unibo.it> *)
+(* 23/04/2004 *)
+(* *)
+(* This module implements the aciclic graph of universes. *)
+(* *)
+(*****************************************************************************)
+
+(*****************************************************************************)
+(** switch implementation **)
+(*****************************************************************************)
+
+let fast_implementation = ref false ;;
+
+(*****************************************************************************)
+(** open **)
+(*****************************************************************************)
open Printf
-(******************************************************************************)
-(** Types and default values **)
-(******************************************************************************)
-
-type universe = int
+(*****************************************************************************)
+(** Types and default values **)
+(*****************************************************************************)
+type universe = int * UriManager.uri option
+
module UniverseType = struct
type t = universe
let compare = Pervasives.compare
end
-
+
module SOF = Set.Make(UniverseType)
-
+
type entry = {
- eq_closure : SOF.t;
- ge_closure : SOF.t;
- gt_closure : SOF.t;
- in_eq_of : SOF.t;
- in_ge_of : SOF.t;
- in_gt_of : SOF.t;
- one_s_eq : SOF.t;
- one_s_ge : SOF.t;
- one_s_gt : SOF.t;
+ eq_closure : SOF.t;
+ ge_closure : SOF.t;
+ gt_closure : SOF.t;
+ in_gegt_of : SOF.t;
+ one_s_eq : SOF.t;
+ one_s_ge : SOF.t;
+ one_s_gt : SOF.t;
}
-
+
module MAL = Map.Make(UniverseType)
-
+
type arc_type = GE | GT | EQ
-
-type arc = arc_type * universe * universe
-
-type bag = entry MAL.t * (arc list)
-
+
+type bag = entry MAL.t
+
let empty_entry = {
- eq_closure=SOF.empty;
- ge_closure=SOF.empty;
- gt_closure=SOF.empty;
- in_eq_of=SOF.empty;
- in_ge_of=SOF.empty;
- in_gt_of=SOF.empty;
- one_s_eq=SOF.empty;
- one_s_ge=SOF.empty;
- one_s_gt=SOF.empty;
+ eq_closure=SOF.empty;
+ ge_closure=SOF.empty;
+ gt_closure=SOF.empty;
+ in_gegt_of=SOF.empty;
+ one_s_eq=SOF.empty;
+ one_s_ge=SOF.empty;
+ one_s_gt=SOF.empty;
}
+let empty_bag = MAL.empty
-let empty_bag = (MAL.empty, [])
+let are_set_eq s1 s2 =
+ SOF.equal s1 s2
-let env_bag = ref empty_bag
+let are_entry_eq v1 v2 =
+ (are_set_eq v1.gt_closure v2.gt_closure ) &&
+ (are_set_eq v1.ge_closure v2.ge_closure ) &&
+ (are_set_eq v1.eq_closure v2.eq_closure ) &&
+ (*(are_set_eq v1.in_gegt_of v2.in_gegt_of ) &&*)
+ (are_set_eq v1.one_s_ge v2.one_s_ge ) &&
+ (are_set_eq v1.one_s_gt v2.one_s_gt ) &&
+ (are_set_eq v1.one_s_eq v2.one_s_eq )
-(******************************************************************************)
-(** Pretty printings **)
-(******************************************************************************)
-let string_of_universe u = string_of_int u
-
-let string_of_arc_type u =
+(* ocaml 3.07 doesn't have MAP.equal, 3.08 has it! *)
+(*
+ let are_ugraph_eq308 g h =
+ MAL.equal are_entry_eq g h
+*)
+let are_ugraph_eq307 g h =
+ try
+ MAL.fold (
+ fun k v b ->
+ if not b then
+ raise (Failure "Different")
+ else
+ try
+ let k_h = MAL.find k h in
+ are_entry_eq v k_h
+ with Not_found -> true
+ ) g true
+ with
+ Failure "Different" -> false
+
+let are_ugraph_eq = are_ugraph_eq307
+
+(*****************************************************************************)
+(** Pretty printings **)
+(*****************************************************************************)
+
+let string_of_universe (i,u) =
match u with
- EQ -> "EQ"
- | GT -> "GT"
- | GE -> "EQ"
-
-let string_of_arc u =
- let atype,a,b = u in
- (string_of_arc_type atype) ^ " " ^
- (string_of_universe a) ^ " " ^ (string_of_universe b) ^ "; "
-;;
+ Some u ->
+ ((string_of_int i) ^ " " ^ (UriManager.string_of_uri u))
+ | None -> (string_of_int i)
let string_of_universe_set l =
SOF.fold (fun x s -> s ^ (string_of_universe x) ^ " ") l ""
-let string_of_arc_list l =
- List.fold_left (fun s x -> s ^ (string_of_arc x) ^ " ") "" l
-
let string_of_node n =
"{"^
"eq_c: " ^ (string_of_universe_set n.eq_closure) ^ "; " ^
"ge_c: " ^ (string_of_universe_set n.ge_closure) ^ "; " ^
"gt_c: " ^ (string_of_universe_set n.gt_closure) ^ "; " ^
- "i_eq: " ^ (string_of_universe_set n.in_eq_of) ^ "; " ^
- "i_ge: " ^ (string_of_universe_set n.in_ge_of) ^ "; " ^
- "i_gt: " ^ (string_of_universe_set n.in_gt_of) ^ "}\n"
+ "i_gegt: " ^ (string_of_universe_set n.in_gegt_of) ^ "}\n"
+
+let string_of_arc (a,u,v) =
+ "(" ^ (string_of_universe u) ^ " " ^ a ^ " " ^ (string_of_universe v) ^ ")"
let string_of_mal m =
let rc = ref "" in
- MAL.iter (fun k v -> rc := !rc ^ sprintf "%d --> %s" k (string_of_node v)) m;
+ MAL.iter (fun k v ->
+ rc := !rc ^ sprintf "%s --> %s" (string_of_universe k)
+ (string_of_node v)) m;
!rc
let string_of_bag b =
- let (m,l) = b in
- let s_m = string_of_mal m in
- let s_l = string_of_arc_list l in
- s_m ^"["^s_l^"]"
+ string_of_mal b
-(******************************************************************************)
-(** Helpers **)
-(******************************************************************************)
+(*****************************************************************************)
+(** Helpers **)
+(*****************************************************************************)
-(*
- we need to merge the 2 graphs... here the code
-*)
+(* find the repr *)
let repr u m =
try
MAL.find u m
with
- Not_found ->
- try
- let m',_ = !env_bag in
- MAL.find u m'
- with
- Not_found -> empty_entry
+ Not_found -> empty_entry
-(*
- FIXME: May be faster if we make it by hand
-*)
+(* FIXME: May be faster if we make it by hand *)
let merge_closures f nodes m =
SOF.fold (fun x i -> SOF.union (f (repr x m)) i ) nodes SOF.empty
-(******************************************************************************)
-(** Real stuff GT **)
-(******************************************************************************)
+(*****************************************************************************)
+(** Benchmarking **)
+(*****************************************************************************)
+let time_spent = ref 0.0;;
+let partial = ref 0.0 ;;
+
+let reset_spent_time () = time_spent := 0.0;;
+let get_spent_time () = !time_spent ;;
+let begin_spending () =
+ assert (!partial = 0.0);
+ partial := Unix.gettimeofday ()
+;;
-(*
- todo is the SOF of nodes that needs to be recomputed,
- m is the MAL map, s is the already touched nodes
-*)
-let rec redo_gt_closure todo m s =
- if SOF.is_empty todo then m
- else
- begin
- (* we choose the node to recompute *)
- let u = SOF.choose todo in
- if not (SOF.mem u s) then
- let ru = repr u m in
- let ru' = {ru with gt_closure =
- (* the new gt closure is the gt-closures + ge-closures + eq-closures
- of the one step gt-connected nodes *)
- SOF.union ru.one_s_gt (merge_closures
- (fun x -> SOF.union x.eq_closure
- (SOF.union x.gt_closure x.ge_closure)) ru.one_s_gt m) } in
- let m' = MAL.add u ru' m in
- let s' = SOF.add u s in
- redo_gt_closure (SOF.union (SOF.remove u todo) ru'.in_gt_of) m' s'
+let end_spending () =
+ assert (!partial > 0.0);
+ let interval = (Unix.gettimeofday ()) -. !partial in
+ partial := 0.0;
+ time_spent := !time_spent +. interval
+;;
+
+\f
+(*****************************************************************************)
+(** _fats implementation **)
+(*****************************************************************************)
+
+let rec closure_of_fast ru m =
+ let eq_c = closure_eq_fast ru m in
+ let ge_c = closure_ge_fast ru m in
+ let gt_c = closure_gt_fast ru m in
+ {
+ eq_closure = eq_c;
+ ge_closure = ge_c;
+ gt_closure = gt_c;
+ in_gegt_of = ru.in_gegt_of;
+ one_s_eq = ru.one_s_eq;
+ one_s_ge = ru.one_s_ge;
+ one_s_gt = ru.one_s_gt
+ }
+
+and closure_eq_fast ru m =
+ let eq_c =
+ let j = ru.one_s_eq in
+ let _Uj = merge_closures (fun x -> x.eq_closure) j m in
+ let one_step_eq = ru.one_s_eq in
+ (SOF.union one_step_eq _Uj)
+ in
+ eq_c
+
+and closure_ge_fast ru m =
+ let ge_c =
+ let j = SOF.union ru.one_s_ge (SOF.union ru.one_s_gt ru.one_s_eq) in
+ let _Uj = merge_closures (fun x -> x.ge_closure) j m in
+ let _Ux = j in
+ (SOF.union _Uj _Ux)
+ in
+ ge_c
+
+and closure_gt_fast ru m =
+ let gt_c =
+ let j = ru.one_s_gt in
+ let k = ru.one_s_ge in
+ let l = ru.one_s_eq in
+ let _Uj = merge_closures (fun x -> x.ge_closure) j m in
+ let _Uk = merge_closures (fun x -> x.gt_closure) k m in
+ let _Ul = merge_closures (fun x -> x.gt_closure) l m in
+ let one_step_gt = ru.one_s_gt in
+ (SOF.union (SOF.union (SOF.union _Ul one_step_gt) _Uk) _Uj)
+ in
+ gt_c
+
+and print_rec_status u ru =
+ print_endline ("Aggiusto " ^ (string_of_universe u) ^
+ "e ottengo questa chiusura\n " ^ (string_of_node ru))
+
+and adjust_fast u m =
+ let ru = repr u m in
+ let gt_c = closure_gt_fast ru m in
+ let ge_c = closure_ge_fast ru m in
+ let eq_c = closure_eq_fast ru m in
+ let changed_eq = not (are_set_eq eq_c ru.eq_closure) in
+ let changed_gegt =
+ (not (are_set_eq gt_c ru.gt_closure)) ||
+ (not (are_set_eq ge_c ru.ge_closure))
+ in
+ if ((not changed_gegt) && (not changed_eq)) then
+ m
else
- (* if already done go next. FIXME: think if it is right
- maybe we should check if we changed something or not *)
- redo_gt_closure (SOF.remove u todo) m s
- end
+ begin
+ let ru' = {
+ eq_closure = eq_c;
+ ge_closure = ge_c;
+ gt_closure = gt_c;
+ in_gegt_of = ru.in_gegt_of;
+ one_s_eq = ru.one_s_eq;
+ one_s_ge = ru.one_s_ge;
+ one_s_gt = ru.one_s_gt}
+ in
+ let m = MAL.add u ru' m in
+ let m =
+ SOF.fold (fun x m -> adjust_fast x m)
+ (SOF.union ru'.eq_closure ru'.in_gegt_of) m
+ (* TESI:
+ ru'.in_gegt_of m
+ *)
+ in
+ m (*adjust_fast u m*)
+ end
+
+and add_gt_arc_fast u v m =
+ let ru = repr u m in
+ let ru' = {ru with one_s_gt = SOF.add v ru.one_s_gt} in
+ let m' = MAL.add u ru' m in
+ let rv = repr v m' in
+ let rv' = {rv with in_gegt_of = SOF.add u rv.in_gegt_of} in
+ let m'' = MAL.add v rv' m' in
+ adjust_fast u m''
+
+and add_ge_arc_fast u v m =
+ let ru = repr u m in
+ let ru' = { ru with one_s_ge = SOF.add v ru.one_s_ge} in
+ let m' = MAL.add u ru' m in
+ let rv = repr v m' in
+ let rv' = {rv with in_gegt_of = SOF.add u rv.in_gegt_of} in
+ let m'' = MAL.add v rv' m' in
+ adjust_fast u m''
-(*
- calculates the closures of u and adjusts the in_*_of of v, then
- starts redo_*_closure to adjust the colure of nodew thet have
- (clusure u) in theyr closures
-*)
-let add_gt_arc u v m =
+and add_eq_arc_fast u v m =
let ru = repr u m in
let rv = repr v m in
- let ru' = {
- (* new node: we add the v gt-closure and v to our gt-closure *)
- eq_closure = ru.eq_closure;
- ge_closure = ru.ge_closure;
- gt_closure = SOF.add v
- (SOF.union ru.gt_closure
- (SOF.union rv.ge_closure
- (SOF.union rv.eq_closure rv.gt_closure)));
- in_eq_of = ru.in_eq_of;
- in_ge_of = ru.in_ge_of;
- in_gt_of = ru.in_gt_of;
- one_s_eq = ru.one_s_eq;
- one_s_ge = ru.one_s_ge;
- one_s_gt = SOF.add v ru.one_s_gt;
- } in
- (* may add the sanity check *)
- let rv' = { rv with in_gt_of = SOF.add u rv.in_gt_of } in
+ let ru' = {ru with one_s_eq = SOF.add v ru.one_s_eq} in
+ (*TESI: let ru' = {ru' with in_gegt_of = SOF.add v ru.in_gegt_of} in *)
let m' = MAL.add u ru' m in
+ let rv' = {rv with one_s_eq = SOF.add u rv.one_s_eq} in
+ (*TESI: let rv' = {rv' with in_gegt_of = SOF.add u rv.in_gegt_of} in *)
let m'' = MAL.add v rv' m' in
- redo_gt_closure ru'.in_gt_of m'' SOF.empty
-
-(*
- given the 2 nodes plus the current bag, adds the arc, recomputes the
- closures and returns the new map
-*)
-let add_gt u v b =
- let m,l = b in
- let m' = add_gt_arc u v m in
- let l' = (GT,u,v)::l in
- (m',l')
+ adjust_fast v (*(adjust_fast u*) m'' (* ) *)
+;;
-(******************************************************************************)
-(** Real stuff GE **)
-(******************************************************************************)
+\f
+(*****************************************************************************)
+(** safe implementation **)
+(*****************************************************************************)
-(*
- todo is the SOF of nodes that needs to be recomputed,
- m is the MAL map, s is the already touched nodes
-*)
-let rec redo_ge_closure todo m s =
- if SOF.is_empty todo then m,s
- else
- begin
- let u = SOF.choose todo in
- if not (SOF.mem u s) then
- begin
- let ru = repr u m in
- (* the ge-closure is recomputed as the ge-closures of
- ge connected nodes plus theys eq-closure *)
- let ru' = {ru with ge_closure = merge_closures
- (fun x -> SOF.union x.eq_closure x.ge_closure) ru.one_s_ge m } in
- let m' = MAL.add u ru' m in
- let s' = SOF.add u s in
- redo_ge_closure (SOF.union (SOF.remove u todo) ru'.in_ge_of) m' s'
- end
+let closure_of u m =
+ let ru = repr u m in
+ let eq_c =
+ let j = ru.one_s_eq in
+ let _Uj = merge_closures (fun x -> x.eq_closure) j m in
+ let one_step_eq = ru.one_s_eq in
+ (SOF.union one_step_eq _Uj)
+ in
+ let ge_c =
+ let j = SOF.union ru.one_s_ge (SOF.union ru.one_s_gt ru.one_s_eq) in
+ let _Uj = merge_closures (fun x -> x.ge_closure) j m in
+ let _Ux = j in
+ (SOF.union _Uj _Ux)
+ in
+ let gt_c =
+ let j = ru.one_s_gt in
+ let k = ru.one_s_ge in
+ let l = ru.one_s_eq in
+ let _Uj = merge_closures (fun x -> x.ge_closure) j m in
+ let _Uk = merge_closures (fun x -> x.gt_closure) k m in
+ let _Ul = merge_closures (fun x -> x.gt_closure) l m in
+ let one_step_gt = ru.one_s_gt in
+ (SOF.union (SOF.union (SOF.union _Ul one_step_gt) _Uk) _Uj)
+ in
+ {
+ eq_closure = eq_c;
+ ge_closure = ge_c;
+ gt_closure = gt_c;
+ in_gegt_of = ru.in_gegt_of;
+ one_s_eq = ru.one_s_eq;
+ one_s_ge = ru.one_s_ge;
+ one_s_gt = ru.one_s_gt
+ }
+
+let rec simple_adjust m =
+ let m' =
+ MAL.mapi (fun x _ -> closure_of x m) m
+ in
+ if not (are_ugraph_eq m m') then(
+ simple_adjust m')
else
- redo_ge_closure (SOF.remove u todo) m s
- end
+ m'
-(*
- calculates the closures of u and adjusts the in_*_of of v, then
- starts redo_*_closure to adjust the colure of nodew thet have
- (clusure u) in theyr closures
-*)
-let add_ge_arc u v m =
+let add_eq_arc u v m =
let ru = repr u m in
- let rv = repr v m in
- let ru' = {
- eq_closure = ru.eq_closure;
- ge_closure = SOF.add v
- (SOF.union ru.ge_closure
- (SOF.union rv.eq_closure rv.ge_closure));
- gt_closure = ru.gt_closure;
- in_eq_of = ru.in_eq_of;
- in_ge_of = ru.in_ge_of;
- in_gt_of = ru.in_gt_of;
- one_s_eq = ru.one_s_eq;
- one_s_ge = SOF.add v ru.one_s_ge;
- one_s_gt = ru.one_s_gt;
- } in
- let rv' = { rv with in_gt_of = SOF.add u rv.in_ge_of } in
+ let rv = repr v m in
+ let ru' = {ru with one_s_eq = SOF.add v ru.one_s_eq} in
let m' = MAL.add u ru' m in
+ let rv' = {rv with one_s_eq = SOF.add u rv.one_s_eq} in
let m'' = MAL.add v rv' m' in
- let m''',td = redo_ge_closure ru'.in_ge_of m'' SOF.empty in
- (* closing ge may provoke aome changes in gt-closures *)
- redo_gt_closure (SOF.union ru'.in_gt_of
- (SOF.fold (fun u s -> SOF.union s ((repr u m''').in_gt_of))
- td SOF.empty )) m''' SOF.empty
+ simple_adjust m''
+
+let add_ge_arc u v m =
+ let ru = repr u m in
+ let ru' = { ru with one_s_ge = SOF.add v ru.one_s_ge} in
+ let m' = MAL.add u ru' m in
+ simple_adjust m'
+
+let add_gt_arc u v m =
+ let ru = repr u m in
+ let ru' = {ru with one_s_gt = SOF.add v ru.one_s_gt} in
+ let m' = MAL.add u ru' m in
+ simple_adjust m'
+
+\f
+(*****************************************************************************)
+(** Outhern interface, that chooses between _fast and safe **)
+(*****************************************************************************)
(*
given the 2 nodes plus the current bag, adds the arc, recomputes the
closures and returns the new map
*)
-let add_ge u v b =
- let m,l = b in
- let m' = add_ge_arc u v m in
- let l' = (GE,u,v)::l in
- (m',l')
-
-(******************************************************************************)
-(** Real stuff EQ **)
-(******************************************************************************)
-
-let rec redo_eq_closure todo m s =
- if SOF.is_empty todo then m,s
- else begin
- let u = SOF.choose todo in
- if not (SOF.mem u s) then
- begin
- let ru = repr u m in
- let eq_closure = merge_closures
- (fun x -> x.eq_closure) ru.one_s_eq m in
- let ru' = {ru with eq_closure = eq_closure
- ; in_eq_of = eq_closure ; one_s_eq = eq_closure } in
- let m' = MAL.add u ru' m in
- let s' = SOF.add u s in
- redo_eq_closure (SOF.union (SOF.remove u todo) ru'.in_eq_of) m' s'
- end
- else
- redo_eq_closure (SOF.remove u todo) m s
- end
-
-(*
- calculates the closures of u and adjusts the in_*_of of v, then
- starts redo_*_closure to adjust the colure of nodew thet have
- (clusure u) in theyr closures
-*)
-let add_eq_arc u v m =
- let ru = repr u m in
- let rv = repr v m in
- (* since eq is symmetric we have to chage more *)
- let eq_closure = SOF.add u (SOF.add v
- (SOF.union ru.eq_closure rv.eq_closure)) in
- let ru' = {
- eq_closure = eq_closure;
- ge_closure = SOF.union ru.ge_closure rv.ge_closure;
- gt_closure = SOF.union ru.gt_closure rv.gt_closure;
- in_eq_of = eq_closure;
- in_ge_of = SOF.union ru.in_ge_of rv.in_ge_of;
- in_gt_of = SOF.union ru.in_gt_of rv.in_gt_of;
- one_s_eq = eq_closure;
- one_s_ge = SOF.union ru.one_s_ge rv.one_s_ge;
- one_s_gt = SOF.union ru.one_s_gt rv.one_s_gt;
- } in
- (* this is a collapse *)
- let rv' = ru' in
- let m' = MAL.add u ru' m in
- let m'' = MAL.add v rv' m' in
- let m''',td = redo_eq_closure ru'.in_eq_of m'' SOF.empty in
- (* redoing a eq may change some ge and some gt *)
- let m'''',td' = redo_ge_closure
- (SOF.union ru'.in_ge_of
- (SOF.fold (fun u s -> SOF.union s ((repr u m''').in_ge_of))
- td SOF.empty)) m''' SOF.empty in
- redo_gt_closure (SOF.union ru'.in_gt_of
- (SOF.fold (fun u s -> SOF.union s ((repr u m'''').in_gt_of))
- td' SOF.empty)) m'''' SOF.empty
+let add_eq fast u v b =
+ if fast then
+ add_eq_arc_fast u v b
+ else
+ add_eq_arc u v b
(*
given the 2 nodes plus the current bag, adds the arc, recomputes the
closures and returns the new map
*)
-let add_eq u v b =
- let m,l = b in
- let m' = add_eq_arc u v m in
- let l' = (EQ,u,v)::l in
- (m',l')
+let add_ge fast u v b =
+ if fast then
+ add_ge_arc_fast u v b
+ else
+ add_ge_arc u v b
+(*
+ given the 2 nodes plus the current bag, adds the arc, recomputes the
+ closures and returns the new map
+*)
+let add_gt fast u v b =
+ if fast then
+ add_gt_arc_fast u v b
+ else
+ add_gt_arc u v b
+
-(******************************************************************************)
-(** Oyther real code **)
-(******************************************************************************)
+(*****************************************************************************)
+(** Other real code **)
+(*****************************************************************************)
exception UniverseInconsistency of string
let error arc node1 closure_type node2 closure =
- let s = " ===== Universe Inconsistency detected =====\n\n" ^
- "\tUnable to add ("^ (string_of_arc arc) ^ ") cause " ^
+ let s = "\n ===== Universe Inconsistency detected =====\n\n" ^
+ "\tUnable to add "^ (string_of_arc arc) ^ " cause " ^
(string_of_universe node1) ^ " is in the " ^
- (string_of_arc_type closure_type) ^ " closure {" ^
+ closure_type ^ " closure {" ^
(string_of_universe_set closure) ^ "} of " ^
(string_of_universe node2) ^ "\n\n" ^
" ===== Universe Inconsistency detected =====\n" in
prerr_endline s;
raise (UniverseInconsistency s)
-(*
- we merge the env_bag with b
-*)
-let qed b =
- let m,l = b in
- let m',l' = !env_bag in
- let m'' = ref m' in
- MAL.iter (fun k v -> m'':= MAL.add k v !m'') m;
- let l'' = l @ l' in
- env_bag := (!m'',l'')
-
-let add_eq u v b =
+
+let fill_empty_nodes_with_uri g uri =
+ let fill_empty_universe u =
+ match u with
+ (i,None) -> (i,Some uri)
+ | (i,Some _) as u -> u
+ in
+ let fill_empty_set s =
+ SOF.fold (fun e s -> SOF.add (fill_empty_universe e) s) s SOF.empty
+ in
+ let fill_empty_entry e = {
+ eq_closure = (fill_empty_set e.eq_closure) ;
+ ge_closure = (fill_empty_set e.ge_closure) ;
+ gt_closure = (fill_empty_set e.gt_closure) ;
+ in_gegt_of = (fill_empty_set e.in_gegt_of) ;
+ one_s_eq = (fill_empty_set e.one_s_eq) ;
+ one_s_ge = (fill_empty_set e.one_s_ge) ;
+ one_s_gt = (fill_empty_set e.one_s_gt) ;
+ } in
+ let m = g in
+ let m' = MAL.fold (
+ fun k v m ->
+ MAL.add (fill_empty_universe k) (fill_empty_entry v) m) m MAL.empty
+ in
+ m'
+
+
+(*****************************************************************************)
+(** World interface **)
+(*****************************************************************************)
+
+type universe_graph = bag
+
+let empty_ugraph = empty_bag
+
+let current_index = ref (-1)
+
+let restart_numbering () = current_index := (-1)
+
+let fresh () =
+ current_index := !current_index + 1;
+ (!current_index,None)
+
+let print_ugraph g =
+ prerr_endline (string_of_bag g)
+
+let add_eq ?(fast=(!fast_implementation)) u v b =
(* should we check to no add twice the same?? *)
- let m,_ = b in
+ let m = b in
let ru = repr u m in
if SOF.mem v ru.gt_closure then
- error (EQ,u,v) v GT u ru.gt_closure
+ error ("EQ",u,v) v "GT" u ru.gt_closure
else
begin
let rv = repr v m in
if SOF.mem u rv.gt_closure then
- error (EQ,u,v) u GT v rv.gt_closure
+ error ("EQ",u,v) u "GT" v rv.gt_closure
else
- add_eq u v b
+ add_eq fast u v b
end
-let add_ge u v b =
+let add_ge ?(fast=(!fast_implementation)) u v b =
(* should we check to no add twice the same?? *)
- let m,_ = b in
+ let m = b in
let rv = repr v m in
if SOF.mem u rv.gt_closure then
- error (GE,u,v) u GT v rv.gt_closure
+ error ("GE",u,v) u "GT" v rv.gt_closure
else
- add_ge u v b
+ add_ge fast u v b
-let add_gt u v b =
+let add_gt ?(fast=(!fast_implementation)) u v b =
(* should we check to no add twice the same?? *)
- let m,_ = b in
+ (*
+ FIXME : check the thesis... no need to check GT and EQ closure since the
+ GE is a superset of both
+ *)
+ let m = b in
let rv = repr v m in
- if SOF.mem u rv.gt_closure then
- error (GT,u,v) u GT v rv.gt_closure
+
+ if u = v then
+ error ("GT",u,v) u "==" v SOF.empty
else
- begin
+
+ (*if SOF.mem u rv.gt_closure then
+ error ("GT",u,v) u "GT" v rv.gt_closure
+ else
+ begin*)
if SOF.mem u rv.ge_closure then
- error (GT,u,v) u GE v rv.ge_closure
+ error ("GT",u,v) u "GE" v rv.ge_closure
else
- begin
+(* begin
if SOF.mem u rv.eq_closure then
- error (GT,u,v) u EQ v rv.eq_closure
- else
- add_gt u v b
- end
- end
-
-
-
-(******************************************************************************)
-(** World interface **)
-(******************************************************************************)
-
-type universe_graph = bag
-
-let work_bag = ref empty_bag
-let current_index = ref (-1)
-
-let get_working () = !work_bag
-let get_global () = !env_bag
-let set_working b = work_bag := b
+ error ("GT",u,v) u "EQ" v rv.eq_closure
+ else*)
+ add_gt fast u v b
+(* end
+ end*)
+
+(*****************************************************************************)
+(** START: Decomment this for performance comparisons **)
+(*****************************************************************************)
+
+let add_eq ?(fast=(!fast_implementation)) u v b =
+ begin_spending ();
+ let rc = add_eq ~fast u v b in
+ end_spending();
+ rc
+
+let add_ge ?(fast=(!fast_implementation)) u v b =
+ begin_spending ();
+ let rc = add_ge ~fast u v b in
+ end_spending();
+ rc
+
+let add_gt ?(fast=(!fast_implementation)) u v b =
+ begin_spending ();
+ let rc = add_gt ~fast u v b in
+ end_spending();
+ rc
+
+(*****************************************************************************)
+(** END: Decomment this for performance comparisons **)
+(*****************************************************************************)
+
+let merge_ugraphs u v =
+ (* this sucks *)
+ let merge_brutal u v =
+ if u = empty_bag then v
+ else if v = empty_bag then u
+ else
+ let m1 = u in
+ let m2 = v in
+ MAL.fold (
+ fun k v x ->
+ (SOF.fold (
+ fun u x ->
+ let m = add_gt k u x in m) v.one_s_gt
+ (SOF.fold (
+ fun u x ->
+ let m = add_ge k u x in m) v.one_s_ge
+ (SOF.fold (
+ fun u x ->
+ let m = add_eq k u x in m) v.one_s_eq x)))
+ ) m1 m2
+ in
+ merge_brutal u v
+
+
+(*****************************************************************************)
+(** Xml sesialization and parsing **)
+(*****************************************************************************)
+
+let xml_of_set s =
+ let l =
+ List.map (
+ function
+ (i,Some u) ->
+ Xml.xml_empty "node" [
+ None,"id",(string_of_int i) ;
+ None,"uri",(UriManager.string_of_uri u)]
+ | (_,None) ->
+ raise (Failure "we can serialize only universes with uri")
+ ) (SOF.elements s)
+ in
+ List.fold_left (fun s x -> [< s ; x >] ) [<>] l
+
+let xml_of_entry_content e =
+ let stream_of_field f name =
+ let eq_c = xml_of_set f in
+ if eq_c != [<>] then
+ Xml.xml_nempty name [] eq_c
+ else
+ [<>]
+ in
+ [<
+ (stream_of_field e.eq_closure "eq_closure");
+ (stream_of_field e.gt_closure "gt_closure");
+ (stream_of_field e.ge_closure "ge_closure");
+ (stream_of_field e.in_gegt_of "in_gegt_of");
+ (stream_of_field e.one_s_eq "one_s_eq");
+ (stream_of_field e.one_s_gt "one_s_gt");
+ (stream_of_field e.one_s_ge "one_s_ge")
+ >]
+
+let xml_of_entry u e =
+ let (i,u') = u in
+ let u'' =
+ match u' with
+ Some x -> x
+ | None ->
+ raise (Failure "we can serialize only universes (entry) with uri")
+ in
+ let ent = Xml.xml_nempty "entry" [
+ None,"id",(string_of_int i) ;
+ None,"uri",(UriManager.string_of_uri u'')] in
+ let content = xml_of_entry_content e in
+ ent content
+
+let write_xml_of_ugraph filename m =
+ let o = open_out filename in
+ output_string o "<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>\n";
+ Xml.pp_to_outchan (
+ Xml.xml_nempty "ugraph" [] (
+ MAL.fold (
+ fun k v s -> [< s ; (xml_of_entry k v) >])
+ m [<>])) o;
+ close_out o
+
+let rec clean_ugraph m f =
+ let m' =
+ MAL.fold (fun k v x -> if (f k) then MAL.add k v x else x ) m MAL.empty in
+ let m'' = MAL.fold (fun k v x ->
+ let v' = {
+ eq_closure = SOF.filter f v.eq_closure;
+ ge_closure = SOF.filter f v.ge_closure;
+ gt_closure = SOF.filter f v.gt_closure;
+ in_gegt_of = SOF.filter f v.in_gegt_of;
+ one_s_eq = SOF.filter f v.one_s_eq;
+ one_s_ge = SOF.filter f v.one_s_ge;
+ one_s_gt = SOF.filter f v.one_s_gt
+ } in
+ MAL.add k v' x ) m' MAL.empty in
+ let e_l =
+ MAL.fold (fun k v l -> if v = empty_entry then k::l else l) m'' []
+ in
+ if e_l != [] then
+ clean_ugraph m'' (fun u -> (f u) && not (List.mem u e_l))
+ else
+ m''
+
+let clean_ugraph g l =
+ clean_ugraph g (fun u -> List.mem u l)
+
+open Pxp_types ;;
+
+let assigner_of =
+ function
+ "ge_closure" -> (fun e u->{e with ge_closure=SOF.add u e.ge_closure})
+ | "gt_closure" -> (fun e u->{e with gt_closure=SOF.add u e.gt_closure})
+ | "eq_closure" -> (fun e u->{e with eq_closure=SOF.add u e.eq_closure})
+ | "in_gegt_of" -> (fun e u->{e with in_gegt_of =SOF.add u e.in_gegt_of})
+ | "one_s_ge" -> (fun e u->{e with one_s_ge =SOF.add u e.one_s_ge})
+ | "one_s_gt" -> (fun e u->{e with one_s_gt =SOF.add u e.one_s_gt})
+ | "one_s_eq" -> (fun e u->{e with one_s_eq =SOF.add u e.one_s_eq})
+ | s -> raise (Failure ("unsupported tag " ^ s))
+;;
-let fresh () =
- current_index := !current_index + 1;
- !current_index
+let cb_factory m =
+ let current_node = ref (0,None) in
+ let current_entry = ref empty_entry in
+ let current_assign = ref (assigner_of "in_ge_of") in
+ function
+ | E_error exn -> raise (Failure (Pxp_types.string_of_exn exn))
+ | E_start_tag ("entry",attlist,_,_) ->
+ let id = List.assoc "id" attlist in
+ let uri = List.assoc "uri" attlist in
+ current_node := (int_of_string id,Some (UriManager.uri_of_string uri))
+ | E_start_tag ("node",attlist,_,_) ->
+ let id = int_of_string (List.assoc "id" attlist) in
+ let uri = List.assoc "uri" attlist in
+ current_entry := !current_assign !current_entry
+ (id,Some (UriManager.uri_of_string uri))
+ | E_start_tag (s,_,_,_) ->
+ current_assign := assigner_of s
+ | E_end_tag ("entry",_) ->
+ m := MAL.add !current_node !current_entry !m;
+ current_entry := empty_entry
+ | _ -> ()
+;;
+
+(* alternative implementation *)
+let mapl = [
+ ("ge_closure",0);("gt_closure",1);("eq_closure",2);
+ ("in_gegt_of", 3);
+ ("one_s_ge", 4);("one_s_gt", 5);("one_s_eq", 6)]
+;;
-let qed () =
- qed !work_bag
+let assigner_of' s = List.assoc s mapl ;;
-let print_global_graph () =
- let s = string_of_bag !env_bag in
- prerr_endline s
+let entry_of_array a = {
+ ge_closure = a.(0); gt_closure = a.(1); eq_closure = a.(2);
+ in_gegt_of = a.(3);
+ one_s_ge = a.(4); one_s_gt = a.(5); one_s_eq = a.(6)}
+;;
-let print_working_graph () =
- let s = string_of_bag !work_bag in
- prerr_endline s
+let cb_factory' m =
+ let current_node = ref (0,None) in
+ let current_entry = Array.create 7 SOF.empty in
+ let current_assign = ref 0 in
+ function
+ | E_error exn -> raise (Failure (Pxp_types.string_of_exn exn))
+ | E_start_tag ("entry",attlist,_,_) ->
+ let id = List.assoc "id" attlist in
+ let uri = List.assoc "uri" attlist in
+ current_node := (int_of_string id,Some (UriManager.uri_of_string uri))
+ | E_start_tag ("node",attlist,_,_) ->
+ let id = int_of_string (List.assoc "id" attlist) in
+ let uri = List.assoc "uri" attlist in
+ current_entry.(!current_assign) <-
+ SOF.add (id,Some (UriManager.uri_of_string uri))
+ current_entry.(!current_assign)
+ | E_start_tag (s,_,_,_) ->
+ current_assign := assigner_of' s
+ | E_end_tag ("entry",_) ->
+ m := MAL.add !current_node (entry_of_array current_entry) !m;
+ Array.fill current_entry 0 7 SOF.empty
+ | _ -> ()
+;;
-type history_ticket = int
+
+let ugraph_of_xml filename =
+ let module PX = Pxp_ev_parser in
+ let module NE = Netconversion in
+ let config = default_config in
+ let entry = `Entry_document [] in
+ let encoding = `Enc_iso88591 in
+ let source = from_file ~system_encoding:encoding filename in
+ let entity_manager =
+ PX.create_entity_manager ~is_document:true config source in
+ let result = ref MAL.empty in
+ let cb = cb_factory result in
+(*let cb = cb_factory' result in*)
+ PX.process_entity config entry entity_manager cb;
+ !result
+
+\f
+(*****************************************************************************)
+(** the main, only for testing **)
+(*****************************************************************************)
-let get_history_ticket b =
- let m,l = b in
- List.length l
+(*
-let redo_history t b b'=
- let rec get_history l n =
- if n == 0 then
- []
+type arc = Ge | Gt | Eq ;;
+
+let randomize_actionlist n m =
+ let ge_percent = 0.7 in
+ let gt_percent = 0.15 in
+ let random_step () =
+ let node1 = Random.int m in
+ let node2 = Random.int m in
+ let op =
+ let r = Random.float 1.0 in
+ if r < ge_percent then
+ Ge
+ else (if r < (ge_percent +. gt_percent) then
+ Gt
+ else
+ Eq)
+ in
+ op,node1,node2
+ in
+ let rec aux n =
+ match n with
+ 0 -> []
+ | n -> (random_step ())::(aux (n-1))
+ in
+ aux n
+
+let print_action_list l =
+ let string_of_step (op,node1,node2) =
+ (match op with
+ Ge -> "Ge"
+ | Gt -> "Gt"
+ | Eq -> "Eq") ^
+ "," ^ (string_of_int node1) ^ "," ^ (string_of_int node2)
+ in
+ let rec aux l =
+ match l with
+ [] -> "]"
+ | a::tl ->
+ ";" ^ (string_of_step a) ^ (aux tl)
+ in
+ let body = aux l in
+ let l_body = (String.length body) - 1 in
+ prerr_endline ("[" ^ (String.sub body 1 l_body))
+
+let debug = false
+let d_print_endline = if debug then print_endline else ignore
+let d_print_ugraph = if debug then print_ugraph else ignore
+
+let _ =
+ (if Array.length Sys.argv < 2 then
+ prerr_endline ("Usage " ^ Sys.argv.(0) ^ " max_edges max_nodes"));
+ Random.self_init ();
+ let max_edges = int_of_string Sys.argv.(1) in
+ let max_nodes = int_of_string Sys.argv.(2) in
+ let action_listR = randomize_actionlist max_edges max_nodes in
+
+ let action_list = [Ge,1,4;Ge,2,6;Ge,1,1;Eq,6,4;Gt,6,3] in
+ let action_list = action_listR in
+
+ print_action_list action_list;
+ let prform_step ?(fast=false) (t,u,v) g =
+ let f,str =
+ match t with
+ Ge -> add_ge,">="
+ | Gt -> add_gt,">"
+ | Eq -> add_eq,"="
+ in
+ d_print_endline (
+ "Aggiungo " ^
+ (string_of_int u) ^
+ " " ^ str ^ " " ^
+ (string_of_int v));
+ let g' = f ~fast (u,None) (v,None) g in
+ (*print_ugraph g' ;*)
+ g'
+ in
+ let fail = ref false in
+ let time1 = Unix.gettimeofday () in
+ let n_safe = ref 0 in
+ let g_safe =
+ try
+ d_print_endline "SAFE";
+ List.fold_left (
+ fun g e ->
+ n_safe := !n_safe + 1;
+ prform_step e g
+ ) empty_ugraph action_list
+ with
+ UniverseInconsistency s -> fail:=true;empty_bag
+ in
+ let time2 = Unix.gettimeofday () in
+ d_print_ugraph g_safe;
+ let time3 = Unix.gettimeofday () in
+ let n_test = ref 0 in
+ let g_test =
+ try
+ d_print_endline "FAST";
+ List.fold_left (
+ fun g e ->
+ n_test := !n_test + 1;
+ prform_step ~fast:true e g
+ ) empty_ugraph action_list
+ with
+ UniverseInconsistency s -> empty_bag
+ in
+ let time4 = Unix.gettimeofday () in
+ d_print_ugraph g_test;
+ if are_ugraph_eq g_safe g_test && !n_test = !n_safe then
+ begin
+ let num_eq =
+ List.fold_left (
+ fun s (e,_,_) ->
+ if e = Eq then s+1 else s
+ ) 0 action_list
+ in
+ let num_gt =
+ List.fold_left (
+ fun s (e,_,_) ->
+ if e = Gt then s+1 else s
+ ) 0 action_list
+ in
+ let num_ge = max_edges - num_gt - num_eq in
+ let time_fast = (time4 -. time3) in
+ let time_safe = (time2 -. time1) in
+ let gap = ((time_safe -. time_fast) *. 100.0) /. time_safe in
+ let fail = if !fail then 1 else 0 in
+ print_endline
+ (sprintf
+ "OK %d safe %1.4f fast %1.4f %% %1.2f #eq %d #gt %d #ge %d %d"
+ fail time_safe time_fast gap num_eq num_gt num_ge !n_safe);
+ exit 0
+ end
else
begin
- match l with
- [] -> failwith "erroer, lista piu' corta della history"
- | h::tl -> h::(get_history tl (n - 1))
+ print_endline "FAIL";
+ print_ugraph g_safe;
+ print_ugraph g_test;
+ exit 1
end
- in
- let rec redo_commands l b =
- match l with
- [] -> b
- | (GE,u,v)::tl -> redo_commands tl (add_ge u v b)
- | (GT,u,v)::tl -> redo_commands tl (add_gt u v b)
- | (EQ,u,v)::tl -> redo_commands tl (add_eq u v b)
- in
- let (m,l) = b in
- let todo = List.rev (get_history l ((List.length l) - t)) in
- try
- redo_commands todo b'
- with
- UniverseInconsistency s -> failwith s
- (*| _ -> failwith "Unexpected exception"*)
-
-let add_gt u v =
- try
- work_bag := add_gt u v !work_bag; true
- with
- UniverseInconsistency s -> false
- (*| _ -> failwith "Unexpected exception"*)
-
-let add_ge u v =
- try
- work_bag := add_ge u v !work_bag;true
- with
- UniverseInconsistency s -> false
- (*| _ -> failwith "Unexpected exception"*)
-
-let add_eq u v =
- try
- work_bag := add_eq u v !work_bag;true
- with
- UniverseInconsistency s -> false
- (*| _ -> failwith "Unexpected exception"*)
+;;
-let saved_data = ref (empty_bag,0)
+ *)
-let directly_to_env_begin () =
- saved_data := (!work_bag, get_history_ticket !env_bag);
- work_bag := empty_bag
-
-let directly_to_env_end () =
- qed ();
- let (b,t) = !saved_data in
- work_bag := redo_history t !env_bag b
-
-let reset_working () = work_bag := empty_bag
-
-(******************************************************************************)
-(** Fake implementatoin **)
-(******************************************************************************)
-
-let reset_working = function _ -> ()
-let directly_to_env_end = function _ -> ()
-let directly_to_env_begin = function _ -> ()
-let add_eq = fun _ _ -> true
-let add_ge = fun _ _ -> true
-let add_gt = fun _ _ -> true
-let get_working = function a -> empty_bag
-let set_working = function a -> ()
+(* EOF *)
* http://helm.cs.unibo.it/
*)
-(* Cic.Type of universe *)
+
+(*
+ The strings contains an unreadable message
+*)
+exception UniverseInconsistency of string
+
+(*
+ Cic.Type of universe
+*)
type universe
-(* returns a fresh universe and puts it in the working graph *)
-val fresh: unit -> universe
+(*
+ Opaque data structure you will use to store constraints
+*)
+type universe_graph
-(* add eq/ge/gt constraints to the woring graph *)
-val add_eq: universe -> universe -> bool
-val add_ge: universe -> universe -> bool
-val add_gt: universe -> universe -> bool
+(*
+ returns a fresh universe
+*)
+val fresh:
+ unit -> universe
-(* prints the graphs *)
-val print_global_graph: unit -> unit
-val print_working_graph: unit -> unit
+(*
+ really useful at the begin and in all the functions that don't care
+ of universes
+*)
+val empty_ugraph: universe_graph
-type universe_graph
-val get_working: unit -> universe_graph
-val set_working: universe_graph -> unit
+(*
+ These are the real functions to add eq/ge/gt constraints
+ to the passed graph, returning an updated graph or raising
+ UniverseInconsistency
+*)
+val add_eq:
+ ?fast:bool -> universe -> universe -> universe_graph -> universe_graph
+val add_ge:
+ ?fast:bool -> universe -> universe -> universe_graph -> universe_graph
+val add_gt:
+ ?fast:bool -> universe -> universe -> universe_graph -> universe_graph
+
+(*
+ debug function to print the graph to standard error
+*)
+val print_ugraph:
+ universe_graph -> unit
+
+(*
+ does what expected, but I don't remember why this was exported
+*)
+val string_of_universe:
+ universe -> string
+
+(*
+ given the list of visible universes (see universes_of_obj) returns a
+ cleaned graph (cleaned from the not visible nodes)
+*)
+val clean_ugraph:
+ universe_graph -> universe list -> universe_graph
+
+(*
+ Since fresh() can't add the right uri to each node, you
+ must fill empty nodes with the uri before you serialize the graph to xml
+*)
+val fill_empty_nodes_with_uri:
+ universe_graph -> UriManager.uri -> universe_graph
+
+(*
+ makes a union.
+ TODO:
+ - remember already merged uri so that we completely skip already merged
+ graphs, this may include a dependecy graph (not merge a subpart of an
+ already merged graph)
+*)
+val merge_ugraphs:
+ universe_graph -> universe_graph -> universe_graph
-val directly_to_env_begin: unit -> unit
-val directly_to_env_end: unit -> unit
+(*
+ ugraph to xml file and viceversa
+*)
+val write_xml_of_ugraph:
+ string -> universe_graph -> unit
-val reset_working: unit -> unit
+(*
+ given a filename parses the xml and returns the data structure
+*)
+val ugraph_of_xml:
+ string -> universe_graph
+val restart_numbering:
+ unit -> unit
+(*
+ Benchmarking stuff
+*)
+val get_spent_time: unit -> float
+val reset_spent_time: unit -> unit
| Ko
| Uncertain
-let refine metasenv context term =
+let refine metasenv context term ugraph =
(* if benchmark then incr actual_refinements; *)
- let metasenv, term = CicMkImplicit.expand_implicits metasenv [] context term in
- debug_print (sprintf "TEST_INTERPRETATION: %s" (CicPp.ppterm term));
- try
- let term', _, metasenv' = CicRefine.type_of_aux' metasenv context term in
- Ok (term', metasenv')
- with
- | CicRefine.Uncertain _ ->
- debug_print ("%%% UNCERTAIN!!! " ^ CicPp.ppterm term) ;
- Uncertain
- | CicRefine.RefineFailure _ ->
- debug_print ("%%% PRUNED!!! " ^ CicPp.ppterm term) ;
- Ko
+ let metasenv, term =
+ CicMkImplicit.expand_implicits metasenv [] context term in
+ debug_print (sprintf "TEST_INTERPRETATION: %s" (CicPp.ppterm term));
+ try
+ let term', _, metasenv',ugraph1 =
+ CicRefine.type_of_aux' metasenv context term ugraph in
+ (Ok (term', metasenv')),ugraph1
+ with
+ | CicRefine.Uncertain _ ->
+ debug_print ("%%% UNCERTAIN!!! " ^ CicPp.ppterm term) ;
+ Uncertain,ugraph
+ | CicRefine.RefineFailure _ ->
+ debug_print ("%%% PRUNED!!! " ^ CicPp.ppterm term) ;
+ Ko,ugraph
+ | CicUnification.UnificationFailure s ->
+ prerr_endline ("PASSADI QUI: " ^ s);
+ raise ( CicUnification.UnificationFailure s )
let resolve (env: environment) (item: domain_item) ?(num = "") ?(args = []) () =
try
match cic with
| Cic.Const (uri, []) ->
let uris =
- match CicEnvironment.get_obj uri with
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
(*match CicTypeChecker.typecheck uri with*)
| Cic.Constant (_, _, _, uris) -> uris
| _ -> assert false
Cic.Const (uri, mk_subst uris)
| Cic.Var (uri, []) ->
let uris =
- match CicEnvironment.get_obj uri with
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
(*match CicTypeChecker.typecheck uri with*)
| Cic.Variable (_, _, _, uris) -> uris
| _ -> assert false
Cic.Var (uri, mk_subst uris)
| Cic.MutInd (uri, i, []) ->
let uris =
- match CicEnvironment.get_obj uri with
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
(*match CicTypeChecker.typecheck uri with*)
| Cic.InductiveDefinition (_, uris, _) -> uris
| _ -> assert false
Cic.MutInd (uri, i, mk_subst uris)
| Cic.MutConstruct (uri, i, j, []) ->
let uris =
- match CicEnvironment.get_obj uri with
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
(*match CicTypeChecker.typecheck uri with*)
| Cic.InductiveDefinition (_, uris, _) -> uris
| _ -> assert false
| CicAst.AttributedTerm (`Loc loc, term) -> aux loc context term
| term -> aux CicAst.dummy_floc context term)
+
(* dom1 \ dom2 *)
let domain_diff dom1 dom2 =
(* let domain_diff = Domain.diff *)
uris
let disambiguate_term ~(dbd:Mysql.dbd) context metasenv term
- ~aliases:current_env
+ ?(initial_ugraph = CicUniv.empty_ugraph) ~aliases:current_env
=
debug_print "NEW DISAMBIGUATE INPUT";
let disambiguate_context = (* cic context -> disambiguate context *)
(* (3) test an interpretation filling with meta uninterpreted identifiers
*)
- let test_env current_env todo_dom univ =
+ let test_env current_env todo_dom ugraph =
let filled_env =
List.fold_left
(fun env item ->
- Environment.add item
- ("Implicit",
+ Environment.add item
+ ("Implicit",
(match item with
- | Id _ | Num _ -> (fun _ _ _ -> Cic.Implicit (Some `Closed))
- | Symbol _ -> (fun _ _ _ -> Cic.Implicit None))) env)
+ | Id _ | Num _ -> (fun _ _ _ -> Cic.Implicit (Some `Closed))
+ | Symbol _ -> (fun _ _ _ -> Cic.Implicit None))) env)
current_env todo_dom
in
try
- CicUniv.set_working univ;
let cic_term =
interpretate ~context:disambiguate_context ~env:filled_env term
in
- let k = refine metasenv context cic_term in
- let new_univ = CicUniv.get_working () in
- (k , new_univ )
+ let k,ugraph1 = refine metasenv context cic_term ugraph in
+ (k , ugraph1 )
with
- | Try_again -> Uncertain,univ
- | DisambiguateChoices.Invalid_choice -> Ko,univ
+ | Try_again -> Uncertain,ugraph
+ | DisambiguateChoices.Invalid_choice -> Ko,ugraph
in
(* (4) build all possible interpretations *)
let rec aux current_env todo_dom base_univ =
in
filter base_univ choices
in
- let base_univ = CicUniv.get_working () in
+ let base_univ = initial_ugraph in
try
let res =
match aux current_env todo_dom base_univ with
| [] -> raise NoWellTypedInterpretation
| [ e,me,t,u ] as l ->
debug_print "UNA SOLA SCELTA";
- CicUniv.set_working u;
- [ e,me,t ]
+ [ e,me,t,u]
| l ->
debug_print (sprintf "PIU' SCELTE (%d)" (List.length l));
let choices =
l
in
let choosed = C.interactive_interpretation_choice choices in
- let l' = List.map (List.nth l) choosed in
- match l' with
- [] -> assert false
- | [e,me,t,u] ->
- CicUniv.set_working u;
- (*CicUniv.print_working_graph ();*)
- [e,me,t]
- | hd::tl -> (* ok, testlibrary... cosi' stampa MANY... bah *)
- List.map (fun (e,me,t,u) -> (e,me,t)) l'
+ List.map (List.nth l) choosed
in
(*
(if benchmark then
Cic.context ->
Cic.metasenv ->
CicAst.term ->
+ ?initial_ugraph:CicUniv.universe_graph ->
aliases:environment -> (* previous interpretation status *)
- (environment * (* new interpretation status *)
- Cic.metasenv * (* new metasenv *)
- Cic.term) list (* disambiguated term *)
+ (environment * (* new interpretation status *)
+ Cic.metasenv * (* new metasenv *)
+ Cic.term*
+ CicUniv.universe_graph) list (* disambiguated term *)
end
Buffer.contents buf
*)
+let empty_environment = Environment.empty
type tactic = (term, string) TacticAst.tactic
type tactical = (term, string) TacticAst.tactical
+val empty_environment: environment
let xxx_type_of_aux' m c t =
let t1 = Sys.time () in
- let res = CicTypeChecker.type_of_aux' m c t in
+ let res,_ = CicTypeChecker.type_of_aux' m c t CicUniv.empty_ugraph in
let t2 = Sys.time () in
type_of_aux'_add_time := !type_of_aux'_add_time +. t2 -. t1 ;
res
with Not_found -> "Type") in
if sort ="Prop" then
let inductive_types =
- (match CicEnvironment.get_obj uri with
- Cic.Constant _ -> assert false
- | Cic.Variable _ -> assert false
- | Cic.CurrentProof _ -> assert false
- | Cic.InductiveDefinition (l,_,_) -> l
+ (let o,_ =
+ CicEnvironment.get_obj uri CicUniv.empty_ugraph
+ in
+ match o with
+ Cic.Constant _ -> assert false
+ | Cic.Variable _ -> assert false
+ | Cic.CurrentProof _ -> assert false
+ | Cic.InductiveDefinition (l,_,_) -> l
) in
let (_,_,_,constructors) =
List.nth inductive_types tyno in
else raise Not_a_proof
| C.AMutCase (id,uri,typeno,ty,te,patterns) ->
let inductive_types,noparams =
- (match CicEnvironment.get_obj uri with
- Cic.Constant _ -> assert false
- | Cic.Variable _ -> assert false
- | Cic.CurrentProof _ -> assert false
- | Cic.InductiveDefinition (l,_,n) -> l,n
- ) in
+ (let o, _ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
+ Cic.Constant _ -> assert false
+ | Cic.Variable _ -> assert false
+ | Cic.CurrentProof _ -> assert false
+ | Cic.InductiveDefinition (l,_,n) -> l,n
+ ) in
let (_,_,_,constructors) = List.nth inductive_types typeno in
let name_and_arities =
let rec count_prods =
let ind_str = (prefix ^ ".ind") in
let ind_uri = UriManager.uri_of_string ind_str in
let inductive_types,noparams =
- (match CicEnvironment.get_obj ind_uri with
- Cic.Constant _ -> assert false
- | Cic.Variable _ -> assert false
- | Cic.CurrentProof _ -> assert false
- | Cic.InductiveDefinition (l,_,n) -> (l,n)
- ) in
+ (let o,_ = CicEnvironment.get_obj ind_uri CicUniv.empty_ugraph in
+ match o with
+ Cic.Constant _ -> assert false
+ | Cic.Variable _ -> assert false
+ | Cic.CurrentProof _ -> assert false
+ | Cic.InductiveDefinition (l,_,n) -> (l,n)
+ ) in
let rec split n l =
if n = 0 then ([],l) else
let p,a = split (n-1) (List.tl l) in
let xxx_type_of_aux' m c t =
let t1 = Sys.time () in
- let res = CicTypeChecker.type_of_aux' m c t in
+ let res,_ = CicTypeChecker.type_of_aux' m c t CicUniv.empty_ugraph in
let t2 = Sys.time () in
type_of_aux'_add_time := !type_of_aux'_add_time +. t2 -. t1 ;
res
let module R = CicReduction in
let module U = UriManager in
let cobj =
- match CicEnvironment.is_type_checked uri with
- CicEnvironment.CheckedObj cobj -> cobj
+ match CicEnvironment.is_type_checked uri CicUniv.empty_ugraph with
+ CicEnvironment.CheckedObj (cobj,_) -> cobj
| CicEnvironment.UncheckedObj uobj ->
raise (NotWellTyped "Reference to an unchecked constant")
in
let module C = Cic in
let module R = CicReduction in
let module U = UriManager in
- match CicEnvironment.is_type_checked uri with
- CicEnvironment.CheckedObj (C.Variable (_,_,ty,_)) -> ty
+ match CicEnvironment.is_type_checked uri CicUniv.empty_ugraph with
+ CicEnvironment.CheckedObj ((C.Variable (_,_,ty,_)),_) -> ty
| CicEnvironment.UncheckedObj (C.Variable _) ->
raise (NotWellTyped "Reference to an unchecked variable")
| _ -> raise (WrongUriToVariable (UriManager.string_of_uri uri))
let module R = CicReduction in
let module U = UriManager in
let cobj =
- match CicEnvironment.is_type_checked uri with
- CicEnvironment.CheckedObj cobj -> cobj
+ match CicEnvironment.is_type_checked uri CicUniv.empty_ugraph with
+ CicEnvironment.CheckedObj (cobj,_) -> cobj
| CicEnvironment.UncheckedObj uobj ->
raise (NotWellTyped "Reference to an unchecked inductive type")
in
let module R = CicReduction in
let module U = UriManager in
let cobj =
- match CicEnvironment.is_type_checked uri with
- CicEnvironment.CheckedObj cobj -> cobj
+ match CicEnvironment.is_type_checked uri CicUniv.empty_ugraph with
+ CicEnvironment.CheckedObj (cobj,_) -> cobj
| CicEnvironment.UncheckedObj uobj ->
raise (NotWellTyped "Reference to an unchecked constructor")
in
(* Checks suppressed *)
CicSubstitution.lift_meta l ty
| C.Sort (C.Type t) -> (* TASSI: CONSTRAINT *)
- let t' = CicUniv.fresh() in
- if not (CicUniv.add_gt t' t ) then
- assert false (* t' is fresh! an error in CicUniv *)
- else
- C.Sort (C.Type t')
+ C.Sort (C.Type (CicUniv.fresh()))
| C.Sort _ -> C.Sort (C.Type (CicUniv.fresh())) (* TASSI: CONSTRAINT *)
| C.Implicit _ -> raise (Impossible 21)
| C.Cast (te,ty) ->
(* Checks suppressed *)
(* Let's visit all the subterms that will not be visited later *)
let (cl,parsno) =
- let obj =
+ let obj,_ =
try
- CicEnvironment.get_cooked_obj uri
+ CicEnvironment.get_cooked_obj uri CicUniv.empty_ugraph
with Not_found -> assert false
in
match obj with
and visit_exp_named_subst context uri exp_named_subst =
let uris_and_types =
- let obj =
+ let obj,_ =
try
- CicEnvironment.get_cooked_obj uri
+ CicEnvironment.get_cooked_obj uri CicUniv.empty_ugraph
with Not_found -> assert false
in
match obj with
| Cic.InductiveDefinition (_,params,_) ->
List.map
(function uri ->
- let obj =
+ let obj,_ =
try
- CicEnvironment.get_cooked_obj uri
+ CicEnvironment.get_cooked_obj uri CicUniv.empty_ugraph
with Not_found -> assert false
in
match obj with
(* different from Coq manual!!! *)
C.Sort s2
| (C.Sort (C.Type t1), C.Sort (C.Type t2)) ->
- (* TASSI: CONSRTAINTS: the same in cictypechecker,cicrefine *)
- let t' = CicUniv.fresh() in
- if not (CicUniv.add_ge t' t1) || not (CicUniv.add_ge t' t2) then
- assert false ; (* not possible, error in CicUniv *)
- C.Sort (C.Type t')
+ C.Sort (C.Type (CicUniv.fresh()))
| (C.Sort _,C.Sort (C.Type t1)) ->
(* TASSI: CONSRTAINTS: the same in cictypechecker,cicrefine *)
C.Sort (C.Type t1) (* c'e' bisogno di un fresh? *)
(match l' with
[] -> assert false
| he::tl ->
- let ty = CicTypeChecker.type_of_aux' metasenv context he in
- fix_according_to_type ty he tl
+ let ty,_ =
+ CicTypeChecker.type_of_aux' metasenv context he
+ CicUniv.empty_ugraph
+ in
+ fix_according_to_type ty he tl
(*
C.Const(uri,exp_named_subst)::l'' ->
let constant_type =
let term' = eta_fix' context term in
let patterns' = List.map (eta_fix' context) patterns in
let inductive_types,noparams =
- (match CicEnvironment.get_obj uri with
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ (match o with
Cic.Constant _ -> assert false
| Cic.Variable _ -> assert false
| Cic.CurrentProof _ -> assert false
if noparams = 0 then
List.map (fun (_,t) -> t) constructors
else
- let term_type =
- CicTypeChecker.type_of_aux' metasenv context term
- in
+ let term_type,_ =
+ CicTypeChecker.type_of_aux' metasenv context term
+ CicUniv.empty_ugraph
+ in
(match term_type with
C.Appl (hd::params) ->
let rec first_n n l =
(fun newsubst (uri,t) ->
let t' = eta_fix' context t in
let ty =
- match CicEnvironment.get_obj uri with
- Cic.Variable (_,_,ty,_) -> CicSubstitution.subst_vars newsubst ty
- | _ -> raise ReferenceToNonVariable in
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
+ Cic.Variable (_,_,ty,_) ->
+ CicSubstitution.subst_vars newsubst ty
+ | _ -> raise ReferenceToNonVariable
+ in
let t'' = fix_according_to_type ty t' [] in
(uri,t'')::newsubst
) [] exp_named_subst)
cicLogger.cmx: cicLogger.cmi
cicEnvironment.cmo: cicLogger.cmi cicEnvironment.cmi
cicEnvironment.cmx: cicLogger.cmx cicEnvironment.cmi
+cicUnivUtils.cmo: cicEnvironment.cmi cicUnivUtils.cmi
+cicUnivUtils.cmx: cicEnvironment.cmx cicUnivUtils.cmi
cicPp.cmo: cicEnvironment.cmi cicPp.cmi
cicPp.cmx: cicEnvironment.cmx cicPp.cmi
cicSubstitution.cmo: cicEnvironment.cmi cicSubstitution.cmi
PACKAGE = cic_proof_checking
-REQUIRES = helm-cic helm-logger helm-getter
+REQUIRES = helm-cic helm-logger helm-getter helm-xml pxp
PREDICATES =
REDUCTION_IMPLEMENTATION = cicReductionMachine.ml
INTERFACE_FILES = \
cicLogger.mli \
- cicEnvironment.mli cicPp.mli cicSubstitution.mli \
+ cicEnvironment.mli cicUnivUtils.mli cicPp.mli cicSubstitution.mli \
cicMiniReduction.mli cicReductionNaif.mli cicReduction.mli \
cicTypeChecker.mli
IMPLEMENTATION_FILES = $(INTERFACE_FILES:%.mli=%.ml)
* http://cs.unibo.it/helm/.
*)
-(******************************************************************************)
-(* *)
-(* PROJECT HELM *)
-(* *)
-(* Claudio Sacerdoti Coen <sacerdot@cs.unibo.it> *)
-(* 24/01/2000 *)
-(* *)
-(* This module implements a trival cache system (an hash-table) for cic *)
-(* objects. Uses the getter (getter.ml) and the parser (cicParser.ml) *)
-(* *)
-(******************************************************************************)
+(*****************************************************************************)
+(* *)
+(* PROJECT HELM *)
+(* *)
+(* Claudio Sacerdoti Coen <sacerdot@cs.unibo.it> *)
+(* 24/01/2000 *)
+(* *)
+(* This module implements a trival cache system (an hash-table) for cic *)
+(* objects. Uses the getter (getter.ml) and the parser (cicParser.ml) *)
+(* *)
+(*****************************************************************************)
+
let cleanup_tmp = true;;
let trust_obj uri = !trust uri
type type_checked_obj =
- CheckedObj of Cic.obj (* cooked obj *)
+ CheckedObj of (Cic.obj * CicUniv.universe_graph) (* cooked obj *)
| UncheckedObj of Cic.obj (* uncooked obj to proof-check *)
;;
module Cache :
sig
val find_or_add_unchecked :
- UriManager.uri -> get_object_to_add:(unit -> Cic.obj) -> Cic.obj
- val unchecked_to_frozen : UriManager.uri -> unit
+ UriManager.uri ->
+ get_object_to_add:(unit -> Cic.obj * CicUniv.universe_graph option) ->
+ Cic.obj * CicUniv.universe_graph
+ val can_be_cooked:
+ UriManager.uri -> bool
+ val unchecked_to_frozen :
+ UriManager.uri -> unit
val frozen_to_cooked :
- uri:UriManager.uri -> unit
- val find_cooked : key:UriManager.uri -> Cic.obj
- val add_cooked : key:UriManager.uri -> Cic.obj -> unit
+ uri:UriManager.uri -> unit
+ val hack_univ:
+ UriManager.uri -> CicUniv.universe_graph -> unit
+ val find_cooked :
+ key:UriManager.uri -> Cic.obj * CicUniv.universe_graph
+ val add_cooked :
+ key:UriManager.uri -> (Cic.obj * CicUniv.universe_graph) -> unit
+ val not_jet_cooked:
+ UriManager.uri -> Cic.obj * CicUniv.universe_graph
val remove: UriManager.uri -> unit
val dump_to_channel : ?callback:(string -> unit) -> out_channel -> unit
val restore_from_channel : ?callback:(string -> unit) -> in_channel -> unit
val empty : unit -> unit
+ val is_in_frozen: UriManager.uri -> bool
+ val is_in_unchecked: UriManager.uri -> bool
end
=
struct
+ (*************************************************************************
+ TASSI: invariant
+ The CacheOfCookedObjects will contain only objects with a valid universe
+ graph. valid means that non None (used if there is no universe file
+ in the universe generation phase).
+ **************************************************************************)
module CacheOfCookedObjects :
sig
val mem : UriManager.uri -> bool
- val find : UriManager.uri -> Cic.obj
- val add : UriManager.uri -> Cic.obj -> unit
+ val find : UriManager.uri -> Cic.obj * CicUniv.universe_graph
+ val add : UriManager.uri -> (Cic.obj * CicUniv.universe_graph) -> unit
val remove : UriManager.uri -> unit
(** (de)serialization of type checker cache *)
with
Not_found -> false
;;
- let find uri = HT.find hashtable uri
- ;;
- let add uri obj =
- HT.add hashtable uri obj
+ let find uri = HT.find hashtable uri ;;
+ let add uri (obj,ugraph) =
+ HT.add hashtable uri (obj,ugraph)
;;
let remove uri =
if mem uri then
let uri' = recons uri in
let exp_named_subst' =
List.map
- (function (uri,t) ->(recons uri,restore_in_term t)) exp_named_subst
+ (function (uri,t) ->(recons uri,restore_in_term t))
+ exp_named_subst
in
C.Var (uri',exp_named_subst')
| C.Meta (i,l) ->
callback (UriManager.string_of_uri k);
HT.add hashtable
(UriManager.uri_of_string (UriManager.string_of_uri k))
- (restore_uris v))
+
+(************************************************
+ TASSI: FIXME add channel stuff for universes
+*************************************************)
+
+ ((restore_uris v),CicUniv.empty_ugraph))
restored
;;
let frozen_list = ref [];;
let unchecked_list = ref [];;
+ let is_in_frozen uri =
+ List.mem_assoc uri !frozen_list
+ ;;
+
+ let is_in_unchecked uri =
+ List.mem_assoc uri !unchecked_list
+ ;;
+ (*******************************************************************
+ TASSI: invariant
+ we need, in the universe generation phase, to traverse objects
+ that are not jet committed, so we search them in the frozen list.
+ Only uncommitted objects without a universe file (see the assertion)
+ can be searched with method
+ *******************************************************************)
+ let not_jet_cooked uri =
+ try
+ let o,u = List.assoc uri !frozen_list in
+ match u with
+ None -> o, CicUniv.empty_ugraph
+ | Some _ -> assert false (* only univ_maker ca use this *)
+ with Not_found ->
+ CacheOfCookedObjects.find uri
+ ;;
let find_or_add_unchecked uri ~get_object_to_add =
- try
- List.assq uri !unchecked_list
- with
- Not_found ->
- if List.mem_assq uri !frozen_list then
- raise (CircularDependency (UriManager.string_of_uri uri))
- else
- if CacheOfCookedObjects.mem uri then
- raise (AlreadyCooked (UriManager.string_of_uri uri))
- else
- (* OK, it is not already frozen nor cooked *)
- let obj = get_object_to_add () in
- unchecked_list := (uri,obj)::!unchecked_list ;
- obj
+ try
+ let o,g = List.assq uri !unchecked_list in
+ match g with
+ None -> o,CicUniv.empty_ugraph
+ | Some g' -> o,g'
+ with
+ Not_found ->
+ if List.mem_assq uri !frozen_list then
+ begin
+ print_endline "\nCircularDependency!\nfrozen list: \n";
+ List.iter (
+ fun (u,(_,o)) ->
+ let su = UriManager.string_of_uri u in
+ let univ = if o = None then "NO_UNIV" else "" in
+ print_endline (su^" "^univ))
+ !frozen_list;
+ raise (CircularDependency (UriManager.string_of_uri uri))
+ end
+ else
+ if CacheOfCookedObjects.mem uri then
+ raise (AlreadyCooked (UriManager.string_of_uri uri))
+ else
+ (* OK, it is not already frozen nor cooked *)
+ let obj,ugraph = get_object_to_add () in
+ let ugraph_real =
+ match ugraph with
+ None -> CicUniv.empty_ugraph
+ | Some g -> g
+ in
+ unchecked_list := (uri,(obj,ugraph))::!unchecked_list ;
+ obj,ugraph_real
;;
let unchecked_to_frozen uri =
try
- let obj = List.assq uri !unchecked_list in
+ let obj,ugraph = List.assq uri !unchecked_list in
unchecked_list := List.remove_assq uri !unchecked_list ;
- frozen_list := (uri,obj)::!frozen_list
+ frozen_list := (uri,(obj,ugraph))::!frozen_list
with
Not_found -> raise (CouldNotFreeze (UriManager.string_of_uri uri))
;;
+ (************************************************************
+ TASSI: invariant
+ only object with a valid universe graph can be committed
+ *************************************************************)
let frozen_to_cooked ~uri =
try
- let obj = List.assq uri !frozen_list in
- frozen_list := List.remove_assq uri !frozen_list ;
- CacheOfCookedObjects.add uri obj
+ let obj,ugraph = List.assq uri !frozen_list in
+ match ugraph with
+ None ->
+ assert false (* only non dummy universes can be committed *)
+ | Some g ->
+ frozen_list := List.remove_assq uri !frozen_list ;
+ CacheOfCookedObjects.add uri (obj,g)
with
- Not_found -> raise (CouldNotUnfreeze (UriManager.string_of_uri uri))
+ Not_found -> raise (CouldNotUnfreeze (UriManager.string_of_uri uri))
+ ;;
+ let can_be_cooked uri =
+ try
+ let obj,ugraph = List.assq uri !frozen_list in
+ match ugraph with
+ None -> false
+ | Some _ -> true
+ with
+ Not_found -> false
+ ;;
+ let hack_univ uri real_ugraph =
+ try
+ let o,g = List.assq uri !frozen_list in
+ match g with
+ None ->
+ frozen_list := List.remove_assoc uri !frozen_list;
+ frozen_list := (uri,(o,Some real_ugraph))::!frozen_list;
+ | Some g ->
+ prerr_endline (
+ "You are probably hacking an object already hacked or an"^
+ " object that has the universe file but is not"^
+ " jet committed");
+ assert false
+ with
+ Not_found ->
+ prerr_endline (
+ "You are hacking an object that is not in the"^
+ " frozen_list, this means you are probably generating an"^
+ " universe file for an object that already as an universe file");
+ assert false
;;
let find_cooked ~key:uri = CacheOfCookedObjects.find uri;;
- let add_cooked ~key:uri obj = CacheOfCookedObjects.add uri obj;;
+ let add_cooked ~key:uri (obj,ugraph) =
+ CacheOfCookedObjects.add uri (obj,ugraph);;
let remove uri =
if (!unchecked_list <> []) || (!frozen_list <> []) then
failwith "CicEnvironment.remove while type checking"
;;
let dump_to_channel = CacheOfCookedObjects.dump_to_channel;;
let restore_from_channel = CacheOfCookedObjects.restore_from_channel;;
- let empty = CacheOfCookedObjects.empty;;
+ let empty () =
+ CacheOfCookedObjects.empty ();
+ unchecked_list := [] ;
+ frozen_list := []
+ ;;
end
;;
(* The body does not exist ==> we consider it an axiom *)
None
in
+
+ (*
+ maybe this is not the right place to do this.. but I think
+ obj_of_xml is called only here
+ *)
+ (* this brakes something : let _ = CicUniv.restart_numbering () in *)
+ let obj = CicParser.obj_of_xml filename bodyfilename in
+ let ugraph,filename_univ =
+ (*
+ try
+ let filename_univ =
+ Http_getter.getxml' (
+ UriManager.uri_of_string (
+ (UriManager.string_of_uri uri) ^ ".univ"))
+ in
+ (Some (CicUniv.ugraph_of_xml filename_univ),Some filename_univ)
+ with Failure s ->
+
+ prerr_endline (
+ "WE HAVE NO UNIVERSE FILE FOR " ^ (UriManager.string_of_uri uri));
+ None,None
+ *)
+ (**********************************************
+ TASSI: should fail when universes will be ON
+ ***********************************************)
+ (Some CicUniv.empty_ugraph,None)
+ in
let cleanup () =
- if cleanup_tmp then
- begin
- if Sys.file_exists filename then Unix.unlink filename ;
- match bodyfilename with
- Some f -> if Sys.file_exists f then Unix.unlink f
- | None -> ()
- end ;
- in
- CicUniv.directly_to_env_begin ();
- let obj =
- try
- CicParser.obj_of_xml filename bodyfilename
- with exn ->
- cleanup ();
- raise exn
- in
- CicUniv.directly_to_env_end ();
- cleanup ();
- obj
- )
+ Unix.unlink filename ;
+ begin
+ match filename_univ with
+ Some f -> Unix.unlink f
+ | None -> ()
+ end;
+ begin
+ match bodyfilename with
+ Some f -> Unix.unlink f
+ | None -> ()
+ end
+ in
+ cleanup();
+ obj,ugraph)
;;
(* set_type_checking_info uri *)
(* must be called once the type-checking of uri is finished *)
(* The object whose uri is uri is unfreezed *)
-let set_type_checking_info uri =
- Cache.frozen_to_cooked uri
+let set_type_checking_info ?(replace_ugraph=None) uri =
+ if Cache.can_be_cooked uri && replace_ugraph <> None then
+ invalid_arg (
+ "?replace_ugraph must be None if you are not committing an "^
+ "object that has an no universe graph associated "^
+ "(can happen only in the fase of universes graphs generation).");
+ if not (Cache.can_be_cooked uri) && replace_ugraph = None then
+ invalid_arg (
+ "?replace_ugraph must be (Some ugraph) when committing an object that "^
+ "has no associated universe graph. If this is in make_univ phase you "^
+ "should drop this exception and let univ_make commit thi object with "^
+ "proper arguments");
+ begin
+ match replace_ugraph with
+ None -> ()
+ | Some g -> Cache.hack_univ uri g
+ end;
+ Cache.frozen_to_cooked uri
;;
+
(* is_type_checked uri *)
(* CSC: commento falso ed obsoleto *)
(* returns a CheckedObj if the term has been type-checked *)
(* otherwise it freezes the term for type-checking and returns
it *)
(* set_type_checking_info must be called to unfreeze the term *)
-let is_type_checked ?(trust=true) uri =
+let is_type_checked ?(trust=true) uri base_univ =
try
- CheckedObj (Cache.find_cooked uri)
+ let o,u = Cache.find_cooked uri in
+ CheckedObj (o,CicUniv.merge_ugraphs u base_univ)
with
- Not_found ->
- let obj = find_or_add_unchecked_to_cache uri in
- Cache.unchecked_to_frozen uri ;
- if trust && trust_obj uri then
- begin
- CicLogger.log (`Trusting uri) ;
- set_type_checking_info uri ;
- CheckedObj (Cache.find_cooked uri)
- end
- else
- UncheckedObj obj
+ Not_found ->
+ let obj,ugraph = find_or_add_unchecked_to_cache uri in
+ Cache.unchecked_to_frozen uri ;
+ if trust && trust_obj uri then
+ begin
+ CicLogger.log (`Trusting uri) ;
+ set_type_checking_info uri ;
+ let o,u = Cache.find_cooked uri in
+ let u' = CicUniv.merge_ugraphs base_univ ugraph in
+ CheckedObj (o,u')
+ end
+ else
+ begin
+ UncheckedObj obj
+ end
;;
(* get_cooked_obj ~trust uri *)
(* returns the object if it is already type-checked or if it can be *)
(* trusted (if [trust] = true and the trusting function accepts it) *)
(* Otherwise it raises Not_found *)
-let get_cooked_obj ?(trust=true) uri =
+let get_cooked_obj ?(trust=true) uri base_univ =
try
- Cache.find_cooked uri
+ let o,u = Cache.find_cooked uri in
+ o,(CicUniv.merge_ugraphs base_univ u)
with Not_found ->
if trust && trust_obj uri then
begin
- match is_type_checked uri with
- CheckedObj obj -> obj
- | _ -> assert false
+ match is_type_checked uri base_univ with
+ CheckedObj (obj,ugraph) -> obj,(CicUniv.merge_ugraphs ugraph base_univ)
+ | _ -> assert false
end
else
- begin
- prerr_endline ("@@@ OOOOOOOPS: get_cooked_obj(" ^ UriManager.string_of_uri uri ^ ") raises Not_found since the object is not type-checked nor trusted.") ;
- raise Not_found
- end
+ begin
+ prerr_endline (
+ "@@@ OOOOOOOPS: get_cooked_obj(" ^ UriManager.string_of_uri uri ^
+ ") raises Not_found since the object is not type-checked"^
+ " nor trusted.");
+ raise Not_found
+ end
;;
-(* get_obj uri *)
-(* returns the cic object whose uri is uri. If the term is not just in cache, *)
-(* then it is parsed via CicParser.term_of_xml from the file whose name is *)
-(* the result of Getter.getxml uri *)
-let get_obj uri =
- try
- get_cooked_obj uri
- with
- Not_found ->
- find_or_add_unchecked_to_cache uri
+(* get_obj uri *)
+(* returns the cic object whose uri is uri. If the term is not just in cache,*)
+(* then it is parsed via CicParser.term_of_xml from the file whose name is *)
+(* the result of Getter.getxml uri *)
+let get_obj ?(not_jet_cooked=false) uri base_univ =
+ if not_jet_cooked then
+ let o,u = Cache.not_jet_cooked uri in
+ o,(CicUniv.merge_ugraphs base_univ u)
+ else
+ try
+ get_cooked_obj uri base_univ
+ with
+ Not_found ->
+ let s = ( UriManager.string_of_uri uri) in
+ let o,u = find_or_add_unchecked_to_cache uri in
+ o,(CicUniv.merge_ugraphs base_univ u)
;;
exception OnlyPutOfInductiveDefinitionsIsAllowed
-let put_inductive_definition uri obj =
+let put_inductive_definition uri (obj,ugraph) =
match obj with
- Cic.InductiveDefinition _ -> Cache.add_cooked uri obj
+ Cic.InductiveDefinition _ -> Cache.add_cooked uri (obj,ugraph)
| _ -> raise OnlyPutOfInductiveDefinitionsIsAllowed
;;
let in_cache uri =
try
- ignore (Cache.find_cooked uri);true
- with Not_found -> false
+ ignore (Cache.find_cooked uri);
+ prerr_endline "TROVATO NELLA CHECKED";true
+ with Not_found ->
+ if Cache.is_in_frozen uri then
+ (prerr_endline "TROVATO NELLA FROZEN";true)
+ else
+ if Cache.is_in_unchecked uri then
+ (prerr_endline "TROVATO NELLA UNCHECKED";true)
+ else
+ (prerr_endline ("NON TROVATO:" ^ (UriManager.string_of_uri uri) );false)
;;
-let add_type_checked_term uri obj =
+let add_type_checked_term uri (obj,ugraph) =
match obj with
- Cic.Constant (s,(Some bo),ty,ul) ->
- Cache.add_cooked ~key:uri obj
- | _ -> assert false
- Cache.add_cooked
+ Cic.Constant (s,(Some bo),ty,ul) ->
+ Cache.add_cooked ~key:uri (obj,ugraph)
+ | _ ->
+ assert false
;;
let remove_term = Cache.remove
* http://cs.unibo.it/helm/.
*)
-(******************************************************************************)
-(* *)
-(* PROJECT HELM *)
-(* *)
-(* Claudio Sacerdoti Coen <sacerdot@cs.unibo.it> *)
-(* 24/01/2000 *)
-(* *)
-(* This module implements a trival cache system (an hash-table) for cic *)
-(* objects. Uses the getter (getter.ml) and the parser (cicParser.ml) *)
-(* *)
-(******************************************************************************)
+(*****************************************************************************)
+(* *)
+(* PROJECT HELM *)
+(* *)
+(* Claudio Sacerdoti Coen <sacerdot@cs.unibo.it> *)
+(* 24/01/2000 *)
+(* *)
+(* This module implements a trival cache system (an hash-table) for cic *)
+(* objects. Uses the getter (getter.ml) and the parser (cicParser.ml) *)
+(* *)
+(*****************************************************************************)
exception CircularDependency of string;;
exception Term_not_found of UriManager.uri;;
-(* get_obj uri *)
-(* returns the cic object whose uri is uri. If the term is not just in cache, *)
-(* then it is parsed via CicParser.term_of_xml from the file whose name is *)
-(* the result of Getter.get uri *)
-val get_obj : UriManager.uri -> Cic.obj
+(* get_obj uri *)
+(* returns the cic object whose uri is uri. If the term is not just in cache,*)
+(* then it is parsed via CicParser.term_of_xml from the file whose name is *)
+(* the result of Getter.get uri *)
+(* *)
+(* ~not_jet_cooked returns the object even if it is not in the *)
+(* CacheOfCookedObjects searching it in the frozen list. *)
+(* This is necessary in cicUnivUtils.ml since (in the univ_maker phase *)
+(* it has to traverse object before they are committed. *)
+(* see the .ml file for some reassuring invariants on this. *)
+val get_obj :
+ ?not_jet_cooked:bool -> UriManager.uri -> CicUniv.universe_graph ->
+ Cic.obj * CicUniv.universe_graph
type type_checked_obj =
- CheckedObj of Cic.obj (* cooked obj *)
+ CheckedObj of (Cic.obj * CicUniv.universe_graph) (* cooked obj *)
| UncheckedObj of Cic.obj (* uncooked obj *)
(* is_type_checked uri cookingsno *)
(* otherwise it returns (false,object) and freeze the object for *)
(* type-checking *)
(* set_type_checking_info must be called to unfreeze the object *)
-val is_type_checked : ?trust:bool -> UriManager.uri -> type_checked_obj
+val is_type_checked :
+ ?trust:bool -> UriManager.uri -> CicUniv.universe_graph -> type_checked_obj
(* set_type_checking_info uri *)
(* must be called once the type-checking of uri is finished *)
(* The object whose uri is uri is unfreezed and won't be type-checked *)
(* again in the future (is_type_checked will return true) *)
-val set_type_checking_info : UriManager.uri -> unit
+(* *)
+(* Since the universes are not exported directly, but generated *)
+(* typecheking the library, we can't find them in the library as we *)
+(* do for the types. This means that when we commit uris during *)
+(* univ generation we can't associate the uri with the universe graph *)
+(* we find in the library, we have to calculate it and then inject it *)
+(* in the cacke. This is an orrible backdoor used by univ_maker. *)
+(* see the .ml file for some reassuring invariants *)
+val set_type_checking_info :
+ ?replace_ugraph:(CicUniv.universe_graph option) -> UriManager.uri -> unit
(* We need this in the Qed. *)
-val add_type_checked_term : UriManager.uri -> Cic.obj -> unit
+val add_type_checked_term :
+ UriManager.uri -> (Cic.obj * CicUniv.universe_graph) -> unit
(** remove a type checked term
* @raise Term_not_found when given term is not in the environment
(* returns the object if it is already type-checked or if it can be *)
(* trusted (if [trust] = true and the trusting function accepts it) *)
(* Otherwise it raises Not_found *)
-val get_cooked_obj : ?trust:bool -> UriManager.uri -> Cic.obj
+val get_cooked_obj :
+ ?trust:bool -> UriManager.uri ->
+ CicUniv.universe_graph -> Cic.obj * CicUniv.universe_graph
(* FUNCTIONS USED ONLY IN THE TOPLEVEL/PROOF-ENGINE *)
(* in the environment. *)
(* WARNING: VERY UNSAFE. *)
(* This function should be called only on a well-typed definition. *)
-val put_inductive_definition : UriManager.uri -> Cic.obj -> unit
+val put_inductive_definition :
+ UriManager.uri -> (Cic.obj * CicUniv.universe_graph) -> unit
(* (de)serialization *)
val dump_to_channel : ?callback:(string -> unit) -> out_channel -> unit
UriManager.name_of_uri uri ^ pp_exp_named_subst exp_named_subst l
| C.MutInd (uri,n,exp_named_subst) ->
(try
- match CicEnvironment.get_obj uri with
+ match fst(CicEnvironment.get_obj uri CicUniv.empty_ugraph) with
C.InductiveDefinition (dl,_,_) ->
let (name,_,_,_) = get_nth dl (n+1) in
name ^ pp_exp_named_subst exp_named_subst l
)
| C.MutConstruct (uri,n1,n2,exp_named_subst) ->
(try
- match CicEnvironment.get_obj uri with
+ match fst(CicEnvironment.get_obj uri CicUniv.empty_ugraph) with
C.InductiveDefinition (dl,_,_) ->
let (_,_,_,cons) = get_nth dl (n1+1) in
let (id,_) = get_nth cons n2 in
)
| C.MutCase (uri,n1,ty,te,patterns) ->
let connames =
- (match CicEnvironment.get_obj uri with
+ (match fst(CicEnvironment.get_obj uri CicUniv.empty_ugraph) with
C.InductiveDefinition (dl,_,_) ->
let (_,_,_,cons) = get_nth dl (n1+1) in
List.map (fun (id,_) -> id) cons
val fdebug : int ref
val whd : ?subst:Cic.substitution -> Cic.context -> Cic.term -> Cic.term
val are_convertible :
- ?subst:Cic.substitution -> ?metasenv:Cic.metasenv -> Cic.context -> Cic.term -> Cic.term -> bool
+ ?subst:Cic.substitution -> ?metasenv:Cic.metasenv ->
+ Cic.context -> Cic.term -> Cic.term -> CicUniv.universe_graph ->
+ bool * CicUniv.universe_graph
+
CicSubstitution.lift m (RS.from_ens (List.assq uri ens))
else
let params =
- (match CicEnvironment.get_obj uri with
+ let o,_ =
+ CicEnvironment.get_cooked_obj uri CicUniv.empty_ugraph
+ in
+ (match o with
C.Constant _ -> raise ReferenceToConstant
| C.Variable (_,_,_,params) -> params
| C.CurrentProof _ -> raise ReferenceToCurrentProof
| C.Appl l -> C.Appl (List.map (unwind_aux m) l)
| C.Const (uri,exp_named_subst) ->
let params =
- (match CicEnvironment.get_obj uri with
+ let o,_ =
+ CicEnvironment.get_cooked_obj uri CicUniv.empty_ugraph
+ in
+ (match o with
C.Constant (_,_,_,params) -> params
| C.Variable _ -> raise ReferenceToVariable
| C.CurrentProof (_,_,_,_,params) -> params
C.Const (uri,exp_named_subst')
| C.MutInd (uri,i,exp_named_subst) ->
let params =
- (match CicEnvironment.get_obj uri with
+ let o,_ =
+ CicEnvironment.get_cooked_obj uri CicUniv.empty_ugraph
+ in
+ (match o with
C.Constant _ -> raise ReferenceToConstant
| C.Variable _ -> raise ReferenceToVariable
| C.CurrentProof _ -> raise ReferenceToCurrentProof
C.MutInd (uri,i,exp_named_subst')
| C.MutConstruct (uri,i,j,exp_named_subst) ->
let params =
- (match CicEnvironment.get_obj uri with
+ let o,_ =
+ CicEnvironment.get_cooked_obj uri CicUniv.empty_ugraph
+ in
+ (match o with
C.Constant _ -> raise ReferenceToConstant
| C.Variable _ -> raise ReferenceToVariable
| C.CurrentProof _ -> raise ReferenceToCurrentProof
if List.exists (function (uri',_) -> UriManager.eq uri' uri) ens then
reduce (0, [], [], RS.from_ens (List.assq uri ens), s)
else
- (match CicEnvironment.get_obj uri with
+ ( let o,_ =
+ CicEnvironment.get_cooked_obj uri CicUniv.empty_ugraph
+ in
+ match o with
C.Constant _ -> raise ReferenceToConstant
| C.CurrentProof _ -> raise ReferenceToCurrentProof
| C.InductiveDefinition _ -> raise ReferenceToInductiveDefinition
C.Appl (List.append (List.map (unwind k e ens) l) s)
*)
| (k, e, ens, (C.Const (uri,exp_named_subst) as t), s) ->
- (match CicEnvironment.get_obj uri with
+ (let o,_ =
+ CicEnvironment.get_cooked_obj uri CicUniv.empty_ugraph
+ in
+ match o with
C.Constant (_,Some body,_,_) ->
let ens' = push_exp_named_subst k e ens exp_named_subst in
(* constants are closed *)
reduce (k, e, ens, (List.nth pl (j-1)), s)
| C.Appl (C.MutConstruct (_,_,j,_) :: tl) ->
let (arity, r) =
- match CicEnvironment.get_obj mutind with
- C.InductiveDefinition (tl,ingredients,r) ->
- let (_,_,arity,_) = List.nth tl i in
- (arity,r)
- | _ -> raise WrongUriToInductiveDefinition
+ let o,_ =
+ CicEnvironment.get_cooked_obj mutind CicUniv.empty_ugraph
+ in
+ match o with
+ C.InductiveDefinition (tl,ingredients,r) ->
+ let (_,_,arity,_) = List.nth tl i in
+ (arity,r)
+ | _ -> raise WrongUriToInductiveDefinition
in
let ts =
let num_to_eat = r in
| (uri,t)::tl ->
push_exp_named_subst k e ((uri,RS.to_ens (unwind k e ens t))::ens) tl
in
- reduce
+ reduce
;;
-
- let rec whd ?(subst=[]) context t = reduce ~subst context (0, [], [], t, []);;
+ (*
+ let rec whd context t =
+ try
+ reduce context (0, [], [], t, [])
+ with Not_found ->
+ prerr_endline (CicPp.ppterm t) ;
+ raise Not_found
+ ;;
+ *)
+
+ let rec whd ?(subst=[]) context t =
+ reduce ~subst context (0, [], [], t, [])
+ ;;
+
(* DEBUGGING ONLY
let whd context t =
let (===) x y = (Pervasives.compare x y = 0)
(* t1, t2 must be well-typed *)
-let are_convertible ?(subst=[]) ?(metasenv=[]) =
- let rec aux test_equality_only context t1 t2 =
- let aux2 test_equality_only t1 t2 =
+let are_convertible ?(subst=[]) ?(metasenv=[]) =
+ let rec aux test_equality_only context t1 t2 ugraph =
+ let aux2 test_equality_only t1 t2 ugraph =
+
(* this trivial euristic cuts down the total time of about five times ;-) *)
(* this because most of the time t1 and t2 are "sintactically" the same *)
if t1 === t2 then
- true
+ true,ugraph
else
begin
let module C = Cic in
match (t1,t2) with
- (C.Rel n1, C.Rel n2) -> n1 = n2
+ (C.Rel n1, C.Rel n2) -> (n1 = n2),ugraph
| (C.Var (uri1,exp_named_subst1), C.Var (uri2,exp_named_subst2)) ->
- U.eq uri1 uri2 &&
+ if U.eq uri1 uri2 then
(try
List.fold_right2
- (fun (uri1,x) (uri2,y) b ->
- U.eq uri1 uri2 && aux test_equality_only context x y && b
- ) exp_named_subst1 exp_named_subst2 true
+ (fun (uri1,x) (uri2,y) (b,ugraph) ->
+ let b',ugraph' = aux test_equality_only context x y ugraph in
+ (U.eq uri1 uri2 && b' && b),ugraph'
+ ) exp_named_subst1 exp_named_subst2 (true,ugraph)
with
- Invalid_argument _ -> false
+ Invalid_argument _ -> false,ugraph
)
+ else
+ false,ugraph
| (C.Meta (n1,l1), C.Meta (n2,l2)) ->
- n1 = n2 &&
- let l1 = CicUtil.clean_up_local_context subst metasenv n1 l1 in
- let l2 = CicUtil.clean_up_local_context subst metasenv n2 l2 in
- List.fold_left2
- (fun b t1 t2 ->
- b &&
- match t1,t2 with
- None,_
- | _,None -> true
- | Some t1',Some t2' -> aux test_equality_only context t1' t2'
- ) true l1 l2
- (* TASSI: CONSTRAINTS *)
+ if n1 = n2 then
+ let b2, ugraph1 =
+ let l1 = CicUtil.clean_up_local_context subst metasenv n1 l1 in
+ let l2 = CicUtil.clean_up_local_context subst metasenv n2 l2 in
+ List.fold_left2
+ (fun (b,ugraph) t1 t2 ->
+ if b then
+ match t1,t2 with
+ None,_
+ | _,None -> true,ugraph
+ | Some t1',Some t2' ->
+ aux test_equality_only context t1' t2' ugraph
+ else
+ false,ugraph
+ ) (true,ugraph) l1 l2
+ in
+ if b2 then true,ugraph1 else false,ugraph
+ else
+ false,ugraph
+ (* TASSI: CONSTRAINTS *)
| (C.Sort (C.Type t1), C.Sort (C.Type t2)) when test_equality_only ->
- CicUniv.add_eq t2 t1
+ true,(CicUniv.add_eq t2 t1 ugraph)
(* TASSI: CONSTRAINTS *)
| (C.Sort (C.Type t1), C.Sort (C.Type t2)) ->
- CicUniv.add_ge t2 t1
+ true,(CicUniv.add_ge t2 t1 ugraph)
(* TASSI: CONSTRAINTS *)
- | (C.Sort s1, C.Sort (C.Type _)) -> not test_equality_only
+ | (C.Sort s1, C.Sort (C.Type _)) -> (not test_equality_only),ugraph
(* TASSI: CONSTRAINTS *)
- | (C.Sort s1, C.Sort s2) -> s1 = s2
- | (C.Prod (name1,s1,t1), C.Prod(_,s2,t2)) ->
- aux true context s1 s2 &&
- aux test_equality_only ((Some (name1, (C.Decl s1)))::context) t1 t2
+ | (C.Sort s1, C.Sort s2) -> (s1 = s2),ugraph
+ | (C.Prod (name1,s1,t1), C.Prod(_,s2,t2)) ->
+ let b',ugraph' = aux true context s1 s2 ugraph in
+ if b' then
+ aux test_equality_only ((Some (name1, (C.Decl s1)))::context)
+ t1 t2 ugraph'
+ else
+ false,ugraph
| (C.Lambda (name1,s1,t1), C.Lambda(_,s2,t2)) ->
- aux test_equality_only context s1 s2 &&
- aux test_equality_only ((Some (name1, (C.Decl s1)))::context) t1 t2
+ let b',ugraph' = aux test_equality_only context s1 s2 ugraph in
+ if b' then
+ aux test_equality_only ((Some (name1, (C.Decl s1)))::context)
+ t1 t2 ugraph'
+ else
+ false,ugraph
| (C.LetIn (name1,s1,t1), C.LetIn(_,s2,t2)) ->
- aux test_equality_only context s1 s2 &&
+ let b',ugraph' = aux test_equality_only context s1 s2 ugraph in
+ if b' then
aux test_equality_only
- ((Some (name1, (C.Def (s1,None))))::context) t1 t2
+ ((Some (name1, (C.Def (s1,None))))::context) t1 t2 ugraph'
+ else
+ false,ugraph
| (C.Appl l1, C.Appl l2) ->
(try
List.fold_right2
- (fun x y b -> aux test_equality_only context x y && b) l1 l2 true
+ (fun x y (b,ugraph) ->
+ if b then
+ aux test_equality_only context x y ugraph
+ else
+ false,ugraph) l1 l2 (true,ugraph)
with
- Invalid_argument _ -> false
+ Invalid_argument _ -> false,ugraph
)
| (C.Const (uri1,exp_named_subst1), C.Const (uri2,exp_named_subst2)) ->
- U.eq uri1 uri2 &&
+ let b' = U.eq uri1 uri2 in
+ if b' then
(try
List.fold_right2
- (fun (uri1,x) (uri2,y) b ->
- U.eq uri1 uri2 && aux test_equality_only context x y && b
- ) exp_named_subst1 exp_named_subst2 true
+ (fun (uri1,x) (uri2,y) (b,ugraph) ->
+ if b && U.eq uri1 uri2 then
+ aux test_equality_only context x y ugraph
+ else
+ false,ugraph
+ ) exp_named_subst1 exp_named_subst2 (true,ugraph)
with
- Invalid_argument _ -> false
+ Invalid_argument _ -> false,ugraph
)
+ else
+ false,ugraph
| (C.MutInd (uri1,i1,exp_named_subst1),
C.MutInd (uri2,i2,exp_named_subst2)
) ->
- U.eq uri1 uri2 && i1 = i2 &&
+ let b' = U.eq uri1 uri2 && i1 = i2 in
+ if b' then
(try
List.fold_right2
- (fun (uri1,x) (uri2,y) b ->
- U.eq uri1 uri2 && aux test_equality_only context x y && b
- ) exp_named_subst1 exp_named_subst2 true
+ (fun (uri1,x) (uri2,y) (b,ugraph) ->
+ if b && U.eq uri1 uri2 then
+ aux test_equality_only context x y ugraph
+ else
+ false,ugraph
+ ) exp_named_subst1 exp_named_subst2 (true,ugraph)
with
- Invalid_argument _ -> false
+ Invalid_argument _ -> false,ugraph
)
+ else
+ false,ugraph
| (C.MutConstruct (uri1,i1,j1,exp_named_subst1),
C.MutConstruct (uri2,i2,j2,exp_named_subst2)
) ->
- U.eq uri1 uri2 && i1 = i2 && j1 = j2 &&
+ let b' = U.eq uri1 uri2 && i1 = i2 && j1 = j2 in
+ if b' then
(try
List.fold_right2
- (fun (uri1,x) (uri2,y) b ->
- U.eq uri1 uri2 && aux test_equality_only context x y && b
- ) exp_named_subst1 exp_named_subst2 true
+ (fun (uri1,x) (uri2,y) (b,ugraph) ->
+ if b && U.eq uri1 uri2 then
+ aux test_equality_only context x y ugraph
+ else
+ false,ugraph
+ ) exp_named_subst1 exp_named_subst2 (true,ugraph)
with
- Invalid_argument _ -> false
+ Invalid_argument _ -> false,ugraph
)
+ else
+ false,ugraph
| (C.MutCase (uri1,i1,outtype1,term1,pl1),
C.MutCase (uri2,i2,outtype2,term2,pl2)) ->
- U.eq uri1 uri2 && i1 = i2 &&
- aux test_equality_only context outtype1 outtype2 &&
- aux test_equality_only context term1 term2 &&
- List.fold_right2
- (fun x y b -> b && aux test_equality_only context x y)
- pl1 pl2 true
+ let b' = U.eq uri1 uri2 && i1 = i2 in
+ if b' then
+ let b'',ugraph''=aux test_equality_only context
+ outtype1 outtype2 ugraph in
+ if b'' then
+ let b''',ugraph'''= aux test_equality_only context
+ term1 term2 ugraph'' in
+ List.fold_right2
+ (fun x y (b,ugraph) ->
+ if b then
+ aux test_equality_only context x y ugraph
+ else
+ false,ugraph)
+ pl1 pl2 (true,ugraph''')
+ else
+ false,ugraph
+ else
+ false,ugraph
| (C.Fix (i1,fl1), C.Fix (i2,fl2)) ->
- let tys =
- List.map (function (n,_,ty,_) -> Some (C.Name n,(C.Decl ty))) fl1
- in
- i1 = i2 &&
+ let tys =
+ List.map (function (n,_,ty,_) -> Some (C.Name n,(C.Decl ty))) fl1
+ in
+ if i1 = i2 then
List.fold_right2
- (fun (_,recindex1,ty1,bo1) (_,recindex2,ty2,bo2) b ->
- b && recindex1 = recindex2 &&
- aux test_equality_only context ty1 ty2 &&
- aux test_equality_only (tys@context) bo1 bo2)
- fl1 fl2 true
+ (fun (_,recindex1,ty1,bo1) (_,recindex2,ty2,bo2) (b,ugraph) ->
+ if b && recindex1 = recindex2 then
+ let b',ugraph' = aux test_equality_only context ty1 ty2
+ ugraph in
+ if b' then
+ aux test_equality_only (tys@context) bo1 bo2 ugraph'
+ else
+ false,ugraph
+ else
+ false,ugraph)
+ fl1 fl2 (true,ugraph)
+ else
+ false,ugraph
| (C.CoFix (i1,fl1), C.CoFix (i2,fl2)) ->
let tys =
List.map (function (n,ty,_) -> Some (C.Name n,(C.Decl ty))) fl1
in
- i1 = i2 &&
- List.fold_right2
- (fun (_,ty1,bo1) (_,ty2,bo2) b ->
- b && aux test_equality_only context ty1 ty2 &&
- aux test_equality_only (tys@context) bo1 bo2)
- fl1 fl2 true
+ if i1 = i2 then
+ List.fold_right2
+ (fun (_,ty1,bo1) (_,ty2,bo2) (b,ugraph) ->
+ if b then
+ let b',ugraph' = aux test_equality_only context ty1 ty2
+ ugraph in
+ if b' then
+ aux test_equality_only (tys@context) bo1 bo2 ugraph'
+ else
+ false,ugraph
+ else
+ false,ugraph)
+ fl1 fl2 (true,ugraph)
+ else
+ false,ugraph
| (C.Cast _, _) | (_, C.Cast _)
| (C.Implicit _, _) | (_, C.Implicit _) ->
assert false
- | (_,_) -> false
+ | (_,_) -> false,ugraph
end
in
-(*
- if aux2 test_equality_only t1 t2 then true
- else
-*)
begin
debug t1 [t2] "PREWHD";
(*
let t1' = whd ~subst context t1 in
let t2' = whd ~subst context t2 in
debug t1' [t2'] "POSTWHD";
- aux2 test_equality_only t1' t2'
+ aux2 test_equality_only t1' t2' ugraph
end
in
- aux false
+ aux false (*c t1 t2 ugraph *)
;;
+
exception ReferenceToInductiveDefinition
val fdebug : int ref
val whd : Cic.context -> Cic.term -> Cic.term
-val are_convertible : Cic.context -> Cic.term -> Cic.term -> bool
+val are_convertible : Cic.context -> Cic.term -> Cic.term -> CicUniv.universe_graph -> bool * CicUniv.universe_graph
| None -> raise RelToHiddenHypothesis
)
| C.Var (uri,exp_named_subst) as t ->
- (match CicEnvironment.get_cooked_obj ~trust:false uri with
+ let o,_ =
+ CicEnvironment.get_cooked_obj ~trust:false uri CicUniv.empty_ugraph
+ in
+ (match o with
C.Constant _ -> raise ReferenceToConstant
| C.CurrentProof _ -> raise ReferenceToCurrentProof
| C.InductiveDefinition _ -> raise ReferenceToInductiveDefinition
| C.Appl (he::tl) -> whdaux (tl@l) he
| C.Appl [] -> raise (Impossible 1)
| C.Const (uri,exp_named_subst) as t ->
- (match CicEnvironment.get_cooked_obj ~trust:false uri with
+ let o,_ =
+ CicEnvironment.get_cooked_obj ~trust:false uri CicUniv.empty_ugraph
+ in
+ (match o with
C.Constant (_,Some body,_,_) ->
whdaux l (CicSubstitution.subst_vars exp_named_subst body)
| C.Constant _ -> if l = [] then t else C.Appl (t::l)
C.MutConstruct (_,_,j,_) -> whdaux l (List.nth pl (j-1))
| C.Appl (C.MutConstruct (_,_,j,_) :: tl) ->
let (arity, r) =
- match CicEnvironment.get_obj mutind with
+ let o,_ = CicEnvironment.get_obj mutind CicUniv.empty_ugraph in
+ match o with
C.InductiveDefinition (tl,ingredients,r) ->
let (_,_,arity,_) = List.nth tl i in
(arity,r)
;;
(* t1, t2 must be well-typed *)
-let are_convertible =
+let are_convertible c t1 t2 ugraph =
let module U = UriManager in
- let rec aux test_equality_only context t1 t2 =
- let aux2 test_equality_only t1 t2 =
+ let rec aux test_equality_only context t1 t2 ugraph =
+ let aux2 test_equality_only t1 t2 ugraph =
(* this trivial euristic cuts down the total time of about five times ;-) *)
(* this because most of the time t1 and t2 are "sintactically" the same *)
if t1 = t2 then
- true
+ true,ugraph
else
begin
let module C = Cic in
match (t1,t2) with
- (C.Rel n1, C.Rel n2) -> n1 = n2
+ (C.Rel n1, C.Rel n2) -> (n1 = n2),ugraph
| (C.Var (uri1,exp_named_subst1), C.Var (uri2,exp_named_subst2)) ->
- U.eq uri1 uri2 &&
+ let b = U.eq uri1 uri2 in
+ if b then
(try
List.fold_right2
- (fun (uri1,x) (uri2,y) b ->
- U.eq uri1 uri2 && aux test_equality_only context x y && b
- ) exp_named_subst1 exp_named_subst2 true
+ (fun (uri1,x) (uri2,y) (b,ugraph) ->
+ (* FIXME: lazy! *)
+ let b',ugraph' = aux test_equality_only context x y ugraph in
+ (U.eq uri1 uri2 && b' && b),ugraph'
+ ) exp_named_subst1 exp_named_subst2 (true,ugraph)
with
- Invalid_argument _ -> false
+ Invalid_argument _ -> false,ugraph
)
+ else
+ false,ugraph
| (C.Meta (n1,l1), C.Meta (n2,l2)) ->
- n1 = n2 &&
+ let b = n1 = n2 in
+ if b then
List.fold_left2
- (fun b t1 t2 ->
- b &&
- match t1,t2 with
+ (fun (b,ugraph) t1 t2 ->
+ if b then
+ match t1,t2 with
None,_
- | _,None -> true
- | Some t1',Some t2' -> aux test_equality_only context t1' t2'
- ) true l1 l2
+ | _,None -> true,ugraph
+ | Some t1',Some t2' ->
+ aux test_equality_only context t1' t2' ugraph
+ else
+ false,ugraph
+ ) (true,ugraph) l1 l2
+ else
+ false,ugraph
(* TASSI: CONSTRAINTS *)
| (C.Sort (C.Type t1), C.Sort (C.Type t2)) when test_equality_only ->
- CicUniv.add_eq t2 t1
+ true,(CicUniv.add_eq t2 t1 ugraph)
(* TASSI: CONSTRAINTS *)
| (C.Sort (C.Type t1), C.Sort (C.Type t2)) ->
- CicUniv.add_ge t2 t1
+ true,(CicUniv.add_ge t2 t1 ugraph)
(* TASSI: CONSTRAINTS *)
- | (C.Sort s1, C.Sort (C.Type _)) -> not test_equality_only
+ | (C.Sort s1, C.Sort (C.Type _)) -> (not test_equality_only),ugraph
(* TASSI: CONSTRAINTS *)
- | (C.Sort s1, C.Sort s2) -> s1 = s2
+ | (C.Sort s1, C.Sort s2) -> (s1 = s2),ugraph
| (C.Prod (name1,s1,t1), C.Prod(_,s2,t2)) ->
- aux true context s1 s2 &&
- aux test_equality_only ((Some (name1, (C.Decl s1)))::context) t1 t2
+ let b',ugraph' = aux true context s1 s2 ugraph in
+ if b' then
+ aux test_equality_only ((Some (name1, (C.Decl s1)))::context)
+ t1 t2 ugraph'
+ else
+ false,ugraph
| (C.Lambda (name1,s1,t1), C.Lambda(_,s2,t2)) ->
- aux test_equality_only context s1 s2 &&
- aux test_equality_only ((Some (name1, (C.Decl s1)))::context) t1 t2
+ let b',ugraph' = aux test_equality_only context s1 s2 ugraph in
+ if b' then
+ aux test_equality_only ((Some (name1, (C.Decl s1)))::context)
+ t1 t2 ugraph'
+ else
+ false,ugraph
| (C.LetIn (name1,s1,t1), C.LetIn(_,s2,t2)) ->
- aux test_equality_only context s1 s2 &&
+ let b',ugraph' = aux test_equality_only context s1 s2 ugraph in
+ if b' then
aux test_equality_only
- ((Some (name1, (C.Def (s1,None))))::context) t1 t2
+ ((Some (name1, (C.Def (s1,None))))::context) t1 t2 ugraph'
+ else
+ false,ugraph
| (C.Appl l1, C.Appl l2) ->
(try
List.fold_right2
- (fun x y b -> aux test_equality_only context x y && b) l1 l2 true
+ (fun x y (b,ugraph) ->
+ if b then
+ aux test_equality_only context x y ugraph
+ else
+ false,ugraph) l1 l2 (true,ugraph)
with
- Invalid_argument _ -> false
+ Invalid_argument _ -> false,ugraph
)
| (C.Const (uri1,exp_named_subst1), C.Const (uri2,exp_named_subst2)) ->
- U.eq uri1 uri2 &&
+ let b' = U.eq uri1 uri2 in
+ if b' then
(try
List.fold_right2
- (fun (uri1,x) (uri2,y) b ->
- U.eq uri1 uri2 && aux test_equality_only context x y && b
- ) exp_named_subst1 exp_named_subst2 true
+ (fun (uri1,x) (uri2,y) (b,ugraph) ->
+ if b && U.eq uri1 uri2 then
+ aux test_equality_only context x y ugraph
+ else
+ false,ugraph
+ ) exp_named_subst1 exp_named_subst2 (true,ugraph)
with
- Invalid_argument _ -> false
+ Invalid_argument _ -> false,ugraph
)
+ else
+ false,ugraph
| (C.MutInd (uri1,i1,exp_named_subst1),
C.MutInd (uri2,i2,exp_named_subst2)
) ->
- U.eq uri1 uri2 && i1 = i2 &&
+ let b' = U.eq uri1 uri2 && i1 = i2 in
+ if b' then
(try
List.fold_right2
- (fun (uri1,x) (uri2,y) b ->
- U.eq uri1 uri2 && aux test_equality_only context x y && b
- ) exp_named_subst1 exp_named_subst2 true
+ (fun (uri1,x) (uri2,y) (b,ugraph) ->
+ if b && U.eq uri1 uri2 then
+ aux test_equality_only context x y ugraph
+ else
+ false,ugraph
+ ) exp_named_subst1 exp_named_subst2 (true,ugraph)
with
- Invalid_argument _ -> false
+ Invalid_argument _ -> false,ugraph
)
+ else
+ false,ugraph
| (C.MutConstruct (uri1,i1,j1,exp_named_subst1),
C.MutConstruct (uri2,i2,j2,exp_named_subst2)
) ->
- U.eq uri1 uri2 && i1 = i2 && j1 = j2 &&
+ let b' = U.eq uri1 uri2 && i1 = i2 && j1 = j2 in
+ if b' then
(try
List.fold_right2
- (fun (uri1,x) (uri2,y) b ->
- U.eq uri1 uri2 && aux test_equality_only context x y && b
- ) exp_named_subst1 exp_named_subst2 true
+ (fun (uri1,x) (uri2,y) (b,ugraph) ->
+ if b && U.eq uri1 uri2 then
+ aux test_equality_only context x y ugraph
+ else
+ false,ugraph
+ ) exp_named_subst1 exp_named_subst2 (true,ugraph)
with
- Invalid_argument _ -> false
+ Invalid_argument _ -> false,ugraph
)
+ else
+ false,ugraph
| (C.MutCase (uri1,i1,outtype1,term1,pl1),
C.MutCase (uri2,i2,outtype2,term2,pl2)) ->
- U.eq uri1 uri2 && i1 = i2 &&
- aux test_equality_only context outtype1 outtype2 &&
- aux test_equality_only context term1 term2 &&
- List.fold_right2
- (fun x y b -> b && aux test_equality_only context x y)
- pl1 pl2 true
+ let b' = U.eq uri1 uri2 && i1 = i2 in
+ if b' then
+ let b'',ugraph''=aux test_equality_only context
+ outtype1 outtype2 ugraph in
+ if b'' then
+ let b''',ugraph'''= aux test_equality_only context
+ term1 term2 ugraph'' in
+ List.fold_right2
+ (fun x y (b,ugraph) ->
+ if b then
+ aux test_equality_only context x y ugraph
+ else
+ false,ugraph)
+ pl1 pl2 (true,ugraph''')
+ else
+ false,ugraph
+ else
+ false,ugraph
| (C.Fix (i1,fl1), C.Fix (i2,fl2)) ->
let tys =
List.map (function (n,_,ty,_) -> Some (C.Name n,(C.Decl ty))) fl1
in
- i1 = i2 &&
+ if i1 = i2 then
List.fold_right2
- (fun (_,recindex1,ty1,bo1) (_,recindex2,ty2,bo2) b ->
- b && recindex1 = recindex2 &&
- aux test_equality_only context ty1 ty2 &&
- aux test_equality_only (tys@context) bo1 bo2)
- fl1 fl2 true
+ (fun (_,recindex1,ty1,bo1) (_,recindex2,ty2,bo2) (b,ugraph) ->
+ if b && recindex1 = recindex2 then
+ let b',ugraph' = aux test_equality_only context ty1 ty2
+ ugraph in
+ if b' then
+ aux test_equality_only (tys@context) bo1 bo2 ugraph'
+ else
+ false,ugraph
+ else
+ false,ugraph)
+ fl1 fl2 (true,ugraph)
+ else
+ false,ugraph
| (C.CoFix (i1,fl1), C.CoFix (i2,fl2)) ->
let tys =
List.map (function (n,ty,_) -> Some (C.Name n,(C.Decl ty))) fl1
in
- i1 = i2 &&
- List.fold_right2
- (fun (_,ty1,bo1) (_,ty2,bo2) b ->
- b && aux test_equality_only context ty1 ty2 &&
- aux test_equality_only (tys@context) bo1 bo2)
- fl1 fl2 true
+ if i1 = i2 then
+ List.fold_right2
+ (fun (_,ty1,bo1) (_,ty2,bo2) (b,ugraph) ->
+ if b then
+ let b',ugraph' = aux test_equality_only context ty1 ty2
+ ugraph in
+ if b' then
+ aux test_equality_only (tys@context) bo1 bo2 ugraph'
+ else
+ false,ugraph
+ else
+ false,ugraph)
+ fl1 fl2 (true,ugraph)
+ else
+ false,ugraph
| (C.Cast _, _) | (_, C.Cast _)
| (C.Implicit _, _) | (_, C.Implicit _) ->
assert false
- | (_,_) -> false
+ | (_,_) -> false,ugraph
end
in
- if aux2 test_equality_only t1 t2 then true
+ let b,ugraph' = aux2 test_equality_only t1 t2 ugraph in
+ if b then
+ b,ugraph'
else
begin
debug t1 [t2] "PREWHD";
let t1' = whd context t1 in
let t2' = whd context t2 in
debug t1' [t2'] "POSTWHD";
- aux2 test_equality_only t1' t2'
+ aux2 test_equality_only t1' t2' ugraph
end
in
- aux false
+ aux false c t1 t2 ugraph
;;
exception ReferenceToInductiveDefinition
val fdebug : int ref
val whd : Cic.context -> Cic.term -> Cic.term
-val are_convertible : Cic.context -> Cic.term -> Cic.term -> bool
+val are_convertible :
+ Cic.context -> Cic.term -> Cic.term ->
+ CicUniv.universe_graph -> bool * CicUniv.universe_graph
with
Not_found ->
let params =
- let obj = CicEnvironment.get_obj uri in
+ let obj,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
(match obj with
C.Constant _ -> raise ReferenceToConstant
| C.Variable (_,_,_,params) -> params
| C.Appl _ -> assert false
| C.Const (uri,exp_named_subst') ->
let params =
- let obj = CicEnvironment.get_obj uri in
+ let obj,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
(match obj with
C.Constant (_,_,_,params) -> params
| C.Variable _ -> raise ReferenceToVariable
C.Const (uri,exp_named_subst'')
| C.MutInd (uri,typeno,exp_named_subst') ->
let params =
- let obj = CicEnvironment.get_obj uri in
+ let obj,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
(match obj with
C.Constant _ -> raise ReferenceToConstant
| C.Variable _ -> raise ReferenceToVariable
C.MutInd (uri,typeno,exp_named_subst'')
| C.MutConstruct (uri,typeno,consno,exp_named_subst') ->
let params =
- let obj = CicEnvironment.get_obj uri in
+ let obj,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
(match obj with
C.Constant _ -> raise ReferenceToConstant
| C.Variable _ -> raise ReferenceToVariable
exception CicEnvironmentError;;
-let rec type_of_constant ~logger uri =
+let rec type_of_constant ~logger uri ugraph =
let module C = Cic in
let module R = CicReduction in
let module U = UriManager in
- let cobj =
- match CicEnvironment.is_type_checked ~trust:true uri with
- CicEnvironment.CheckedObj cobj -> cobj
+ let cobj,ugraph =
+ match CicEnvironment.is_type_checked ~trust:true uri ugraph with
+ CicEnvironment.CheckedObj (cobj,ugraph') -> cobj,ugraph'
| CicEnvironment.UncheckedObj uobj ->
logger#log (`Start_type_checking uri) ;
- CicUniv.directly_to_env_begin ();
(* let's typecheck the uncooked obj *)
- (match uobj with
+
+(****************************************************************
+ TASSI: FIXME qui e' inutile ricordarselo,
+ tanto poi lo richiediamo alla cache che da quello su disco
+*****************************************************************)
+
+ let ugraph_dust =
+ (match uobj with
C.Constant (_,Some te,ty,_) ->
- let _ = type_of ~logger ty in
- let type_of_te = type_of ~logger te in
- if not (R.are_convertible [] type_of_te ty) then
+ let _,ugraph = type_of ~logger ty ugraph in
+ let type_of_te,ugraph' = type_of ~logger te ugraph in
+ let b',ugraph'' = (R.are_convertible [] type_of_te ty ugraph') in
+ if not b' then
raise (TypeCheckerFailure (sprintf
"the constant %s is not well typed because the type %s of the body is not convertible to the declared type %s"
(U.string_of_uri uri) (CicPp.ppterm type_of_te)
(CicPp.ppterm ty)))
+ else
+ ugraph'
| C.Constant (_,None,ty,_) ->
(* only to check that ty is well-typed *)
- let _ = type_of ty in ()
+ let _,ugraph' = type_of ~logger ty ugraph in
+ ugraph'
| C.CurrentProof (_,conjs,te,ty,_) ->
- let _ =
+ let _,ugraph1 =
List.fold_left
- (fun metasenv ((_,context,ty) as conj) ->
- ignore (type_of_aux' ~logger metasenv context ty) ;
- metasenv @ [conj]
- ) [] conjs
+ (fun (metasenv,ugraph) ((_,context,ty) as conj) ->
+ let _,ugraph' =
+ type_of_aux' ~logger metasenv context ty ugraph
+ in
+ (metasenv @ [conj],ugraph')
+ ) ([],ugraph) conjs
in
- let _ = type_of_aux' ~logger conjs [] ty in
- let type_of_te = type_of_aux' ~logger conjs [] te in
- if not (R.are_convertible [] type_of_te ty) then
+ let _,ugraph2 = type_of_aux' ~logger conjs [] ty ugraph1 in
+ let type_of_te,ugraph3 =
+ type_of_aux' ~logger conjs [] te ugraph2
+ in
+ let b,ugraph4 = (R.are_convertible [] type_of_te ty ugraph3) in
+ if not b then
raise (TypeCheckerFailure (sprintf
"the current proof %s is not well typed because the type %s of the body is not convertible to the declared type %s"
(U.string_of_uri uri) (CicPp.ppterm type_of_te)
(CicPp.ppterm ty)))
+ else
+ ugraph4
| _ ->
- raise (TypeCheckerFailure
- ("Unknown constant:" ^ U.string_of_uri uri))
- );
- CicEnvironment.set_type_checking_info uri ;
- CicUniv.directly_to_env_end ();
- logger#log (`Type_checking_completed uri) ;
- match CicEnvironment.is_type_checked ~trust:false uri with
- CicEnvironment.CheckedObj cobj -> cobj
- | CicEnvironment.UncheckedObj _ -> raise CicEnvironmentError
+ raise (TypeCheckerFailure
+ ("Unknown constant:" ^ U.string_of_uri uri)))
+ in
+ try
+ CicEnvironment.set_type_checking_info uri;
+ logger#log (`Type_checking_completed uri) ;
+ match CicEnvironment.is_type_checked ~trust:false uri ugraph with
+ CicEnvironment.CheckedObj (cobj,ugraph') -> cobj,ugraph'
+ | CicEnvironment.UncheckedObj _ -> raise CicEnvironmentError
+ with Invalid_argument s ->
+ (*prerr_endline s;*)
+ uobj,ugraph_dust
in
- match cobj with
- C.Constant (_,_,ty,_) -> ty
- | C.CurrentProof (_,_,_,ty,_) -> ty
+ match cobj,ugraph with
+ (C.Constant (_,_,ty,_)),g -> ty,g
+ | (C.CurrentProof (_,_,_,ty,_)),g -> ty,g
| _ ->
raise (TypeCheckerFailure ("Unknown constant:" ^ U.string_of_uri uri))
-and type_of_variable ~logger uri =
+and type_of_variable ~logger uri ugraph =
let module C = Cic in
let module R = CicReduction in
let module U = UriManager in
(* 0 because a variable is never cooked => no partial cooking at one level *)
- match CicEnvironment.is_type_checked ~trust:true uri with
- CicEnvironment.CheckedObj (C.Variable (_,_,ty,_)) -> ty
+ match CicEnvironment.is_type_checked ~trust:true uri ugraph with
+ CicEnvironment.CheckedObj ((C.Variable (_,_,ty,_)),ugraph') -> ty,ugraph'
| CicEnvironment.UncheckedObj (C.Variable (_,bo,ty,_)) ->
logger#log (`Start_type_checking uri) ;
- CicUniv.directly_to_env_begin ();
(* only to check that ty is well-typed *)
- let _ = type_of ty in
+ let _,ugraph1 = type_of ~logger ty ugraph in
+ let ugraph2 =
(match bo with
- None -> ()
+ None -> ugraph
| Some bo ->
- if not (R.are_convertible [] (type_of ~logger bo) ty) then
+ let ty_bo,ugraph' = type_of ~logger bo ugraph1 in
+ let b,ugraph'' = (R.are_convertible [] ty_bo ty ugraph') in
+ if not b then
raise (TypeCheckerFailure
("Unknown variable:" ^ U.string_of_uri uri))
- ) ;
- CicEnvironment.set_type_checking_info uri ;
- CicUniv.directly_to_env_end ();
- logger#log (`Type_checking_completed uri) ;
- ty
+ else
+ ugraph'')
+ in
+ (try
+ CicEnvironment.set_type_checking_info uri ;
+ logger#log (`Type_checking_completed uri) ;
+ match CicEnvironment.is_type_checked ~trust:false uri ugraph with
+ CicEnvironment.CheckedObj ((C.Variable (_,_,ty,_)),ugraph') ->
+ ty,ugraph'
+ | CicEnvironment.CheckedObj _
+ | CicEnvironment.UncheckedObj _ -> raise CicEnvironmentError
+ with Invalid_argument s ->
+ (*prerr_endline s;*)
+ ty,ugraph2)
| _ ->
- raise (TypeCheckerFailure ("Unknown variable:" ^ U.string_of_uri uri))
+ raise (TypeCheckerFailure ("Unknown variable:" ^ U.string_of_uri uri))
and does_not_occur context n nn te =
let module C = Cic in
List.fold_right (fun x i -> i && does_not_occur context n nn x) tl true
| C.Appl ((C.MutInd (uri,i,exp_named_subst))::tl) ->
let (ok,paramsno,ity,cl,name) =
- match CicEnvironment.get_obj uri with
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.InductiveDefinition (tl,_,paramsno) ->
let (name,_,ity,cl) = List.nth tl i in
(List.length tl = 1, paramsno, ity, cl, name)
(* Main function to checks the correctness of a mutual *)
(* inductive block definition. This is the function *)
(* exported to the proof-engine. *)
-and typecheck_mutual_inductive_defs ~logger uri (itl,_,indparamsno) =
+and typecheck_mutual_inductive_defs ~logger uri (itl,_,indparamsno) ugraph =
let module U = UriManager in
(* let's check if the arity of the inductive types are well *)
(* formed *)
- List.iter (fun (_,_,x,_) -> let _ = type_of ~logger x in ()) itl ;
+ let ugrap1 = List.fold_left
+ (fun ugraph (_,_,x,_) -> let _,ugraph' =
+ type_of ~logger x ugraph in ugraph')
+ ugraph itl in
(* let's check if the types of the inductive constructors *)
(* are well formed. *)
(* mutual inductive types at the head of the types of the *)
(* constructors using Prods *)
let len = List.length itl in
- let tys =
+ let tys =
List.map (fun (n,_,ty,_) -> Some (Cic.Name n,(Cic.Decl ty))) itl in
- let _ =
+ let _,ugraph2 =
List.fold_right
- (fun (_,_,_,cl) i ->
- List.iter
- (fun (name,te) ->
- let debrujinedte = debrujin_constructor uri len te in
- let augmented_term =
- List.fold_right
- (fun (name,_,ty,_) i -> Cic.Prod (Cic.Name name, ty, i))
- itl debrujinedte
- in
- let _ = type_of augmented_term in
- (* let's check also the positivity conditions *)
- if
- not
- (are_all_occurrences_positive tys uri indparamsno i 0 len
- debrujinedte)
- then
- raise
- (TypeCheckerFailure ("Non positive occurence in " ^
- U.string_of_uri uri))
- ) cl ;
- (i + 1)
- ) itl 1
- in
- ()
+ (fun (_,_,_,cl) (i,ugraph) ->
+ let ugraph'' =
+ List.fold_left
+ (fun ugraph (name,te) ->
+ let debrujinedte = debrujin_constructor uri len te in
+ let augmented_term =
+ List.fold_right
+ (fun (name,_,ty,_) i -> Cic.Prod (Cic.Name name, ty, i))
+ itl debrujinedte
+ in
+ let _,ugraph' = type_of ~logger augmented_term ugraph in
+ (* let's check also the positivity conditions *)
+ if
+ not
+ (are_all_occurrences_positive tys uri indparamsno i 0 len
+ debrujinedte)
+ then
+ raise
+ (TypeCheckerFailure ("Non positive occurence in " ^
+ U.string_of_uri uri))
+ else
+ ugraph'
+ ) ugraph cl in
+ (i + 1),ugraph''
+ ) itl (1,ugraph)
+ in
+ ugraph2
(* Main function to checks the correctness of a mutual *)
(* inductive block definition. *)
-and check_mutual_inductive_defs uri =
- function
- Cic.InductiveDefinition (itl, params, indparamsno) ->
- typecheck_mutual_inductive_defs uri (itl,params,indparamsno)
- | _ ->
- raise (TypeCheckerFailure ("Unknown mutual inductive definition:" ^
- UriManager.string_of_uri uri))
+and check_mutual_inductive_defs uri obj ugraph =
+ match obj with
+ Cic.InductiveDefinition (itl, params, indparamsno) ->
+ typecheck_mutual_inductive_defs uri (itl,params,indparamsno) ugraph
+ | _ ->
+ raise (TypeCheckerFailure (
+ "Unknown mutual inductive definition:" ^
+ UriManager.string_of_uri uri))
-and type_of_mutual_inductive_defs ~logger uri i =
+and type_of_mutual_inductive_defs ~logger uri i ugraph =
let module C = Cic in
let module R = CicReduction in
let module U = UriManager in
- let cobj =
- match CicEnvironment.is_type_checked ~trust:true uri with
- CicEnvironment.CheckedObj cobj -> cobj
- | CicEnvironment.UncheckedObj uobj ->
- logger#log (`Start_type_checking uri) ;
- CicUniv.directly_to_env_begin ();
- check_mutual_inductive_defs ~logger uri uobj ;
- CicEnvironment.set_type_checking_info uri ;
- CicUniv.directly_to_env_end ();
- logger#log (`Type_checking_completed uri) ;
- (match CicEnvironment.is_type_checked ~trust:false uri with
- CicEnvironment.CheckedObj cobj -> cobj
- | CicEnvironment.UncheckedObj _ -> raise CicEnvironmentError
- )
+ let cobj,ugraph1 =
+ match CicEnvironment.is_type_checked ~trust:true uri ugraph with
+ CicEnvironment.CheckedObj (cobj,ugraph') -> cobj,ugraph'
+ | CicEnvironment.UncheckedObj uobj ->
+ logger#log (`Start_type_checking uri) ;
+ let ugraph1_dust =
+ check_mutual_inductive_defs ~logger uri uobj ugraph
+ in
+ (* TASSI: FIXME: check ugraph1 == ugraph ritornato da env *)
+ try
+ CicEnvironment.set_type_checking_info uri ;
+ logger#log (`Type_checking_completed uri) ;
+ (match CicEnvironment.is_type_checked ~trust:false uri ugraph with
+ CicEnvironment.CheckedObj (cobj,ugraph') -> (cobj,ugraph')
+ | CicEnvironment.UncheckedObj _ -> raise CicEnvironmentError
+ )
+ with
+ Invalid_argument s ->
+ (*prerr_endline s;*)
+ uobj,ugraph1_dust
in
- match cobj with
- C.InductiveDefinition (dl,_,_) ->
- let (_,_,arity,_) = List.nth dl i in
- arity
- | _ ->
- raise (TypeCheckerFailure ("Unknown mutual inductive definition:" ^
- U.string_of_uri uri))
-
-and type_of_mutual_inductive_constr ~logger uri i j =
+ match cobj with
+ C.InductiveDefinition (dl,_,_) ->
+ let (_,_,arity,_) = List.nth dl i in
+ arity,ugraph1
+ | _ ->
+ raise (TypeCheckerFailure ("Unknown mutual inductive definition:" ^
+ U.string_of_uri uri))
+
+and type_of_mutual_inductive_constr ~logger uri i j ugraph =
let module C = Cic in
let module R = CicReduction in
let module U = UriManager in
- let cobj =
- match CicEnvironment.is_type_checked ~trust:true uri with
- CicEnvironment.CheckedObj cobj -> cobj
- | CicEnvironment.UncheckedObj uobj ->
- logger#log (`Start_type_checking uri) ;
- (*CicUniv.directly_to_env_begin ();*)
- check_mutual_inductive_defs ~logger uri uobj ;
- CicEnvironment.set_type_checking_info uri ;
- (*CicUniv.directly_to_env_end ();*)
- logger#log (`Type_checking_completed uri) ;
- (match CicEnvironment.is_type_checked ~trust:false uri with
- CicEnvironment.CheckedObj cobj -> cobj
- | CicEnvironment.UncheckedObj _ -> raise CicEnvironmentError
- )
+ let cobj,ugraph1 =
+ match CicEnvironment.is_type_checked ~trust:true uri ugraph with
+ CicEnvironment.CheckedObj (cobj,ugraph') -> cobj,ugraph'
+ | CicEnvironment.UncheckedObj uobj ->
+ logger#log (`Start_type_checking uri) ;
+ let ugraph1_dust =
+ check_mutual_inductive_defs ~logger uri uobj ugraph
+ in
+ (* check ugraph1 validity ??? == ugraph' *)
+ try
+ CicEnvironment.set_type_checking_info uri ;
+ logger#log (`Type_checking_completed uri) ;
+ (match CicEnvironment.is_type_checked
+ ~trust:false uri ugraph with
+ CicEnvironment.CheckedObj (cobj,ugraph') -> cobj,ugraph'
+ | CicEnvironment.UncheckedObj _ ->
+ raise CicEnvironmentError)
+ with
+ Invalid_argument s ->
+ (*prerr_endline s;*)
+ uobj,ugraph1_dust
in
- match cobj with
- C.InductiveDefinition (dl,_,_) ->
- let (_,_,_,cl) = List.nth dl i in
- let (_,ty) = List.nth cl (j-1) in
- ty
- | _ ->
- raise (TypeCheckerFailure ("Unknown mutual inductive definition:" ^
- UriManager.string_of_uri uri))
+ match cobj with
+ C.InductiveDefinition (dl,_,_) ->
+ let (_,_,_,cl) = List.nth dl i in
+ let (_,ty) = List.nth cl (j-1) in
+ ty,ugraph1
+ | _ ->
+ raise (TypeCheckerFailure ("Unknown mutual inductive definition:" ^
+ UriManager.string_of_uri uri))
and recursive_args context n nn te =
let module C = Cic in
(match term with
C.Rel m when List.mem m safes || m = x ->
let (tys,len,isinductive,paramsno,cl) =
- match CicEnvironment.get_obj uri with
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.InductiveDefinition (tl,_,paramsno) ->
let tys =
List.map
) (List.combine pl cl) true
| C.Appl ((C.Rel m)::tl) when List.mem m safes || m = x ->
let (tys,len,isinductive,paramsno,cl) =
- match CicEnvironment.get_obj uri with
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.InductiveDefinition (tl,_,paramsno) ->
let (_,isinductive,_,cl) = List.nth tl i in
let tys =
(match term with
C.Rel m when List.mem m safes || m = x ->
let (tys,len,isinductive,paramsno,cl) =
- match CicEnvironment.get_obj uri with
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.InductiveDefinition (tl,_,paramsno) ->
let len = List.length tl in
let (_,isinductive,_,cl) = List.nth tl i in
) (List.combine pl cl) true
| C.Appl ((C.Rel m)::tl) when List.mem m safes || m = x ->
let (tys,len,isinductive,paramsno,cl) =
- match CicEnvironment.get_obj uri with
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.InductiveDefinition (tl,_,paramsno) ->
let (_,isinductive,_,cl) = List.nth tl i in
let tys =
List.fold_right (fun x i -> i && does_not_occur context n nn x) tl true
| C.Appl ((C.MutConstruct (uri,i,j,exp_named_subst))::tl) ->
let consty =
- let obj =
- try
- CicEnvironment.get_cooked_obj ~trust:false uri
- with Not_found -> assert false
- in
+ let obj,_ =
+ try
+ CicEnvironment.get_cooked_obj ~trust:false uri CicUniv.empty_ugraph
+ with Not_found -> assert false
+ in
match obj with
C.InductiveDefinition (itl,_,_) ->
let (_,_,_,cl) = List.nth itl i in
args coInductiveTypeURI
) fl true
-and check_allowed_sort_elimination ~logger context uri i need_dummy ind arity1 arity2 =
+and check_allowed_sort_elimination ~logger context uri i need_dummy ind
+ arity1 arity2 ugraph =
let module C = Cic in
let module U = UriManager in
match (CicReduction.whd context arity1, CicReduction.whd context arity2) with
- (C.Prod (_,so1,de1), C.Prod (_,so2,de2))
- when CicReduction.are_convertible context so1 so2 ->
- check_allowed_sort_elimination ~logger context uri i need_dummy
- (C.Appl [CicSubstitution.lift 1 ind ; C.Rel 1]) de1 de2
- | (C.Sort C.Prop, C.Sort C.Prop) when need_dummy -> true
+ (C.Prod (_,so1,de1), C.Prod (_,so2,de2)) ->
+ let b,ugraph1 = CicReduction.are_convertible context so1 so2 ugraph in
+ if b then
+ check_allowed_sort_elimination ~logger context uri i need_dummy
+ (C.Appl [CicSubstitution.lift 1 ind ; C.Rel 1]) de1 de2 ugraph1
+ else
+ false,ugraph1
+ | (C.Sort C.Prop, C.Sort C.Prop) when need_dummy -> true,ugraph
| (C.Sort C.Prop, C.Sort C.Set)
| (C.Sort C.Prop, C.Sort C.CProp)
| (C.Sort C.Prop, C.Sort (C.Type _) ) when need_dummy ->
(* TASSI: da verificare *)
(*CSC: WRONG. MISSING CONDITIONS ON THE ARGUMENTS OF THE CONSTRUTOR *)
- (match CicEnvironment.get_obj uri with
- C.InductiveDefinition (itl,_,_) ->
- let (_,_,_,cl) = List.nth itl i in
- (* is a singleton definition or the empty proposition? *)
- List.length cl = 1 || List.length cl = 0
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
+ C.InductiveDefinition (itl,_,_) ->
+ let (_,_,_,cl) = List.nth itl i in
+ (* is a singleton definition or the empty proposition? *)
+ (List.length cl = 1 || List.length cl = 0) , ugraph
| _ ->
- raise (TypeCheckerFailure ("Unknown mutual inductive definition:" ^
- UriManager.string_of_uri uri))
+ raise (TypeCheckerFailure
+ ("Unknown mutual inductive definition:" ^
+ UriManager.string_of_uri uri))
)
- | (C.Sort C.Set, C.Sort C.Prop) when need_dummy -> true
- | (C.Sort C.CProp, C.Sort C.Prop) when need_dummy -> true
- | (C.Sort C.Set, C.Sort C.Set) when need_dummy -> true
- | (C.Sort C.Set, C.Sort C.CProp) when need_dummy -> true
- | (C.Sort C.CProp, C.Sort C.Set) when need_dummy -> true
- | (C.Sort C.CProp, C.Sort C.CProp) when need_dummy -> true
+ | (C.Sort C.Set, C.Sort C.Prop) when need_dummy -> true , ugraph
+ | (C.Sort C.CProp, C.Sort C.Prop) when need_dummy -> true , ugraph
+ | (C.Sort C.Set, C.Sort C.Set) when need_dummy -> true , ugraph
+ | (C.Sort C.Set, C.Sort C.CProp) when need_dummy -> true , ugraph
+ | (C.Sort C.CProp, C.Sort C.Set) when need_dummy -> true , ugraph
+ | (C.Sort C.CProp, C.Sort C.CProp) when need_dummy -> true , ugraph
| ((C.Sort C.Set, C.Sort (C.Type _)) | (C.Sort C.CProp, C.Sort (C.Type _)))
(* TASSI: da verificare *)
when need_dummy ->
- (match CicEnvironment.get_obj uri with
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.InductiveDefinition (itl,_,paramsno) ->
let tys =
List.map (fun (n,_,ty,_) -> Some (Cic.Name n,(Cic.Decl ty))) itl
in
let (_,_,_,cl) = List.nth itl i in
- List.fold_right
- (fun (_,x) i -> i && is_small ~logger tys paramsno x) cl true
- | _ ->
+ (List.fold_right
+ (fun (_,x) (i,ugraph) ->
+ if i then
+ is_small ~logger tys paramsno x ugraph
+ else
+ false,ugraph
+ ) cl (true,ugraph))
+ | _ ->
raise (TypeCheckerFailure ("Unknown mutual inductive definition:" ^
UriManager.string_of_uri uri))
)
- | (C.Sort (C.Type _), C.Sort _) when need_dummy -> true
+ | (C.Sort (C.Type _), C.Sort _) when need_dummy -> true , ugraph
(* TASSI: da verificare *)
| (C.Sort C.Prop, C.Prod (name,so,ta)) when not need_dummy ->
- let res = CicReduction.are_convertible context so ind
- in
- res &&
- (match CicReduction.whd ((Some (name,(C.Decl so)))::context) ta with
- C.Sort C.Prop -> true
- | (C.Sort C.Set | C.Sort C.CProp) ->
- (match CicEnvironment.get_obj uri with
- C.InductiveDefinition (itl,_,_) ->
- let (_,_,_,cl) = List.nth itl i in
+ let b,ugraph1 = CicReduction.are_convertible context so ind ugraph in
+ if not b then
+ false,ugraph1
+ else
+ (match CicReduction.whd ((Some (name,(C.Decl so)))::context) ta with
+ C.Sort C.Prop -> true,ugraph1
+ | (C.Sort C.Set | C.Sort C.CProp) ->
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
+ C.InductiveDefinition (itl,_,_) ->
+ let (_,_,_,cl) = List.nth itl i in
(* is a singleton definition? *)
- List.length cl = 1
- | _ ->
- raise (TypeCheckerFailure
- ("Unknown mutual inductive definition:" ^
- UriManager.string_of_uri uri))
+ List.length cl = 1,ugraph1
+ | _ ->
+ raise (TypeCheckerFailure
+ ("Unknown mutual inductive definition:" ^
+ UriManager.string_of_uri uri))
)
- | _ -> false
- )
- | ((C.Sort C.Set, C.Prod (name,so,ta)) | (C.Sort C.CProp, C.Prod (name,so,ta)))
- when not need_dummy ->
- let res = CicReduction.are_convertible context so ind
- in
- res &&
- (match CicReduction.whd ((Some (name,(C.Decl so)))::context) ta with
- C.Sort C.Prop
- | C.Sort C.Set -> true
- | C.Sort C.CProp -> true
- | C.Sort (C.Type _) ->
- (* TASSI: da verificare *)
- (match CicEnvironment.get_obj uri with
- C.InductiveDefinition (itl,_,paramsno) ->
- let (_,_,_,cl) = List.nth itl i in
- let tys =
- List.map
+ | _ -> false,ugraph1
+ )
+ | ((C.Sort C.Set, C.Prod (name,so,ta))
+ | (C.Sort C.CProp, C.Prod (name,so,ta)))
+ when not need_dummy ->
+ let b,ugraph1 = CicReduction.are_convertible context so ind ugraph in
+ if not b then
+ false,ugraph1
+ else
+ (match CicReduction.whd ((Some (name,(C.Decl so)))::context) ta with
+ C.Sort C.Prop
+ | C.Sort C.Set -> true,ugraph1
+ | C.Sort C.CProp -> true,ugraph1
+ | C.Sort (C.Type _) ->
+ (* TASSI: da verificare *)
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
+ C.InductiveDefinition (itl,_,paramsno) ->
+ let (_,_,_,cl) = List.nth itl i in
+ let tys =
+ List.map
(fun (n,_,ty,_) -> Some (Cic.Name n,(Cic.Decl ty))) itl
- in
- List.fold_right
- (fun (_,x) i -> i && is_small ~logger tys paramsno x) cl true
- | _ ->
- raise (TypeCheckerFailure
- ("Unknown mutual inductive definition:" ^
- UriManager.string_of_uri uri))
+ in
+ (List.fold_right
+ (fun (_,x) (i,ugraph) ->
+ if i then
+ is_small ~logger tys paramsno x ugraph
+ else
+ false,ugraph
+ ) cl (true,ugraph1))
+ | _ ->
+ raise (TypeCheckerFailure
+ ("Unknown mutual inductive definition:" ^
+ UriManager.string_of_uri uri))
)
- | _ -> raise (AssertFailure "19")
- )
+ | _ -> raise (AssertFailure "19")
+ )
| (C.Sort (C.Type _), C.Prod (_,so,_)) when not need_dummy ->
- (* TASSI: da verificare *)
- CicReduction.are_convertible context so ind
- | (_,_) -> false
-
+ (* TASSI: da verificare *)
+ CicReduction.are_convertible context so ind ugraph
+ | (_,_) -> false,ugraph
+
and type_of_branch context argsno need_dummy outtype term constype =
let module C = Cic in
let module R = CicReduction in
metavariable is consitent - up to relocation via the relocation list l -
with the actual context *)
-and check_metasenv_consistency ~logger ?(subst=[]) metasenv context
- canonical_context l
+
+and check_metasenv_consistency ~logger ?(subst=[]) metasenv context
+ canonical_context l ugraph
=
let module C = Cic in
let module R = CicReduction in
let module S = CicSubstitution in
- let lifted_canonical_context =
+ let lifted_canonical_context =
let rec aux i =
function
- [] -> []
- | (Some (n,C.Decl t))::tl ->
- (Some (n,C.Decl (S.lift_meta l (S.lift i t))))::(aux (i+1) tl)
- | (Some (n,C.Def (t,None)))::tl ->
- (Some (n,C.Def ((S.lift_meta l (S.lift i t)),None)))::(aux (i+1) tl)
- | None::tl -> None::(aux (i+1) tl)
- | (Some (n,C.Def (t,Some ty)))::tl ->
- (Some (n,C.Def ((S.lift_meta l (S.lift i t)),Some (S.lift_meta l (S.lift i ty)))))::(aux (i+1) tl)
+ [] -> []
+ | (Some (n,C.Decl t))::tl ->
+ (Some (n,C.Decl (S.lift_meta l (S.lift i t))))::(aux (i+1) tl)
+ | (Some (n,C.Def (t,None)))::tl ->
+ (Some (n,C.Def ((S.lift_meta l (S.lift i t)),None)))::(aux (i+1) tl)
+ | None::tl -> None::(aux (i+1) tl)
+ | (Some (n,C.Def (t,Some ty)))::tl ->
+ (Some (n,C.Def ((S.lift_meta l (S.lift i t)),Some (S.lift_meta l (S.lift i ty)))))::(aux (i+1) tl)
in
- aux 1 canonical_context
+ aux 1 canonical_context
in
- List.iter2
- (fun t ct ->
- match (t,ct) with
- | _,None -> ()
- | Some t,Some (_,C.Def (ct,_)) ->
- if not (R.are_convertible ~subst ~metasenv context t ct) then
- raise (TypeCheckerFailure (sprintf
- "Not well typed metavariable local context: expected a term convertible with %s, found %s"
- (CicPp.ppterm ct) (CicPp.ppterm t)))
- | Some t,Some (_,C.Decl ct) ->
- let type_t = type_of_aux' ~logger ~subst metasenv context t in
- if not (R.are_convertible ~subst ~metasenv context type_t ct) then
- (* debug *)
- raise (TypeCheckerFailure (sprintf
- "Not well typed metavariable local context: expected a term of type %s, found %s of type %s"
- (CicPp.ppterm ct) (CicPp.ppterm t) (CicPp.ppterm type_t)))
- | None, _ ->
- raise (TypeCheckerFailure
- "Not well typed metavariable local context: an hypothesis, that is not hidden, is not instantiated")
- ) l lifted_canonical_context
+ List.fold_left2
+ (fun ugraph t ct ->
+ match (t,ct) with
+ | _,None -> ugraph
+ | Some t,Some (_,C.Def (ct,_)) ->
+ let b,ugraph1 =
+ R.are_convertible ~subst ~metasenv context t ct ugraph
+ in
+ if not b then
+ raise
+ (TypeCheckerFailure
+ (sprintf "Not well typed metavariable local context: expected a term convertible with %s, found %s" (CicPp.ppterm ct) (CicPp.ppterm t)))
+ else
+ ugraph1
+ | Some t,Some (_,C.Decl ct) ->
+ let type_t,ugraph1 =
+ type_of_aux' ~logger ~subst metasenv context t ugraph
+ in
+ let b,ugraph2 =
+ R.are_convertible ~subst ~metasenv context type_t ct ugraph1
+ in
+ if not b then
+ raise (TypeCheckerFailure
+ (sprintf "Not well typed metavariable local context: expected a term of type %s, found %s of type %s"
+ (CicPp.ppterm ct) (CicPp.ppterm t)
+ (CicPp.ppterm type_t)))
+ else
+ ugraph2
+ | None, _ ->
+ raise (TypeCheckerFailure
+ ("Not well typed metavariable local context: "^
+ "an hypothesis, that is not hidden, is not instantiated"))
+ ) ugraph l lifted_canonical_context
+
+
+(*
+ type_of_aux' is just another name (with a different scope)
+ for type_of_aux
+*)
-(* type_of_aux' is just another name (with a different scope) for type_of_aux *)
-and type_of_aux' ~logger ?(subst = []) metasenv context t =
- let rec type_of_aux ~logger context =
+and type_of_aux' ~logger ?(subst = []) metasenv context t ugraph =
+ let rec type_of_aux ~logger context t ugraph =
let module C = Cic in
let module R = CicReduction in
let module S = CicSubstitution in
let module U = UriManager in
- function
+ match t with
C.Rel n ->
(try
match List.nth context (n - 1) with
- Some (_,C.Decl t) -> S.lift n t
- | Some (_,C.Def (_,Some ty)) -> S.lift n ty
+ Some (_,C.Decl t) -> S.lift n t,ugraph
+ | Some (_,C.Def (_,Some ty)) -> S.lift n ty,ugraph
| Some (_,C.Def (bo,None)) ->
debug_print "##### CASO DA INVESTIGARE E CAPIRE" ;
- type_of_aux ~logger context (S.lift n bo)
- | None -> raise (TypeCheckerFailure "Reference to deleted hypothesis")
+ type_of_aux ~logger context (S.lift n bo) ugraph
+ | None -> raise
+ (TypeCheckerFailure "Reference to deleted hypothesis")
with
_ ->
raise (TypeCheckerFailure "unbound variable")
)
| C.Var (uri,exp_named_subst) ->
incr fdebug ;
- check_exp_named_subst ~logger ~subst context exp_named_subst ;
- let ty =
- CicSubstitution.subst_vars exp_named_subst (type_of_variable ~logger uri)
- in
- decr fdebug ;
- ty
+ let ugraph1 =
+ check_exp_named_subst ~logger ~subst context exp_named_subst ugraph
+ in
+ let ty,ugraph2 = type_of_variable ~logger uri ugraph1 in
+ let ty1 = CicSubstitution.subst_vars exp_named_subst ty in
+ decr fdebug ;
+ ty1,ugraph2
| C.Meta (n,l) ->
(try
let (canonical_context,term,ty) = CicUtil.lookup_subst n subst in
- check_metasenv_consistency ~logger
- ~subst metasenv context canonical_context l;
- (* assuming subst is well typed !!!!! *)
- CicSubstitution.lift_meta l ty
- (* type_of_aux context (CicSubstitution.lift_meta l term) *)
+ let ugraph1 =
+ check_metasenv_consistency ~logger
+ ~subst metasenv context canonical_context l ugraph
+ in
+ (* assuming subst is well typed !!!!! *)
+ ((CicSubstitution.lift_meta l ty), ugraph1)
+ (* type_of_aux context (CicSubstitution.lift_meta l term) *)
with CicUtil.Subst_not_found _ ->
let (_,canonical_context,ty) = CicUtil.lookup_meta n metasenv in
- check_metasenv_consistency ~logger
- ~subst metasenv context canonical_context l;
- CicSubstitution.lift_meta l ty)
+ let ugraph1 =
+ check_metasenv_consistency ~logger
+ ~subst metasenv context canonical_context l ugraph
+ in
+ ((CicSubstitution.lift_meta l ty),ugraph1))
(* TASSI: CONSTRAINTS *)
| C.Sort (C.Type t) ->
let t' = CicUniv.fresh() in
- if not (CicUniv.add_gt t' t ) then
- assert false (* t' is fresh! an error in CicUniv *)
- else
- C.Sort (C.Type t')
+ let ugraph1 = CicUniv.add_gt t' t ugraph in
+ (C.Sort (C.Type t')),ugraph1
(* TASSI: CONSTRAINTS *)
- | C.Sort s -> C.Sort (C.Type (CicUniv.fresh ()))
+ | C.Sort s -> (C.Sort (C.Type (CicUniv.fresh ()))),ugraph
| C.Implicit _ -> raise (AssertFailure "21")
| C.Cast (te,ty) as t ->
- let _ = type_of_aux ~logger context ty in
- if R.are_convertible ~subst ~metasenv context (type_of_aux ~logger context te) ty then
- ty
- else
- raise (TypeCheckerFailure
- (sprintf "Invalid cast %s" (CicPp.ppterm t)))
+ let _,ugraph1 = type_of_aux ~logger context ty ugraph in
+ let ty_te,ugraph2 = type_of_aux ~logger context te ugraph1 in
+ let b,ugraph3 =
+ R.are_convertible ~subst ~metasenv context ty_te ty ugraph2
+ in
+ if b then
+ ty,ugraph3
+ else
+ raise (TypeCheckerFailure
+ (sprintf "Invalid cast %s" (CicPp.ppterm t)))
| C.Prod (name,s,t) ->
- let sort1 = type_of_aux ~logger context s
- and sort2 = type_of_aux ~logger ((Some (name,(C.Decl s)))::context) t in
- let res = sort_of_prod ~subst context (name,s) (sort1,sort2) in
- res
+ let sort1,ugraph1 = type_of_aux ~logger context s ugraph in
+ let sort2,ugraph2 =
+ type_of_aux ~logger ((Some (name,(C.Decl s)))::context) t ugraph1
+ in
+ sort_of_prod ~subst context (name,s) (sort1,sort2) ugraph2
| C.Lambda (n,s,t) ->
- let sort1 = type_of_aux ~logger context s in
+ let sort1,ugraph1 = type_of_aux ~logger context s ugraph in
(match R.whd ~subst context sort1 with
C.Meta _
| C.Sort _ -> ()
| _ ->
raise
(TypeCheckerFailure (sprintf
- "Not well-typed lambda-abstraction: the source %s should be a
- type; instead it is a term of type %s" (CicPp.ppterm s)
+ "Not well-typed lambda-abstraction: the source %s should be a type; instead it is a term of type %s" (CicPp.ppterm s)
(CicPp.ppterm sort1)))
) ;
- let type2 = type_of_aux ~logger ((Some (n,(C.Decl s)))::context) t in
- C.Prod (n,s,type2)
+ let type2,ugraph2 =
+ type_of_aux ~logger ((Some (n,(C.Decl s)))::context) t ugraph1
+ in
+ (C.Prod (n,s,type2)),ugraph2
| C.LetIn (n,s,t) ->
(* only to check if s is well-typed *)
- let ty = type_of_aux ~logger context s in
+ let ty,ugraph1 = type_of_aux ~logger context s ugraph in
(* The type of a LetIn is a LetIn. Extremely slow since the computed
LetIn is later reduced and maybe also re-checked.
(C.LetIn (n,s, type_of_aux ((Some (n,(C.Def s)))::context) t))
*)
(* One-step LetIn reduction. Even faster than the previous solution.
Moreover the inferred type is closer to the expected one. *)
- (CicSubstitution.subst s
- (type_of_aux ~logger ((Some (n,(C.Def (s,Some ty))))::context) t))
+ let ty1,ugraph2 =
+ type_of_aux ~logger
+ ((Some (n,(C.Def (s,Some ty))))::context) t ugraph1
+ in
+ (CicSubstitution.subst s ty1),ugraph2
| C.Appl (he::tl) when List.length tl > 0 ->
- let hetype = type_of_aux ~logger context he in
- let tlbody_and_type = List.map (fun x -> (x, type_of_aux ~logger context x)) tl in
- eat_prods ~subst context hetype tlbody_and_type
+ let hetype,ugraph1 = type_of_aux ~logger context he ugraph in
+ let tlbody_and_type,ugraph2 =
+ List.fold_right (
+ fun x (l,ugraph) ->
+ let ty,ugraph1 = type_of_aux ~logger context x ugraph in
+ let _,ugraph1 = type_of_aux ~logger context ty ugraph1 in
+ ((x,ty)::l,ugraph1))
+ tl ([],ugraph1)
+ in
+ (* TASSI: questa c'era nel mio... ma non nel CVS... *)
+ (* let _,ugraph2 = type_of_aux context hetype ugraph2 in *)
+ eat_prods ~subst context hetype tlbody_and_type ugraph2
| C.Appl _ -> raise (AssertFailure "Appl: no arguments")
| C.Const (uri,exp_named_subst) ->
- incr fdebug ;
- check_exp_named_subst ~logger ~subst context exp_named_subst ;
- let cty =
- CicSubstitution.subst_vars exp_named_subst (type_of_constant ~logger uri)
- in
- decr fdebug ;
- cty
+ incr fdebug ;
+ let ugraph1 =
+ check_exp_named_subst ~logger ~subst context exp_named_subst ugraph
+ in
+ let cty,ugraph2 = type_of_constant ~logger uri ugraph1 in
+ let cty1 =
+ CicSubstitution.subst_vars exp_named_subst cty
+ in
+ decr fdebug ;
+ cty1,ugraph2
| C.MutInd (uri,i,exp_named_subst) ->
incr fdebug ;
- check_exp_named_subst ~logger ~subst context exp_named_subst ;
- let cty =
- CicSubstitution.subst_vars exp_named_subst
- (type_of_mutual_inductive_defs ~logger uri i)
- in
- decr fdebug ;
- cty
+ let ugraph1 =
+ check_exp_named_subst ~logger ~subst context exp_named_subst ugraph
+ in
+ (* TASSI: da me c'era anche questa, ma in CVS no *)
+ let mty,ugraph2 = type_of_mutual_inductive_defs ~logger uri i ugraph1 in
+ (* fine parte dubbia *)
+ let cty =
+ CicSubstitution.subst_vars exp_named_subst mty
+ in
+ decr fdebug ;
+ cty,ugraph2
| C.MutConstruct (uri,i,j,exp_named_subst) ->
- check_exp_named_subst ~logger ~subst context exp_named_subst ;
- let cty =
- CicSubstitution.subst_vars exp_named_subst
- (type_of_mutual_inductive_constr ~logger uri i j)
- in
- cty
+ let ugraph1 =
+ check_exp_named_subst ~logger ~subst context exp_named_subst ugraph
+ in
+ (* TASSI: idem come sopra *)
+ let mty,ugraph2 =
+ type_of_mutual_inductive_constr ~logger uri i j ugraph1
+ in
+ let cty =
+ CicSubstitution.subst_vars exp_named_subst mty
+ in
+ cty,ugraph2
| C.MutCase (uri,i,outtype,term,pl) ->
- let outsort = type_of_aux ~logger context outtype in
+ let outsort,ugraph1 = type_of_aux ~logger context outtype ugraph in
let (need_dummy, k) =
let rec guess_args context t =
let outtype = CicReduction.whd ~subst context t in
"Malformed case analasys' output type %s"
(CicPp.ppterm outtype)))
in
+(*
+ let (parameters, arguments, exp_named_subst),ugraph2 =
+ let ty,ugraph2 = type_of_aux context term ugraph1 in
+ match R.whd context ty with
+ (*CSC manca il caso dei CAST *)
+(*CSC: ma servono i parametri (uri,i)? Se si', perche' non serve anche il *)
+(*CSC: parametro exp_named_subst? Se no, perche' non li togliamo? *)
+(*CSC: Hint: nella DTD servono per gli stylesheet. *)
+ C.MutInd (uri',i',exp_named_subst) as typ ->
+ if U.eq uri uri' && i = i' then
+ ([],[],exp_named_subst),ugraph2
+ else
+ raise
+ (TypeCheckerFailure
+ (sprintf
+ ("Case analysys: analysed term type is %s, but is expected to be (an application of) %s#1/%d{_}")
+ (CicPp.ppterm typ) (U.string_of_uri uri) i))
+ | C.Appl
+ ((C.MutInd (uri',i',exp_named_subst) as typ):: tl) as typ' ->
+ if U.eq uri uri' && i = i' then
+ let params,args =
+ split tl (List.length tl - k)
+ in (params,args,exp_named_subst),ugraph2
+ else
+ raise
+ (TypeCheckerFailure
+ (sprintf
+ ("Case analysys: analysed term type is %s, "^
+ "but is expected to be (an application of) "^
+ "%s#1/%d{_}")
+ (CicPp.ppterm typ') (U.string_of_uri uri) i))
+ | _ ->
+ raise
+ (TypeCheckerFailure
+ (sprintf
+ ("Case analysis: "^
+ "analysed term %s is not an inductive one")
+ (CicPp.ppterm term)))
+*)
let (b, k) = guess_args context outsort in
- if not b then (b, k - 1) else (b, k) in
- let (parameters, arguments, exp_named_subst) =
- match R.whd ~subst context (type_of_aux ~logger context term) with
+ if not b then (b, k - 1) else (b, k) in
+ let (parameters, arguments, exp_named_subst),ugraph2 =
+ let ty,ugraph2 = type_of_aux ~logger context term ugraph1 in
+ match R.whd ~subst context ty with
C.MutInd (uri',i',exp_named_subst) as typ ->
- if U.eq uri uri' && i = i' then ([],[],exp_named_subst)
+ if U.eq uri uri' && i = i' then
+ ([],[],exp_named_subst),ugraph2
else raise
(TypeCheckerFailure
(sprintf
- "Case analysys: analysed term type is %s,
- but is expected to be (an application of) %s#1/%d{_}"
+ ("Case analysys: analysed term type is %s, but is expected to be (an application of) %s#1/%d{_}")
(CicPp.ppterm typ) (U.string_of_uri uri) i))
- | C.Appl ((C.MutInd (uri',i',exp_named_subst) as typ):: tl) as typ' ->
+ | C.Appl
+ ((C.MutInd (uri',i',exp_named_subst) as typ):: tl) as typ' ->
if U.eq uri uri' && i = i' then
let params,args =
split tl (List.length tl - k)
- in params,args,exp_named_subst
+ in (params,args,exp_named_subst),ugraph2
else raise
(TypeCheckerFailure
(sprintf
- "Case analysys: analysed term type is %s,
- but is expected to be (an application of) %s#1/%d{_}"
+ "Case analysys: analysed term type is %s, but is expected to be (an application of) %s#1/%d{_}"
(CicPp.ppterm typ') (U.string_of_uri uri) i))
| _ ->
raise
"Case analysis: analysed term %s is not an inductive one"
(CicPp.ppterm term)))
in
- (* let's control if the sort elimination is allowed: [(I q1 ... qr)|B] *)
+ (*
+ let's control if the sort elimination is allowed:
+ [(I q1 ... qr)|B]
+ *)
let sort_of_ind_type =
if parameters = [] then
C.MutInd (uri,i,exp_named_subst)
else
- C.Appl ((C.MutInd (uri,i,exp_named_subst))::parameters) in
- if not
- (check_allowed_sort_elimination ~logger context uri i need_dummy
- sort_of_ind_type (type_of_aux ~logger context sort_of_ind_type) outsort)
- then
+ C.Appl ((C.MutInd (uri,i,exp_named_subst))::parameters)
+ in
+ let type_of_sort_of_ind_ty,ugraph3 =
+ type_of_aux ~logger context sort_of_ind_type ugraph2 in
+ let b,ugraph4 =
+ check_allowed_sort_elimination ~logger context uri i need_dummy
+ sort_of_ind_type type_of_sort_of_ind_ty outsort ugraph3
+ in
+ if not b then
raise
(TypeCheckerFailure ("Case analasys: sort elimination not allowed"));
(* let's check if the type of branches are right *)
let parsno =
- let obj =
+ let obj,_ =
try
- CicEnvironment.get_cooked_obj ~trust:false uri
+ CicEnvironment.get_cooked_obj ~trust:false uri CicUniv.empty_ugraph
with Not_found -> assert false
in
match obj with
raise (TypeCheckerFailure
("Unknown mutual inductive definition:" ^
UriManager.string_of_uri uri))
- in
- let (_,branches_ok) =
+ in
+ let (_,branches_ok,ugraph5) =
List.fold_left
- (fun (j,b) p ->
- let cons =
- if parameters = [] then
- (C.MutConstruct (uri,i,j,exp_named_subst))
- else
- (C.Appl
- (C.MutConstruct (uri,i,j,exp_named_subst)::parameters)) in
- (j + 1,
- let res =
- b &&
- R.are_convertible
- ~subst ~metasenv context (type_of_aux ~logger context p)
- (type_of_branch context parsno need_dummy outtype cons
- (type_of_aux ~logger context cons)) in
- if not res then
- debug_print ("#### " ^ CicPp.ppterm (type_of_aux ~logger context p) ^ " <==> " ^ CicPp.ppterm (type_of_branch context parsno need_dummy outtype cons (type_of_aux ~logger context cons))) ; res
- )
- ) (1,true) pl
- in
- if not branches_ok then
- raise
- (TypeCheckerFailure "Case analysys: wrong branch type");
- if not need_dummy then
- C.Appl ((outtype::arguments)@[term])
- else if arguments = [] then
- outtype
- else
- C.Appl (outtype::arguments)
+ (fun (j,b,ugraph) p ->
+ if b then
+ let cons =
+ if parameters = [] then
+ (C.MutConstruct (uri,i,j,exp_named_subst))
+ else
+ (C.Appl
+ (C.MutConstruct (uri,i,j,exp_named_subst)::parameters))
+ in
+ let ty_p,ugraph1 = type_of_aux ~logger context p ugraph in
+ let ty_cons,ugraph3 = type_of_aux ~logger context cons ugraph1 in
+ (* 2 is skipped *)
+ let ty_branch =
+ type_of_branch context parsno need_dummy outtype cons
+ ty_cons in
+ let b1,ugraph4 =
+ R.are_convertible
+ ~subst ~metasenv context ty_p ty_branch ugraph3
+ in
+ if not b1 then
+ debug_print
+ ("#### " ^ CicPp.ppterm ty_p ^
+ " <==> " ^ CicPp.ppterm ty_branch);
+ (j + 1,b1,ugraph4)
+ else
+ (j,false,ugraph)
+ ) (1,true,ugraph4) pl
+ in
+ if not branches_ok then
+ raise
+ (TypeCheckerFailure "Case analysys: wrong branch type");
+ if not need_dummy then
+ (C.Appl ((outtype::arguments)@[term])),ugraph5
+ else if arguments = [] then
+ outtype,ugraph5
+ else
+ (C.Appl (outtype::arguments)),ugraph5
| C.Fix (i,fl) ->
- let types_times_kl =
- List.rev
- (List.map
- (fun (n,k,ty,_) ->
- let _ = type_of_aux ~logger context ty in
- (Some (C.Name n,(C.Decl ty)),k)) fl)
+ let types_times_kl,ugraph1 =
+ (* WAS: list rev list map *)
+ List.fold_left
+ (fun (l,ugraph) (n,k,ty,_) ->
+ let _,ugraph1 = type_of_aux ~logger context ty ugraph in
+ ((Some (C.Name n,(C.Decl ty)),k)::l,ugraph1)
+ ) ([],ugraph) fl
+ in
+ let (types,kl) = List.split types_times_kl in
+ let len = List.length types in
+ let ugraph2 =
+ List.fold_left
+ (fun ugraph (name,x,ty,bo) ->
+ let ty_bo,ugraph1 =
+ type_of_aux ~logger (types@context) bo ugraph
+ in
+ let b,ugraph2 =
+ R.are_convertible ~subst ~metasenv (types@context)
+ ty_bo (CicSubstitution.lift len ty) ugraph1 in
+ if b then
+ begin
+ let (m, eaten, context') =
+ eat_lambdas ~subst (types @ context) (x + 1) bo
+ in
+ (*
+ let's control the guarded by
+ destructors conditions D{f,k,x,M}
+ *)
+ if not (guarded_by_destructors context' eaten
+ (len + eaten) kl 1 [] m) then
+ raise
+ (TypeCheckerFailure
+ ("Fix: not guarded by destructors"))
+ else
+ ugraph2
+ end
+ else
+ raise (TypeCheckerFailure ("Fix: ill-typed bodies"))
+ ) ugraph1 fl in
+ (*CSC: controlli mancanti solo su D{f,k,x,M} *)
+ let (_,_,ty,_) = List.nth fl i in
+ ty,ugraph2
+ | C.CoFix (i,fl) ->
+ let types,ugraph1 =
+ List.fold_left
+ (fun (l,ugraph) (n,ty,_) ->
+ let _,ugraph1 =
+ type_of_aux ~logger context ty ugraph in
+ (Some (C.Name n,(C.Decl ty))::l,ugraph1)
+ ) ([],ugraph) fl
in
- let (types,kl) = List.split types_times_kl in
let len = List.length types in
- List.iter
- (fun (name,x,ty,bo) ->
- if
- (R.are_convertible
- ~subst ~metasenv (types@context) (type_of_aux ~logger (types@context) bo)
- (CicSubstitution.lift len ty))
- then
- begin
- let (m, eaten, context') =
- eat_lambdas ~subst (types @ context) (x + 1) bo in
- (*let's control the guarded by destructors conditions D{f,k,x,M}*)
- if
- not (guarded_by_destructors context'
- eaten (len + eaten) kl 1 [] m)
- then
+ let ugraph2 =
+ List.fold_left
+ (fun ugraph (_,ty,bo) ->
+ let ty_bo,ugraph1 =
+ type_of_aux ~logger (types @ context) bo ugraph
+ in
+ let b,ugraph2 =
+ R.are_convertible ~subst ~metasenv (types @ context) ty_bo
+ (CicSubstitution.lift len ty) ugraph1
+ in
+ if b then
+ begin
+ (* let's control that the returned type is coinductive *)
+ match returns_a_coinductive context ty with
+ None ->
+ raise
+ (TypeCheckerFailure
+ ("CoFix: does not return a coinductive type"))
+ | Some uri ->
+ (*
+ let's control the guarded by constructors
+ conditions C{f,M}
+ *)
+ if not (guarded_by_constructors (types @ context)
+ 0 len false bo [] uri) then
+ raise
+ (TypeCheckerFailure
+ ("CoFix: not guarded by constructors"))
+ else
+ ugraph2
+ end
+ else
raise
- (TypeCheckerFailure ("Fix: not guarded by destructors"))
- end
- else
- raise (TypeCheckerFailure ("Fix: ill-typed bodies"))
- ) fl ;
- (*CSC: controlli mancanti solo su D{f,k,x,M} *)
- let (_,_,ty,_) = List.nth fl i in
- ty
- | C.CoFix (i,fl) ->
- let types =
- List.rev
- (List.map
- (fun (n,ty,_) ->
- let _ = type_of_aux ~logger context ty in Some (C.Name n,(C.Decl ty))) fl)
+ (TypeCheckerFailure ("CoFix: ill-typed bodies"))
+ ) ugraph1 fl
in
- let len = List.length types in
- List.iter
- (fun (_,ty,bo) ->
- if
- (R.are_convertible
- ~subst ~metasenv (types @ context)
- (type_of_aux ~logger (types @ context) bo) (CicSubstitution.lift len ty))
- then
- begin
- (* let's control that the returned type is coinductive *)
- match returns_a_coinductive context ty with
- None ->
- raise
- (TypeCheckerFailure
- ("CoFix: does not return a coinductive type"))
- | Some uri ->
- (*let's control the guarded by constructors conditions C{f,M}*)
- if
- not
- (guarded_by_constructors
- (types @ context) 0 len false bo [] uri)
- then
- raise
- (TypeCheckerFailure ("CoFix: not guarded by constructors"))
- end
- else
- raise
- (TypeCheckerFailure ("CoFix: ill-typed bodies"))
- ) fl ;
- let (_,ty,_) = List.nth fl i in
- ty
+ let (_,ty,_) = List.nth fl i in
+ ty,ugraph2
- and check_exp_named_subst ~logger ?(subst = []) context =
- let rec check_exp_named_subst_aux ~logger esubsts =
- function
- [] -> ()
- | ((uri,t) as item)::tl ->
- let typeofvar =
- CicSubstitution.subst_vars esubsts (type_of_variable ~logger uri) in
- let typeoft = type_of_aux ~logger context t in
- if CicReduction.are_convertible
- ~subst ~metasenv context typeoft typeofvar then
- check_exp_named_subst_aux ~logger (esubsts@[item]) tl
- else
- begin
- CicReduction.fdebug := 0 ;
- ignore (CicReduction.are_convertible ~subst ~metasenv context typeoft typeofvar) ;
- fdebug := 0 ;
- debug typeoft [typeofvar] ;
- raise (TypeCheckerFailure "Wrong Explicit Named Substitution")
- end
- in
- check_exp_named_subst_aux ~logger []
-
- and sort_of_prod ?(subst = []) context (name,s) (t1, t2) =
+ and check_exp_named_subst ~logger ?(subst = []) context ugraph =
+ let rec check_exp_named_subst_aux ~logger esubsts l ugraph =
+ match l with
+ [] -> ugraph
+ | ((uri,t) as item)::tl ->
+ let ty_uri,ugraph1 = type_of_variable ~logger uri ugraph in
+ let typeofvar =
+ CicSubstitution.subst_vars esubsts ty_uri in
+ let typeoft,ugraph2 = type_of_aux ~logger context t ugraph1 in
+ let b,ugraph3 =
+ CicReduction.are_convertible ~subst ~metasenv
+ context typeoft typeofvar ugraph2
+ in
+ if b then
+ check_exp_named_subst_aux ~logger (esubsts@[item]) tl ugraph3
+ else
+ begin
+ CicReduction.fdebug := 0 ;
+ ignore
+ (CicReduction.are_convertible
+ ~subst ~metasenv context typeoft typeofvar ugraph2) ;
+ fdebug := 0 ;
+ debug typeoft [typeofvar] ;
+ raise (TypeCheckerFailure "Wrong Explicit Named Substitution")
+ end
+ in
+ check_exp_named_subst_aux ~logger [] ugraph
+
+ and sort_of_prod ?(subst = []) context (name,s) (t1, t2) ugraph =
let module C = Cic in
let t1' = CicReduction.whd ~subst context t1 in
let t2' = CicReduction.whd ~subst ((Some (name,C.Decl s))::context) t2 in
(C.Sort s1, C.Sort s2)
when (s2 = C.Prop or s2 = C.Set or s2 = C.CProp) ->
(* different from Coq manual!!! *)
- C.Sort s2
+ C.Sort s2,ugraph
| (C.Sort (C.Type t1), C.Sort (C.Type t2)) ->
(* TASSI: CONSRTAINTS: the same in doubletypeinference, cicrefine *)
let t' = CicUniv.fresh() in
- if not (CicUniv.add_ge t' t1) || not (CicUniv.add_ge t' t2) then
- assert false ; (* not possible, error in CicUniv *)
- C.Sort (C.Type t')
+ let ugraph1 = CicUniv.add_ge t' t1 ugraph in
+ let ugraph2 = CicUniv.add_ge t' t2 ugraph1 in
+ C.Sort (C.Type t'),ugraph2
| (C.Sort _,C.Sort (C.Type t1)) ->
(* TASSI: CONSRTAINTS: the same in doubletypeinference, cicrefine *)
- C.Sort (C.Type t1) (* c'e' bisogno di un fresh? *)
- | (C.Meta _, C.Sort _) -> t2'
+ C.Sort (C.Type t1),ugraph (* c'e' bisogno di un fresh? *)
+ | (C.Meta _, C.Sort _) -> t2',ugraph
| (C.Meta _, (C.Meta (_,_) as t))
| (C.Sort _, (C.Meta (_,_) as t)) when CicUtil.is_closed t ->
- t2'
+ t2',ugraph
| (_,_) -> raise (TypeCheckerFailure (sprintf
"Prod: expected two sorts, found = %s, %s" (CicPp.ppterm t1')
(CicPp.ppterm t2')))
- and eat_prods ?(subst = []) context hetype =
- (*CSC: siamo sicuri che le are_convertible non lavorino con termini non *)
- (*CSC: cucinati *)
- function
- [] -> hetype
- | (hete, hety)::tl ->
- (match (CicReduction.whd ~subst context hetype) with
- Cic.Prod (n,s,t) ->
- if CicReduction.are_convertible ~subst ~metasenv context hety s then
- (CicReduction.fdebug := -1 ;
- eat_prods ~subst context (CicSubstitution.subst hete t) tl
- )
- else
- begin
- CicReduction.fdebug := 0 ;
- ignore (CicReduction.are_convertible ~subst ~metasenv context s hety) ;
- fdebug := 0 ;
- debug s [hety] ;
- raise (TypeCheckerFailure (sprintf
- "Appl: wrong parameter-type, expected %s, found %s"
- (CicPp.ppterm hetype) (CicPp.ppterm s)))
- end
- | _ ->
- raise (TypeCheckerFailure
- "Appl: this is not a function, it cannot be applied")
- )
+ and eat_prods ?(subst = []) context hetype l ugraph =
+ (*CSC: siamo sicuri che le are_convertible non lavorino con termini non *)
+ (*CSC: cucinati *)
+ match l with
+ [] -> hetype,ugraph
+ | (hete, hety)::tl ->
+ (match (CicReduction.whd ~subst context hetype) with
+ Cic.Prod (n,s,t) ->
+ let b,ugraph1 =
+ CicReduction.are_convertible
+ ~subst ~metasenv context hety s ugraph
+ in
+ if b then
+ begin
+ CicReduction.fdebug := -1 ;
+ eat_prods ~subst context
+ (CicSubstitution.subst hete t) tl ugraph1
+ (*TASSI: not sure *)
+ end
+ else
+ begin
+ CicReduction.fdebug := 0 ;
+ ignore (CicReduction.are_convertible
+ ~subst ~metasenv context s hety ugraph) ;
+ fdebug := 0 ;
+ debug s [hety] ;
+ raise
+ (TypeCheckerFailure
+ (sprintf
+ ("Appl: wrong parameter-type, expected %s, found %s")
+ (CicPp.ppterm hetype) (CicPp.ppterm s)))
+ end
+ | _ ->
+ raise (TypeCheckerFailure
+ "Appl: this is not a function, it cannot be applied")
+ )
and returns_a_coinductive context ty =
let module C = Cic in
match CicReduction.whd context ty with
C.MutInd (uri,i,_) ->
(*CSC: definire una funzioncina per questo codice sempre replicato *)
- let obj =
+ let obj,_ =
try
- CicEnvironment.get_cooked_obj ~trust:false uri
+ CicEnvironment.get_cooked_obj ~trust:false uri CicUniv.empty_ugraph
with Not_found -> assert false
in
(match obj with
UriManager.string_of_uri uri))
)
| C.Appl ((C.MutInd (uri,i,_))::_) ->
- (match CicEnvironment.get_obj uri with
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.InductiveDefinition (itl,_,_) ->
let (_,is_inductive,_,_) = List.nth itl i in
if is_inductive then None else (Some uri)
debug_print ("INIZIO TYPE_OF_AUX " ^ CicPp.ppterm t) ; flush stderr ;
let res =
*)
- type_of_aux ~logger context t
+ type_of_aux ~logger context t ugraph
(*
in debug_print "FINE TYPE_OF_AUX" ; flush stderr ; res
*)
(* is a small constructor? *)
(*CSC: ottimizzare calcolando staticamente *)
-and is_small ~logger context paramsno c =
- let rec is_small_aux ~logger context c =
+and is_small ~logger context paramsno c ugraph =
+ let rec is_small_aux ~logger context c ugraph =
let module C = Cic in
match CicReduction.whd context c with
C.Prod (n,so,de) ->
(*CSC: [] is an empty metasenv. Is it correct? *)
- let s = type_of_aux' ~logger [] context so in
- (s = C.Sort C.Prop || s = C.Sort C.Set || s = C.Sort C.CProp) &&
- is_small_aux ~logger ((Some (n,(C.Decl so)))::context) de
- | _ -> true (*CSC: we trust the type-checker *)
+ let s,ugraph1 = type_of_aux' ~logger [] context so ugraph in
+ let b = (s = C.Sort C.Prop || s = C.Sort C.Set || s = C.Sort C.CProp) in
+ if b then
+ is_small_aux ~logger ((Some (n,(C.Decl so)))::context) de ugraph1
+ else
+ false,ugraph1
+ | _ -> true,ugraph (*CSC: we trust the type-checker *)
in
let (context',dx) = split_prods context paramsno c in
- is_small_aux ~logger context' dx
+ is_small_aux ~logger context' dx ugraph
-and type_of ~logger t =
+and type_of ~logger t ugraph =
(*CSC
debug_print ("INIZIO TYPE_OF_AUX' " ^ CicPp.ppterm t) ; flush stderr ;
let res =
*)
- type_of_aux' ~logger [] [] t
+ type_of_aux' ~logger [] [] t ugraph
(*CSC
in debug_print "FINE TYPE_OF_AUX'" ; flush stderr ; res
*)
;;
-(* tassi FIXME: not sure where is this called... no history here... *)
-let typecheck uri =
+let typecheck uri ugraph =
let module C = Cic in
let module R = CicReduction in
let module U = UriManager in
let logger = new CicLogger.logger in
- (*match CicEnvironment.is_type_checked ~trust:false uri with*)
- match CicEnvironment.is_type_checked ~trust:true uri with
- CicEnvironment.CheckedObj cobj -> cobj
+ (* ??? match CicEnvironment.is_type_checked ~trust:true uri with ???? *)
+ match CicEnvironment.is_type_checked ~trust:false uri ugraph with
+ CicEnvironment.CheckedObj (cobj,ugraph') ->
+ (* prerr_endline ("NON-INIZIO A TYPECHECKARE " ^ U.string_of_uri uri);*)
+ cobj,ugraph'
| CicEnvironment.UncheckedObj uobj ->
(* let's typecheck the uncooked object *)
logger#log (`Start_type_checking uri) ;
- CicUniv.directly_to_env_begin ();
- (match uobj with
- C.Constant (_,Some te,ty,_) ->
- let _ = type_of ~logger ty in
- if not (R.are_convertible [] (type_of ~logger te ) ty) then
+ (* prerr_endline ("INIZIO A TYPECHECKARE " ^ U.string_of_uri uri); *)
+ let ugraph1 =
+ (match uobj with
+ C.Constant (_,Some te,ty,_) ->
+ let _,ugraph1 = type_of ~logger ty ugraph in
+ let ty_te,ugraph2 = type_of ~logger te ugraph1 in
+ let b,ugraph3 = (R.are_convertible [] ty_te ty ugraph2) in
+ if not b then
raise (TypeCheckerFailure
("Unknown constant:" ^ U.string_of_uri uri))
+ else
+ ugraph3
| C.Constant (_,None,ty,_) ->
(* only to check that ty is well-typed *)
- let _ = type_of ~logger ty in ()
+ let _,ugraph1 = type_of ~logger ty ugraph in
+ ugraph1
| C.CurrentProof (_,conjs,te,ty,_) ->
- let _ =
+ let _,ugraph1 =
List.fold_left
- (fun metasenv ((_,context,ty) as conj) ->
- ignore (type_of_aux' ~logger metasenv context ty) ;
- metasenv @ [conj]
- ) [] conjs
+ (fun (metasenv,ugraph) ((_,context,ty) as conj) ->
+ let _,ugraph1 =
+ type_of_aux' ~logger metasenv context ty ugraph
+ in
+ metasenv @ [conj],ugraph1
+ ) ([],ugraph) conjs
in
- let _ = type_of_aux' ~logger conjs [] ty in
- let type_of_te = type_of_aux' ~logger conjs [] te in
- if not (R.are_convertible [] type_of_te ty)
- then
+ let _,ugraph2 = type_of_aux' ~logger conjs [] ty ugraph1 in
+ let type_of_te,ugraph3 =
+ type_of_aux' ~logger conjs [] te ugraph2
+ in
+ let b,ugraph4 = R.are_convertible [] type_of_te ty ugraph3 in
+ if not b then
raise (TypeCheckerFailure (sprintf
"the current proof %s is not well typed because the type %s of the body is not convertible to the declared type %s"
(U.string_of_uri uri) (CicPp.ppterm type_of_te)
(CicPp.ppterm ty)))
+ else
+ ugraph4
| C.Variable (_,bo,ty,_) ->
(* only to check that ty is well-typed *)
- let _ = type_of ~logger ty in
+ let _,ugraph1 = type_of ~logger ty ugraph in
(match bo with
- None -> ()
+ None -> ugraph1
| Some bo ->
- if not (R.are_convertible [] (type_of ~logger bo) ty) then
- raise (TypeCheckerFailure
- ("Unknown variable:" ^ U.string_of_uri uri))
+ let ty_bo,ugraph2 = type_of ~logger bo ugraph1 in
+ let b,ugraph3 = R.are_convertible [] ty_bo ty ugraph2 in
+ if not b then
+ raise (TypeCheckerFailure
+ ("Unknown variable:" ^ U.string_of_uri uri))
+ else
+ ugraph3
)
| C.InductiveDefinition _ ->
- check_mutual_inductive_defs ~logger uri uobj
- ) ;
- CicEnvironment.set_type_checking_info uri ;
- CicUniv.directly_to_env_end ();
- logger#log (`Type_checking_completed uri);
- uobj
+ check_mutual_inductive_defs ~logger uri uobj ugraph
+ ) in
+ try
+ CicEnvironment.set_type_checking_info uri;
+ logger#log (`Type_checking_completed uri);
+ match CicEnvironment.is_type_checked ~trust:false uri ugraph with
+ CicEnvironment.CheckedObj (cobj,ugraph') -> cobj,ugraph'
+ | _ -> raise CicEnvironmentError
+ with
+ (*
+ this is raised if set_type_checking_info is called on an object
+ that has no associated universe file. If we are in univ_maker
+ phase this is OK since univ_maker will properly commit the
+ object.
+ *)
+ Invalid_argument s ->
+ (*prerr_endline s;*)
+ uobj,ugraph1
;;
(** wrappers which instantiate fresh loggers *)
exception TypeCheckerFailure of string
exception AssertFailure of string
-val typecheck : UriManager.uri -> Cic.obj
+val typecheck :
+ UriManager.uri -> CicUniv.universe_graph -> Cic.obj * CicUniv.universe_graph
(* FUNCTIONS USED ONLY IN THE TOPLEVEL *)
(* type_of_aux' metasenv context term *)
val type_of_aux':
- ?subst:Cic.substitution -> Cic.metasenv -> Cic.context -> Cic.term -> Cic.term
+ ?subst:Cic.substitution -> Cic.metasenv -> Cic.context ->
+ Cic.term -> CicUniv.universe_graph ->
+ Cic.term * CicUniv.universe_graph
+
(* typecheck_mutual_inductive_defs uri (itl,params,indparamsno) *)
val typecheck_mutual_inductive_defs :
- UriManager.uri -> Cic.inductiveType list * UriManager.uri list * int -> unit
+ UriManager.uri -> Cic.inductiveType list * UriManager.uri list * int ->
+ CicUniv.universe_graph -> CicUniv.universe_graph
--- /dev/null
+(* Copyright (C) 2000, HELM Team.
+ *
+ * This file is part of HELM, an Hypertextual, Electronic
+ * Library of Mathematics, developed at the Computer Science
+ * Department, University of Bologna, Italy.
+ *
+ * HELM is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * HELM is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HELM; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ *
+ * For details, see the HELM World-Wide-Web page,
+ * http://cs.unibo.it/helm/.
+ *)
+
+(*****************************************************************************)
+(* *)
+(* PROJECT HELM *)
+(* *)
+(* Enrico Tassi <tassi@cs.unibo.it> *)
+(* 23/04/2004 *)
+(* *)
+(* This module implements some useful function regarding univers graphs *)
+(* *)
+(*****************************************************************************)
+
+let universes_of_obj t =
+ let don = ref [] in
+ let module C = Cic in
+ let rec aux t =
+ match t with
+ C.Const (u,exp_named_subst)
+ | C.Var (u,exp_named_subst) ->
+ if List.mem u !don then [] else
+ (don := u::!don;
+ aux_obj (CicEnvironment.get_obj ~not_jet_cooked:true u
+ CicUniv.empty_ugraph))
+ | C.MutInd (u,_,exp_named_subst) ->
+ if List.mem u !don then
+ []
+ else
+ begin
+ don := u::!don;
+ (match fst(CicEnvironment.get_obj ~not_jet_cooked:true u
+ CicUniv.empty_ugraph) with
+ | C.InductiveDefinition (l,_,_) ->
+ List.fold_left (
+ fun y (_,_,t,l') ->
+ y @ (aux t) @
+ (List.fold_left (
+ fun x (_,t) -> x @ (aux t) )
+ [] l'))
+ [] l
+ | _ -> assert false) @
+ List.fold_left (fun x (uri,t) -> x @ (aux t) ) [] exp_named_subst
+ end
+ | C.MutConstruct (u,_,_,exp_named_subst) ->
+ if List.mem u !don then
+ []
+ else
+ begin
+ don := u::!don;
+ (match fst(CicEnvironment.get_obj ~not_jet_cooked:true u
+ CicUniv.empty_ugraph) with
+ | C.InductiveDefinition (l,_,_) ->
+ List.fold_left (
+ fun x (_,_,_t,l') ->
+ x @ aux t @
+ (List.fold_left (
+ fun y (_,t) -> y @ (aux t) )
+ [] l'))
+ [] l
+ | _ -> assert false) @
+ List.fold_left (fun x (uri,t) -> x @ (aux t) ) [] exp_named_subst
+ end
+ | C.Meta (n,l1) ->
+ List.fold_left
+ (fun x t ->
+ match t with
+ Some t' -> x @ (aux t')
+ | _ -> x)
+ [] l1
+ | C.Sort ( C.Type i) -> [i]
+ | C.Rel _
+ | C.Sort _
+ | C.Implicit _ -> []
+ | C.Prod (b,s,t) ->
+ aux s @ aux t
+ | C.Cast (v,t) ->
+ aux v @ aux t
+ | C.Lambda (b,s,t) ->
+ aux s @ aux t
+ | C.LetIn (b,s,t) ->
+ aux s @ aux t
+ | C.Appl li ->
+ List.fold_left (fun x t -> x @ (aux t)) [] li
+ | C.MutCase (uri,n1,ty,te,patterns) ->
+ aux ty @ aux te @
+ (List.fold_left (fun x t -> x @ (aux t)) [] patterns)
+ | C.Fix (no, funs) ->
+ List.fold_left (fun x (_,_,b,c) -> x @ (aux b) @ (aux c)) [] funs
+ | C.CoFix (no,funs) ->
+ List.fold_left (fun x (_,b,c) -> x @ (aux b) @ (aux c)) [] funs
+ and aux_obj ?(boo=false) (t,_) =
+ (match t with
+ C.Constant (_,Some te,ty,v) -> aux te @ aux ty @
+ List.fold_left (
+ fun l u ->
+ l @ aux_obj (CicEnvironment.get_obj ~not_jet_cooked:true u
+ CicUniv.empty_ugraph))
+ [] v
+ | C.Constant (_,None,ty,v) -> aux ty @
+ List.fold_left (
+ fun l u ->
+ l @ aux_obj (CicEnvironment.get_obj ~not_jet_cooked:true u
+ CicUniv.empty_ugraph))
+ [] v
+ | C.CurrentProof (_,conjs,te,ty,v) -> aux te @ aux ty @
+ List.fold_left (
+ fun l u ->
+ l @ aux_obj (CicEnvironment.get_obj ~not_jet_cooked:true u
+ CicUniv.empty_ugraph))
+ [] v
+ | C.Variable (_,Some bo,ty,v) -> aux bo @ aux ty @
+ List.fold_left (
+ fun l u ->
+ l @ aux_obj (CicEnvironment.get_obj ~not_jet_cooked:true u
+ CicUniv.empty_ugraph))
+ [] v
+ | C.Variable (_,None ,ty,v) -> aux ty @
+ List.fold_left (
+ fun l u ->
+ l @ aux_obj (CicEnvironment.get_obj ~not_jet_cooked:true u
+ CicUniv.empty_ugraph))
+ [] v
+ | C.InductiveDefinition (l,v,_) ->
+ (List.fold_left (
+ fun x (_,_,t,l') ->
+ x @ aux t @ List.fold_left (
+ fun y (_,t) -> y @ aux t)
+ [] l')
+ [] l) @
+ (List.fold_left (
+ fun l u ->
+ l @ aux_obj (CicEnvironment.get_obj ~not_jet_cooked:true u
+ CicUniv.empty_ugraph))
+ [] v)
+ )
+ in
+ aux_obj (t,CicUniv.empty_ugraph)
+
+
+
--- /dev/null
+(* Copyright (C) 2000, HELM Team.
+ *
+ * This file is part of HELM, an Hypertextual, Electronic
+ * Library of Mathematics, developed at the Computer Science
+ * Department, University of Bologna, Italy.
+ *
+ * HELM is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * HELM is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HELM; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ *
+ * For details, see the HELM World-Wide-Web page,
+ * http://cs.unibo.it/helm/.
+ *)
+(* traverses recursively a type and lists the referenced universes *)
+val universes_of_obj:
+ Cic.obj -> CicUniv.universe list
| _ -> assert false
let get_types uri =
- match CicEnvironment.get_obj uri with
- | Cic.Constant _ -> assert false
- | Cic.Variable _ -> assert false
- | Cic.CurrentProof _ -> assert false
- | Cic.InductiveDefinition (l,_,_) -> l
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
+ | Cic.Constant _ -> assert false
+ | Cic.Variable _ -> assert false
+ | Cic.CurrentProof _ -> assert false
+ | Cic.InductiveDefinition (l,_,_) -> l
let name_of_inductive_type uri i =
let types = get_types uri in
--- /dev/null
+(* Copyright (C) 2000, HELM Team.
+ *
+ * This file is part of HELM, an Hypertextual, Electronic
+ * Library of Mathematics, developed at the Computer Science
+ * Department, University of Bologna, Italy.
+ *
+ * HELM is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * HELM is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HELM; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ *
+ * For details, see the HELM World-Wide-Web page,
+ * http://cs.unibo.it/helm/.
+ *)
+
+(**************************************************************************)
+(* *)
+(* PROJECT HELM *)
+(* *)
+(* Andrea Asperti <asperti@cs.unibo.it> *)
+(* 27/6/2003 *)
+(* *)
+(**************************************************************************)
+
+
+(* the type cexpr is inspired by OpenMath. A few primitive constructors
+ have been added, in order to take into account some special features
+ of functional expressions. Most notably: case, let in, let rec, and
+ explicit substitutions *)
+
+type cexpr =
+ Symbol of string option * string * subst option * string option
+ (* h:xref, name, subst, definitionURL *)
+ | LocalVar of (string option) * string (* h:xref, name *)
+ | Meta of string option * string * meta_subst (* h:xref, name, meta_subst *)
+ | Num of string option * string (* h:xref, value *)
+ | Appl of string option * cexpr list (* h:xref, args *)
+ | Binder of string option * string * decl * cexpr
+ (* h:xref, name, decl, body *)
+ | Letin of string option * def * cexpr (* h:xref, def, body *)
+ | Letrec of string option * def list * cexpr (* h:xref, def list, body *)
+ | Case of string option * cexpr * ((string * cexpr) list)
+ (* h:xref, case_expr, named-pattern list *)
+
+and
+ decl = string * cexpr (* name, type *)
+and
+ def = string * cexpr (* name, body *)
+and
+ subst = (UriManager.uri * cexpr) list
+and
+ meta_subst = cexpr option list
+;;
+
+(* NOTATION *)
+
+let symbol_table = Hashtbl.create 503;;
+
+(* eq *)
+Hashtbl.add symbol_table HelmLibraryObjects.Logic.eq_XURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "eq",
+ None, Some HelmLibraryObjects.Logic.eq_SURI))
+ :: List.map acic2cexpr (List.tl args)));;
+
+(* and *)
+Hashtbl.add symbol_table HelmLibraryObjects.Logic.and_XURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "and",
+ None, Some HelmLibraryObjects.Logic.and_SURI))
+ :: List.map acic2cexpr args));;
+
+(* or *)
+Hashtbl.add symbol_table HelmLibraryObjects.Logic.or_XURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "or",
+ None, Some HelmLibraryObjects.Logic.or_SURI))
+ :: List.map acic2cexpr args));;
+
+(* iff *)
+Hashtbl.add symbol_table HelmLibraryObjects.Logic.iff_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "iff",
+ None, Some HelmLibraryObjects.Logic.iff_SURI))
+ :: List.map acic2cexpr args));;
+
+(* not *)
+Hashtbl.add symbol_table HelmLibraryObjects.Logic.not_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "not",
+ None, Some HelmLibraryObjects.Logic.not_SURI))
+ :: List.map acic2cexpr args));;
+
+(* Rinv *)
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.rinv_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "inv",
+ None, Some HelmLibraryObjects.Reals.rinv_SURI))
+ :: List.map acic2cexpr args));;
+
+(* Ropp *)
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.ropp_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "opp",
+ None, Some HelmLibraryObjects.Reals.ropp_SURI))
+ :: List.map acic2cexpr args));;
+
+(* exists *)
+Hashtbl.add symbol_table HelmLibraryObjects.Logic.ex_XURI
+ (fun aid sid args acic2cexpr ->
+ match (List.tl args) with
+ [Cic.ALambda (_,Cic.Name n,s,t)] ->
+ Binder
+ (Some aid, "Exists", (n,acic2cexpr s),acic2cexpr t)
+ | _ -> raise Not_found);;
+
+(* leq *)
+Hashtbl.add symbol_table HelmLibraryObjects.Peano.le_XURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "leq",
+ None, Some HelmLibraryObjects.Peano.le_SURI))
+ :: List.map acic2cexpr args));;
+
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.rle_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "leq",
+ None, Some HelmLibraryObjects.Reals.rle_SURI))
+ :: List.map acic2cexpr args));;
+
+(* lt *)
+Hashtbl.add symbol_table HelmLibraryObjects.Peano.lt_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "lt",
+ None, Some HelmLibraryObjects.Peano.lt_SURI))
+ :: List.map acic2cexpr args));;
+
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.rlt_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "lt",
+ None, Some HelmLibraryObjects.Reals.rlt_SURI))
+ :: List.map acic2cexpr args));;
+
+(* geq *)
+Hashtbl.add symbol_table HelmLibraryObjects.Peano.ge_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "geq",
+ None, Some HelmLibraryObjects.Peano.ge_SURI))
+ :: List.map acic2cexpr args));;
+
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.rge_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "geq",
+ None, Some HelmLibraryObjects.Reals.rge_SURI))
+ :: List.map acic2cexpr args));;
+
+(* gt *)
+Hashtbl.add symbol_table HelmLibraryObjects.Peano.gt_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "gt",
+ None, Some HelmLibraryObjects.Peano.gt_SURI))
+ :: List.map acic2cexpr args));;
+
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.rgt_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "gt",
+ None, Some HelmLibraryObjects.Reals.rgt_SURI))
+ :: List.map acic2cexpr args));;
+
+(* plus *)
+Hashtbl.add symbol_table HelmLibraryObjects.Peano.plus_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "plus",
+ None, Some HelmLibraryObjects.Peano.plus_SURI))
+ :: List.map acic2cexpr args));;
+
+Hashtbl.add symbol_table HelmLibraryObjects.BinInt.zplus_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "plus",
+ None, Some HelmLibraryObjects.BinInt.zplus_SURI))
+ :: List.map acic2cexpr args));;
+
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.rplus_SURI
+ (fun aid sid args acic2cexpr ->
+ let appl () =
+ Appl
+ (Some aid, (Symbol (Some sid, "plus",
+ None, Some HelmLibraryObjects.Reals.rplus_SURI))
+ :: List.map acic2cexpr args)
+ in
+ let rec aux acc = function
+ | [ Cic.AConst (nid, uri, []); n] when
+ UriManager.eq uri HelmLibraryObjects.Reals.r1_URI ->
+ (match n with
+ | Cic.AConst (_, uri, []) when
+ UriManager.eq uri HelmLibraryObjects.Reals.r1_URI ->
+ Num (Some aid, string_of_int (acc + 2))
+ | Cic.AAppl (_, Cic.AConst (_, uri, []) :: args) when
+ UriManager.eq uri HelmLibraryObjects.Reals.rplus_URI ->
+ aux (acc + 1) args
+ | _ -> appl ())
+ | _ -> appl ()
+ in
+ aux 0 args)
+;;
+
+(* zero and one *)
+
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.r0_SURI
+ (fun aid sid args acic2cexpr -> Num (Some sid, "0")) ;;
+
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.r1_SURI
+ (fun aid sid args acic2cexpr -> Num (Some sid, "1")) ;;
+
+(* times *)
+Hashtbl.add symbol_table HelmLibraryObjects.Peano.mult_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "times",
+ None, Some HelmLibraryObjects.Peano.mult_SURI))
+ :: List.map acic2cexpr args));;
+
+
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.rmult_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "times",
+ None, Some HelmLibraryObjects.Reals.rmult_SURI))
+ :: List.map acic2cexpr args));;
+(* minus *)
+Hashtbl.add symbol_table HelmLibraryObjects.Peano.minus_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "minus",
+ None, Some HelmLibraryObjects.Peano.minus_SURI))
+ :: List.map acic2cexpr args));;
+
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.rminus_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "minus",
+ None, Some HelmLibraryObjects.Reals.rminus_SURI))
+ :: List.map acic2cexpr args));;
+
+(* div *)
+Hashtbl.add symbol_table HelmLibraryObjects.Reals.rdiv_SURI
+ (fun aid sid args acic2cexpr ->
+ Appl
+ (Some aid, (Symbol (Some sid, "div",
+ None, Some HelmLibraryObjects.Reals.rdiv_SURI))
+ :: List.map acic2cexpr args));;
+
+
+
+
+(* END NOTATION *)
+
+
+let string_of_sort =
+ function
+ Cic.Prop -> "Prop"
+ | Cic.Set -> "Set"
+ | Cic.Type _ -> "Type" (* TASSI *)
+ | Cic.CProp -> "Type"
+;;
+
+let get_constructors uri i =
+ let inductive_types =
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
+ Cic.Constant _ -> assert false
+ | Cic.Variable _ -> assert false
+ | Cic.CurrentProof _ -> assert false
+ | Cic.InductiveDefinition (l,_,_) -> l
+ ) in
+ let (_,_,_,constructors) = List.nth inductive_types i in
+ constructors
+;;
+
+exception NotImplemented;;
+
+let acic2cexpr ids_to_inner_sorts t =
+ let rec acic2cexpr t =
+ let module C = Cic in
+ let module X = Xml in
+ let module U = UriManager in
+ let module C2A = Cic2acic in
+ let make_subst =
+ function
+ [] -> None
+ | l -> Some (List.map (function (uri,t) -> (uri, acic2cexpr t)) l) in
+ match t with
+ C.ARel (id,idref,n,b) -> LocalVar (Some id,b)
+ | C.AVar (id,uri,subst) ->
+ Symbol (Some id, UriManager.name_of_uri uri,
+ make_subst subst, Some (UriManager.string_of_uri uri))
+ | C.AMeta (id,n,l) ->
+ let l' =
+ List.rev_map
+ (function
+ None -> None
+ | Some t -> Some (acic2cexpr t)
+ ) l
+ in
+ Meta (Some id,("?" ^ (string_of_int n)),l')
+ | C.ASort (id,s) -> Symbol (Some id,string_of_sort s,None,None)
+ | C.AImplicit _ -> raise NotImplemented
+ | C.AProd (id,n,s,t) ->
+ (match n with
+ Cic.Anonymous ->
+ Appl (Some id, [Symbol (None, "arrow",None,None);
+ acic2cexpr s; acic2cexpr t])
+ | Cic.Name name ->
+ let sort =
+ (try Hashtbl.find ids_to_inner_sorts id
+ with Not_found ->
+ (* if the Prod does not have the sort, it means
+ that it has been generated by cic2content, and
+ thus is a statement *)
+ "Prop") in
+ let binder = if sort = "Prop" then "Forall" else "Prod" in
+ let decl = (name, acic2cexpr s) in
+ Binder (Some id,binder,decl,acic2cexpr t))
+ | C.ACast (id,v,t) -> acic2cexpr v
+ | C.ALambda (id,n,s,t) ->
+ let name =
+ (match n with
+ Cic.Anonymous -> "_"
+ | Cic.Name name -> name) in
+ let decl = (name, acic2cexpr s) in
+ Binder (Some id,"Lambda",decl,acic2cexpr t)
+ | C.ALetIn (id,n,s,t) ->
+ (match n with
+ Cic.Anonymous -> assert false
+ | Cic.Name name ->
+ let def = (name, acic2cexpr s) in
+ Letin (Some id,def,acic2cexpr t))
+ | C.AAppl (aid,C.AConst (sid,uri,subst)::tl) ->
+ let uri_str = UriManager.string_of_uri uri in
+ (try
+ (let f = Hashtbl.find symbol_table uri_str in
+ f aid sid tl acic2cexpr)
+ with Not_found ->
+ Appl (Some aid, Symbol (Some sid,UriManager.name_of_uri uri,
+ make_subst subst, Some uri_str)::List.map acic2cexpr tl))
+ | C.AAppl (aid,C.AMutInd (sid,uri,i,subst)::tl) ->
+ let inductive_types =
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
+ Cic.Constant _ -> assert false
+ | Cic.Variable _ -> assert false
+ | Cic.CurrentProof _ -> assert false
+ | Cic.InductiveDefinition (l,_,_) -> l
+ ) in
+ let (name,_,_,_) = List.nth inductive_types i in
+ let uri_str = UriManager.string_of_uri uri in
+ let puri_str =
+ uri_str ^ "#xpointer(1/" ^ (string_of_int (i + 1)) ^ ")" in
+ (try
+ (let f = Hashtbl.find symbol_table puri_str in
+ f aid sid tl acic2cexpr)
+ with Not_found ->
+ Appl (Some aid, Symbol (Some sid, name,
+ make_subst subst, Some uri_str)::List.map acic2cexpr tl))
+ | C.AAppl (id,li) ->
+ Appl (Some id, List.map acic2cexpr li)
+ | C.AConst (id,uri,subst) ->
+ let uri_str = UriManager.string_of_uri uri in
+ (try
+ let f = Hashtbl.find symbol_table uri_str in
+ f "dummy" id [] acic2cexpr
+ with Not_found ->
+ Symbol (Some id, UriManager.name_of_uri uri,
+ make_subst subst, Some (UriManager.string_of_uri uri)))
+ | C.AMutInd (id,uri,i,subst) ->
+ let inductive_types =
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
+ Cic.Constant _ -> assert false
+ | Cic.Variable _ -> assert false
+ | Cic.CurrentProof _ -> assert false
+ | Cic.InductiveDefinition (l,_,_) -> l
+ ) in
+ let (name,_,_,_) = List.nth inductive_types i in
+ let uri_str = UriManager.string_of_uri uri in
+ Symbol (Some id, name, make_subst subst, Some uri_str)
+ | C.AMutConstruct (id,uri,i,j,subst) ->
+ let constructors = get_constructors uri i in
+ let (name,_) = List.nth constructors (j-1) in
+ let uri_str = UriManager.string_of_uri uri in
+ Symbol (Some id, name, make_subst subst, Some uri_str)
+ | C.AMutCase (id,uri,typeno,ty,te,patterns) ->
+ let constructors = get_constructors uri typeno in
+ let named_patterns =
+ List.map2 (fun c p -> (fst c, acic2cexpr p))
+ constructors patterns in
+ Case (Some id, acic2cexpr te, named_patterns)
+ | C.AFix (id, no, funs) ->
+ let defs =
+ List.map (function (id1,n,_,_,bo) -> (n, acic2cexpr bo)) funs in
+ let (name,_) = List.nth defs no in
+ let body = LocalVar (None, name) in
+ Letrec (Some id, defs, body)
+ | C.ACoFix (id,no,funs) ->
+ let defs =
+ List.map (function (id1,n,_,bo) -> (n, acic2cexpr bo)) funs in
+ let (name,_) = List.nth defs no in
+ let body = LocalVar (None, name) in
+ Letrec (Some id, defs, body) in
+ acic2cexpr t
+;;
+
+
+
+
+
+
+
+
+
+
+
let debug_print = prerr_endline
-let fo_unif_subst subst context metasenv t1 t2 =
- try
- CicUnification.fo_unif_subst subst context metasenv t1 t2
- with
- (CicUnification.UnificationFailure msg) -> raise (RefineFailure msg)
- | (CicUnification.Uncertain msg) -> raise (Uncertain msg)
+let fo_unif_subst subst context metasenv t1 t2 ugraph =
+ try
+ CicUnification.fo_unif_subst subst context metasenv t1 t2 ugraph
+ with
+ (CicUnification.UnificationFailure msg) -> raise (RefineFailure msg)
+ | (CicUnification.Uncertain msg) -> raise (Uncertain msg)
;;
let rec split l n =
| (_,_) -> raise (AssertFailure "split: list too short")
;;
-let rec type_of_constant uri =
+let rec type_of_constant uri ugraph =
let module C = Cic in
let module R = CicReduction in
let module U = UriManager in
with Not_found -> assert false
in
*)
- match CicEnvironment.get_obj uri with
- C.Constant (_,_,ty,_) -> ty
- | C.CurrentProof (_,_,_,ty,_) -> ty
+ let obj,u= CicEnvironment.get_obj uri ugraph in
+ match obj with
+ C.Constant (_,_,ty,_) -> ty,u
+ | C.CurrentProof (_,_,_,ty,_) -> ty,u
| _ ->
raise
(RefineFailure ("Unknown constant definition " ^ U.string_of_uri uri))
-and type_of_variable uri =
+and type_of_variable uri ugraph =
let module C = Cic in
let module R = CicReduction in
let module U = UriManager in
with Not_found -> assert false
in
*)
- match CicEnvironment.get_obj uri with
- C.Variable (_,_,ty,_) -> ty
+ let obj,u = CicEnvironment.get_obj uri ugraph in
+ match obj with
+ C.Variable (_,_,ty,_) -> ty,u
| _ ->
raise
(RefineFailure
("Unknown variable definition " ^ UriManager.string_of_uri uri))
-and type_of_mutual_inductive_defs uri i =
+and type_of_mutual_inductive_defs uri i ugraph =
let module C = Cic in
let module R = CicReduction in
let module U = UriManager in
with Not_found -> assert false
in
*)
- match CicEnvironment.get_obj uri with
+ let obj,u = CicEnvironment.get_obj uri ugraph in
+ match obj with
C.InductiveDefinition (dl,_,_) ->
let (_,_,arity,_) = List.nth dl i in
- arity
+ arity,u
| _ ->
raise
(RefineFailure
("Unknown mutual inductive definition " ^ U.string_of_uri uri))
-and type_of_mutual_inductive_constr uri i j =
+and type_of_mutual_inductive_constr uri i j ugraph =
let module C = Cic in
let module R = CicReduction in
let module U = UriManager in
with Not_found -> assert false
in
*)
- match CicEnvironment.get_obj uri with
+ let obj,u = CicEnvironment.get_obj uri ugraph in
+ match obj with
C.InductiveDefinition (dl,_,_) ->
let (_,_,_,cl) = List.nth dl i in
let (_,ty) = List.nth cl (j-1) in
- ty
+ ty,u
| _ ->
raise
(RefineFailure
("Unkown mutual inductive definition " ^ U.string_of_uri uri))
+
(* type_of_aux' is just another name (with a different scope) for type_of_aux *)
(* the check_branch function checks if a branch of a case is refinable.
The problem is that outype is in general unknown, and we should
try to synthesize it from the above information, that is in general
a second order unification problem. *)
-
-and check_branch n context metasenv subst left_args_no actualtype term expectedtype =
+
+and check_branch n context metasenv subst left_args_no actualtype term expectedtype ugraph =
let module C = Cic in
(* let module R = CicMetaSubst in *)
let module R = CicReduction in
match R.whd ~subst context expectedtype with
C.MutInd (_,_,_) ->
- (n,context,actualtype, [term]), subst, metasenv
+ (n,context,actualtype, [term]), subst, metasenv, ugraph
| C.Appl (C.MutInd (_,_,_)::tl) ->
let (_,arguments) = split tl left_args_no in
- (n,context,actualtype, arguments@[term]), subst, metasenv
+ (n,context,actualtype, arguments@[term]), subst, metasenv, ugraph
| C.Prod (name,so,de) ->
(* we expect that the actual type of the branch has the due
number of Prod *)
(match R.whd ~subst context actualtype with
C.Prod (name',so',de') ->
- let subst, metasenv =
- fo_unif_subst subst context metasenv so so' in
+ let subst, metasenv, ugraph1 =
+ fo_unif_subst subst context metasenv so so' ugraph in
let term' =
(match CicSubstitution.lift 1 term with
C.Appl l -> C.Appl (l@[C.Rel 1])
| t -> C.Appl [t ; C.Rel 1]) in
(* we should also check that the name variable is anonymous in
the actual type de' ?? *)
- check_branch (n+1) ((Some (name,(C.Decl so)))::context) metasenv subst left_args_no de' term' de
+ check_branch (n+1) ((Some (name,(C.Decl so)))::context) metasenv subst left_args_no de' term' de ugraph1
| _ -> raise (AssertFailure "Wrong number of arguments"))
| _ -> raise (AssertFailure "Prod or MutInd expected")
-and type_of_aux' metasenv context t =
- let rec type_of_aux subst metasenv context t =
+and type_of_aux' metasenv context t ugraph =
+ let rec type_of_aux subst metasenv context t ugraph =
let module C = Cic in
let module S = CicSubstitution in
let module U = UriManager in
C.Rel n ->
(try
match List.nth context (n - 1) with
- Some (_,C.Decl t) -> S.lift n t,subst,metasenv
- | Some (_,C.Def (_,Some ty)) -> S.lift n ty,subst,metasenv
+ Some (_,C.Decl t) -> S.lift n t,subst,metasenv, ugraph
+ | Some (_,C.Def (_,Some ty)) -> S.lift n ty,subst,metasenv, ugraph
| Some (_,C.Def (bo,None)) ->
- type_of_aux subst metasenv context (S.lift n bo)
+ type_of_aux subst metasenv context (S.lift n bo) ugraph
| None -> raise (RefineFailure "Rel to hidden hypothesis")
with
_ -> raise (RefineFailure "Not a close term")
)
| C.Var (uri,exp_named_subst) ->
- let subst',metasenv' =
- check_exp_named_subst subst metasenv context exp_named_subst in
+ let subst',metasenv',ugraph1 =
+ check_exp_named_subst subst metasenv context exp_named_subst ugraph in
+ let ty_uri,ugraph1 = type_of_variable uri ugraph in
+
let ty =
- CicSubstitution.subst_vars exp_named_subst (type_of_variable uri)
+ CicSubstitution.subst_vars exp_named_subst ty_uri
in
- ty,subst',metasenv'
+ ty,subst',metasenv',ugraph1
| C.Meta (n,l) ->
(try
let (canonical_context, term,ty) = CicUtil.lookup_subst n subst in
- let subst,metasenv =
+ let subst,metasenv,ugraph1 =
check_metasenv_consistency n subst metasenv context
- canonical_context l
+ canonical_context l ugraph
in
(* trust or check ??? *)
- CicSubstitution.lift_meta l ty, subst, metasenv
+ CicSubstitution.lift_meta l ty, subst, metasenv, ugraph1
(* type_of_aux subst metasenv
context (CicSubstitution.lift_meta l term) *)
with CicUtil.Subst_not_found _ ->
let (_,canonical_context,ty) = CicUtil.lookup_meta n metasenv in
- let subst,metasenv =
+ let subst,metasenv, ugraph1 =
check_metasenv_consistency n subst metasenv context
- canonical_context l
+ canonical_context l ugraph
in
- CicSubstitution.lift_meta l ty, subst, metasenv)
- (* TASSI: CONSTRAINT *)
+ CicSubstitution.lift_meta l ty, subst, metasenv,ugraph1)
+ (* TASSI: CONSTRAINT *)
| C.Sort (C.Type t) ->
let t' = CicUniv.fresh() in
- if not (CicUniv.add_gt t' t ) then
- assert false (* t' is fresh! an error in CicUniv *)
- else
- C.Sort (C.Type t'),subst,metasenv
- (* TASSI: CONSTRAINT *)
- | C.Sort _ -> C.Sort (C.Type (CicUniv.fresh())),subst,metasenv
+ let ugraph1 = CicUniv.add_gt t' t ugraph in
+ (C.Sort (C.Type t')),subst,metasenv,ugraph1
+ (* TASSI: CONSTRAINT *)
+ | C.Sort _ -> C.Sort (C.Type (CicUniv.fresh())),subst,metasenv,ugraph
| C.Implicit _ -> raise (AssertFailure "21")
| C.Cast (te,ty) ->
- let _,subst',metasenv' =
- type_of_aux subst metasenv context ty in
- let inferredty,subst'',metasenv'' =
- type_of_aux subst' metasenv' context te
+ let _,subst',metasenv',ugraph1 =
+ type_of_aux subst metasenv context ty ugraph in
+ let inferredty,subst'',metasenv'',ugraph2 =
+ type_of_aux subst' metasenv' context te ugraph1
in
(try
- let subst''',metasenv''' =
- fo_unif_subst subst'' context metasenv'' inferredty ty
+ let subst''',metasenv''',ugraph3 =
+ fo_unif_subst subst'' context metasenv'' inferredty ty ugraph2
in
- ty,subst''',metasenv'''
+ ty,subst''',metasenv''',ugraph3
with
_ -> raise (RefineFailure "Cast"))
| C.Prod (name,s,t) ->
- let sort1,subst',metasenv' = type_of_aux subst metasenv context s in
- let sort2,subst'',metasenv'' =
- type_of_aux subst' metasenv' ((Some (name,(C.Decl s)))::context) t
+ let sort1,subst',metasenv',ugraph1 = type_of_aux subst metasenv context s ugraph in
+ let sort2,subst'',metasenv'',ugraph2 =
+ type_of_aux subst' metasenv' ((Some (name,(C.Decl s)))::context) t ugraph1
in
- sort_of_prod subst'' metasenv'' context (name,s) (sort1,sort2)
+ sort_of_prod subst'' metasenv'' context (name,s) (sort1,sort2) ugraph2
| C.Lambda (n,s,t) ->
- let sort1,subst',metasenv' = type_of_aux subst metasenv context s in
+ let sort1,subst',metasenv',ugraph1 =
+ type_of_aux subst metasenv context s ugraph
+ in
(match CicReduction.whd ~subst:subst' context sort1 with
C.Meta _
| C.Sort _ -> ()
instead it is a term of type %s" (CicPp.ppterm s)
(CicPp.ppterm sort1)))
) ;
- let type2,subst'',metasenv'' =
- type_of_aux subst' metasenv' ((Some (n,(C.Decl s)))::context) t
+ let type2,subst'',metasenv'',ugraph2 =
+ type_of_aux subst' metasenv' ((Some (n,(C.Decl s)))::context) t ugraph1
in
- C.Prod (n,s,type2),subst'',metasenv''
+ C.Prod (n,s,type2),subst'',metasenv'',ugraph2
| C.LetIn (n,s,t) ->
(* only to check if s is well-typed *)
- let ty,subst',metasenv' = type_of_aux subst metasenv context s in
- let inferredty,subst'',metasenv'' =
- type_of_aux subst' metasenv' ((Some (n,(C.Def (s,Some ty))))::context) t
+ let ty,subst',metasenv',ugraph1 =
+ type_of_aux subst metasenv context s ugraph
+ in
+ let inferredty,subst'',metasenv'',ugraph2 =
+ type_of_aux subst' metasenv' ((Some (n,(C.Def (s,Some ty))))::context) t ugraph1
in
(* One-step LetIn reduction. Even faster than the previous solution.
Moreover the inferred type is closer to the expected one. *)
- CicSubstitution.subst s inferredty,subst',metasenv'
+ CicSubstitution.subst s inferredty,subst',metasenv',ugraph2
| C.Appl (he::((_::_) as tl)) ->
- let hetype,subst',metasenv' = type_of_aux subst metasenv context he in
- let tlbody_and_type,subst'',metasenv'' =
+ let hetype,subst',metasenv',ugraph1 =
+ type_of_aux subst metasenv context he ugraph
+ in
+ let tlbody_and_type,subst'',metasenv'',ugraph2 =
List.fold_right
- (fun x (res,subst,metasenv) ->
- let ty,subst',metasenv' =
- type_of_aux subst metasenv context x
+ (fun x (res,subst,metasenv,ugraph) ->
+ let ty,subst',metasenv',ugraph1 =
+ type_of_aux subst metasenv context x ugraph
in
- (x, ty)::res,subst',metasenv'
- ) tl ([],subst',metasenv')
+ (x, ty)::res,subst',metasenv',ugraph1
+ ) tl ([],subst',metasenv',ugraph1)
in
- eat_prods subst'' metasenv'' context hetype tlbody_and_type
+ eat_prods subst'' metasenv'' context hetype tlbody_and_type ugraph2
| C.Appl _ -> raise (RefineFailure "Appl: no arguments")
| C.Const (uri,exp_named_subst) ->
- let subst',metasenv' =
- check_exp_named_subst subst metasenv context exp_named_subst in
+ let subst',metasenv',ugraph1 =
+ check_exp_named_subst subst metasenv context exp_named_subst ugraph in
+ let ty_uri,ugraph2 = type_of_constant uri ugraph1 in
let cty =
- CicSubstitution.subst_vars exp_named_subst (type_of_constant uri)
+ CicSubstitution.subst_vars exp_named_subst ty_uri
in
- cty,subst',metasenv'
+ cty,subst',metasenv',ugraph2
| C.MutInd (uri,i,exp_named_subst) ->
- let subst',metasenv' =
- check_exp_named_subst subst metasenv context exp_named_subst in
- let cty =
- CicSubstitution.subst_vars exp_named_subst
- (type_of_mutual_inductive_defs uri i)
+ let subst',metasenv',ugraph1 =
+ check_exp_named_subst subst metasenv context exp_named_subst ugraph
in
- cty,subst',metasenv'
+ let ty_uri,ugraph2 = type_of_mutual_inductive_defs uri i ugraph1 in
+ let cty =
+ CicSubstitution.subst_vars exp_named_subst ty_uri in
+ cty,subst',metasenv',ugraph2
| C.MutConstruct (uri,i,j,exp_named_subst) ->
- let subst',metasenv' =
- check_exp_named_subst subst metasenv context exp_named_subst in
+ let subst',metasenv',ugraph1 =
+ check_exp_named_subst subst metasenv context exp_named_subst ugraph in
+ let ty_uri,ugraph2 = type_of_mutual_inductive_constr uri i j ugraph1 in
let cty =
- CicSubstitution.subst_vars exp_named_subst
- (type_of_mutual_inductive_constr uri i j)
- in
- cty,subst',metasenv'
+ CicSubstitution.subst_vars exp_named_subst ty_uri in
+ cty,subst',metasenv',ugraph2
| C.MutCase (uri, i, outtype, term, pl) ->
(* first, get the inductive type (and noparams) in the environment *)
- let (_,b,arity,constructors), expl_params, no_left_params =
+ let (_,b,arity,constructors), expl_params, no_left_params,ugraph =
(*
let obj =
try
with Not_found -> assert false
in
*)
- match CicEnvironment.get_obj uri with
+ let obj,u = CicEnvironment.get_obj uri ugraph in
+ match obj with
C.InductiveDefinition (l,expl_params,parsno) ->
- List.nth l i , expl_params, parsno
+ List.nth l i , expl_params, parsno, u
| _ ->
raise
(RefineFailure
C.Appl (C.MutInd (uri,i,exp_named_subst)::(left_args @ right_args))
in
(* check consistency with the actual type of term *)
- let actual_type,subst,metasenv =
- type_of_aux subst metasenv context term in
- let _, subst, metasenv =
- type_of_aux subst metasenv context expected_type
+ let actual_type,subst,metasenv,ugraph1 =
+ type_of_aux subst metasenv context term ugraph in
+ let _, subst, metasenv,ugraph2 =
+ type_of_aux subst metasenv context expected_type ugraph1
in
let actual_type = CicReduction.whd ~subst context actual_type in
- let subst,metasenv =
- fo_unif_subst subst context metasenv expected_type actual_type
+ let subst,metasenv,ugraph3 =
+ fo_unif_subst subst context metasenv expected_type actual_type ugraph2
in
(* TODO: check if the sort elimination is allowed: [(I q1 ... qr)|B] *)
- let (_,outtypeinstances,subst,metasenv) =
+ let (_,outtypeinstances,subst,metasenv,ugraph4) =
List.fold_left
- (fun (j,outtypeinstances,subst,metasenv) p ->
+ (fun (j,outtypeinstances,subst,metasenv,ugraph) p ->
let constructor =
if left_args = [] then
(C.MutConstruct (uri,i,j,exp_named_subst))
else
(C.Appl (C.MutConstruct (uri,i,j,exp_named_subst)::left_args))
in
- let actual_type,subst,metasenv =
- type_of_aux subst metasenv context p in
- let expected_type, subst, metasenv =
- type_of_aux subst metasenv context constructor in
- let outtypeinstance,subst,metasenv =
+ let actual_type,subst,metasenv,ugraph1 =
+ type_of_aux subst metasenv context p ugraph in
+ let expected_type, subst, metasenv,ugraph2 =
+ type_of_aux subst metasenv context constructor ugraph1 in
+ let outtypeinstance,subst,metasenv,ugraph3 =
check_branch
0 context metasenv subst
- no_left_params actual_type constructor expected_type in
- (j+1,outtypeinstance::outtypeinstances,subst,metasenv))
- (1,[],subst,metasenv) pl in
+ no_left_params actual_type constructor expected_type ugraph2 in
+ (j+1,outtypeinstance::outtypeinstances,subst,metasenv,ugraph3))
+ (1,[],subst,metasenv,ugraph3) pl in
(* we are left to check that the outype matches his instances.
The easy case is when the outype is specified, that amount
to a trivial check. Otherwise, we should guess a type from
its instances *)
(* easy case *)
- let _, subst, metasenv =
+ let _, subst, metasenv,ugraph5 =
type_of_aux subst metasenv context
- (C.Appl ((outtype :: right_args) @ [term]))
+ (C.Appl ((outtype :: right_args) @ [term])) ugraph4
in
- let (subst,metasenv) =
+ let (subst,metasenv,ugraph6) =
List.fold_left
- (fun (subst,metasenv) (constructor_args_no,context,instance,args) ->
+ (fun (subst,metasenv,ugraph) (constructor_args_no,context,instance,args) ->
let instance' =
let appl =
let outtype' =
(*
(* if appl is not well typed then the type_of below solves the
* problem *)
- let (_, subst, metasenv) =
- type_of_aux subst metasenv context appl
+ let (_, subst, metasenv,ugraph1) =
+ type_of_aux subst metasenv context appl ugraph
in
*)
(* DEBUG
(* CicMetaSubst.whd subst context appl *)
CicReduction.whd ~subst context appl
in
- fo_unif_subst subst context metasenv instance instance')
- (subst,metasenv) outtypeinstances in
+ fo_unif_subst subst context metasenv instance instance' ugraph)
+ (subst,metasenv,ugraph5) outtypeinstances in
CicReduction.whd ~subst
- context (C.Appl(outtype::right_args@[term])),subst,metasenv
+ context (C.Appl(outtype::right_args@[term])),subst,metasenv,ugraph6
| C.Fix (i,fl) ->
- let subst,metasenv,types =
+ let subst,metasenv,types,ugraph1 =
List.fold_left
- (fun (subst,metasenv,types) (n,_,ty,_) ->
- let _,subst',metasenv' = type_of_aux subst metasenv context ty in
- subst',metasenv', Some (C.Name n,(C.Decl ty)) :: types
- ) (subst,metasenv,[]) fl
+ (fun (subst,metasenv,types,ugraph) (n,_,ty,_) ->
+ let _,subst',metasenv',ugraph1 = type_of_aux subst metasenv context ty ugraph in
+ subst',metasenv', Some (C.Name n,(C.Decl ty)) :: types, ugraph
+ ) (subst,metasenv,[],ugraph) fl
in
let len = List.length types in
let context' = types@context in
- let subst,metasenv =
+ let subst,metasenv,ugraph2 =
List.fold_left
- (fun (subst,metasenv) (name,x,ty,bo) ->
- let ty_of_bo,subst,metasenv =
- type_of_aux subst metasenv context' bo
+ (fun (subst,metasenv,ugraph) (name,x,ty,bo) ->
+ let ty_of_bo,subst,metasenv,ugraph1 =
+ type_of_aux subst metasenv context' bo ugraph
in
fo_unif_subst subst context' metasenv
- ty_of_bo (CicSubstitution.lift len ty)
- ) (subst,metasenv) fl in
+ ty_of_bo (CicSubstitution.lift len ty) ugraph1
+ ) (subst,metasenv,ugraph1) fl in
let (_,_,ty,_) = List.nth fl i in
- ty,subst,metasenv
+ ty,subst,metasenv,ugraph2
| C.CoFix (i,fl) ->
- let subst,metasenv,types =
+ let subst,metasenv,types,ugraph1 =
List.fold_left
- (fun (subst,metasenv,types) (n,ty,_) ->
- let _,subst',metasenv' = type_of_aux subst metasenv context ty in
- subst',metasenv', Some (C.Name n,(C.Decl ty)) :: types
- ) (subst,metasenv,[]) fl
+ (fun (subst,metasenv,types,ugraph) (n,ty,_) ->
+ let _,subst',metasenv',ugraph1 = type_of_aux subst metasenv context ty ugraph in
+ subst',metasenv', Some (C.Name n,(C.Decl ty)) :: types, ugraph1
+ ) (subst,metasenv,[],ugraph) fl
in
let len = List.length types in
let context' = types@context in
- let subst,metasenv =
+ let subst,metasenv,ugraph2 =
List.fold_left
- (fun (subst,metasenv) (name,ty,bo) ->
- let ty_of_bo,subst,metasenv =
- type_of_aux subst metasenv context' bo
+ (fun (subst,metasenv,ugraph) (name,ty,bo) ->
+ let ty_of_bo,subst,metasenv,ugraph1 =
+ type_of_aux subst metasenv context' bo ugraph
in
fo_unif_subst subst context' metasenv
- ty_of_bo (CicSubstitution.lift len ty)
- ) (subst,metasenv) fl in
+ ty_of_bo (CicSubstitution.lift len ty) ugraph1
+ ) (subst,metasenv,ugraph1) fl in
let (_,ty,_) = List.nth fl i in
- ty,subst,metasenv
+ ty,subst,metasenv,ugraph2
(* check_metasenv_consistency checks that the "canonical" context of a
metavariable is consitent - up to relocation via the relocation list l -
with the actual context *)
and check_metasenv_consistency
- metano subst metasenv context canonical_context l
+ metano subst metasenv context canonical_context l ugraph
=
let module C = Cic in
let module R = CicReduction in
in
try
List.fold_left2
- (fun (subst,metasenv) t ct ->
+ (fun (subst,metasenv,ugraph) t ct ->
match (t,ct) with
_,None ->
- subst,metasenv
+ subst,metasenv,ugraph
| Some t,Some (_,C.Def (ct,_)) ->
(try
- fo_unif_subst subst context metasenv t ct
+ fo_unif_subst subst context metasenv t ct ugraph
with e -> raise (RefineFailure (sprintf "The local context is not consistent with the canonical context, since %s cannot be unified with %s. Reason: %s" (CicMetaSubst.ppterm subst t) (CicMetaSubst.ppterm subst ct) (match e with AssertFailure msg -> msg | _ -> (Printexc.to_string e)))))
| Some t,Some (_,C.Decl ct) ->
- let inferredty,subst',metasenv' =
- type_of_aux subst metasenv context t
+ let inferredty,subst',metasenv',ugraph1 =
+ type_of_aux subst metasenv context t ugraph
in
(try
fo_unif_subst
- subst' context metasenv' inferredty ct
+ subst' context metasenv' inferredty ct ugraph1
with e -> raise (RefineFailure (sprintf "The local context is not consistent with the canonical context, since the type %s of %s cannot be unified with the expected type %s. Reason: %s" (CicMetaSubst.ppterm subst' inferredty) (CicMetaSubst.ppterm subst' t) (CicMetaSubst.ppterm subst' ct) (match e with AssertFailure msg -> msg | _ -> (Printexc.to_string e)))))
| None, Some _ ->
raise (RefineFailure (sprintf
"Not well typed metavariable instance %s: the local context does not instantiate an hypothesis even if the hypothesis is not restricted in the canonical context %s"
(CicMetaSubst.ppterm subst (Cic.Meta (metano, l)))
(CicMetaSubst.ppcontext subst canonical_context)))
- ) (subst,metasenv) l lifted_canonical_context
+ ) (subst,metasenv,ugraph) l lifted_canonical_context
with
Invalid_argument _ ->
raise
(CicMetaSubst.ppterm subst (Cic.Meta (metano, l)))
(CicMetaSubst.ppcontext subst canonical_context)))
- and check_exp_named_subst metasubst metasenv context =
- let rec check_exp_named_subst_aux metasubst metasenv substs =
- function
- [] -> metasubst,metasenv
+ and check_exp_named_subst metasubst metasenv context tl ugraph =
+ let rec check_exp_named_subst_aux metasubst metasenv substs tl ugraph =
+ match tl with
+ [] -> metasubst,metasenv,ugraph
| ((uri,t) as subst)::tl ->
+ let ty_uri,ugraph1 = type_of_variable uri ugraph in
let typeofvar =
- CicSubstitution.subst_vars substs (type_of_variable uri) in
+ CicSubstitution.subst_vars substs ty_uri in
(* CSC: why was this code here? it is wrong
(match CicEnvironment.get_cooked_obj ~trust:false uri with
Cic.Variable (_,Some bo,_,_) ->
("Unkown variable definition " ^ UriManager.string_of_uri uri))
) ;
*)
- let typeoft,metasubst',metasenv' =
- type_of_aux metasubst metasenv context t
+ let typeoft,metasubst',metasenv',ugraph2 =
+ type_of_aux metasubst metasenv context t ugraph1
in
- let metasubst'',metasenv'' =
+ let metasubst'',metasenv'',ugraph3 =
try
- fo_unif_subst metasubst' context metasenv' typeoft typeofvar
+ fo_unif_subst metasubst' context metasenv' typeoft typeofvar ugraph2
with _ ->
raise (RefineFailure
("Wrong Explicit Named Substitution: " ^ CicMetaSubst.ppterm metasubst' typeoft ^
" not unifiable with " ^ CicMetaSubst.ppterm metasubst' typeofvar))
in
- check_exp_named_subst_aux metasubst'' metasenv'' (substs@[subst]) tl
+ check_exp_named_subst_aux metasubst'' metasenv'' (substs@[subst]) tl ugraph3
in
- check_exp_named_subst_aux metasubst metasenv []
+ check_exp_named_subst_aux metasubst metasenv [] tl ugraph
- and sort_of_prod subst metasenv context (name,s) (t1, t2) =
+
+ and sort_of_prod subst metasenv context (name,s) (t1, t2) ugraph =
let module C = Cic in
let context_for_t2 = (Some (name,C.Decl s))::context in
let t1'' = CicReduction.whd ~subst context t1 in
match (t1'', t2'') with
(C.Sort s1, C.Sort s2)
when (s2 = C.Prop or s2 = C.Set or s2 = C.CProp) -> (* different than Coq manual!!! *)
- C.Sort s2,subst,metasenv
+ C.Sort s2,subst,metasenv,ugraph
| (C.Sort (C.Type t1), C.Sort (C.Type t2)) ->
(* TASSI: CONSRTAINTS: the same in cictypechecker, doubletypeinference *)
let t' = CicUniv.fresh() in
- if not (CicUniv.add_ge t' t1) || not (CicUniv.add_ge t' t2) then
- assert false ; (* not possible, error in CicUniv *)
- C.Sort (C.Type t'),subst,metasenv
+ let ugraph1 = CicUniv.add_ge t' t1 ugraph in
+ let ugraph2 = CicUniv.add_ge t' t2 ugraph1 in
+ C.Sort (C.Type t'),subst,metasenv,ugraph2
| (C.Sort _,C.Sort (C.Type t1)) ->
(* TASSI: CONSRTAINTS: the same in cictypechecker, doubletypeinference *)
- C.Sort (C.Type t1),subst,metasenv
- | (C.Meta _, C.Sort _) -> t2'',subst,metasenv
+ C.Sort (C.Type t1),subst,metasenv,ugraph
+ | (C.Meta _, C.Sort _) -> t2'',subst,metasenv,ugraph
| (C.Sort _,C.Meta _) | (C.Meta _,C.Meta _) ->
(* TODO how can we force the meta to become a sort? If we don't we
* brake the invariant that refine produce only well typed terms *)
* Sort (Prop | Set | CProp) then the result is the rhs *)
let (metasenv,idx) =
CicMkImplicit.mk_implicit_sort metasenv subst in
- let (subst, metasenv) =
- fo_unif_subst subst context_for_t2 metasenv (C.Meta (idx,[])) t2''
+ let (subst, metasenv,ugraph1) =
+ fo_unif_subst subst context_for_t2 metasenv (C.Meta (idx,[])) t2'' ugraph
in
- t2'',subst,metasenv
+ t2'',subst,metasenv,ugraph1
| (_,_) ->
raise (RefineFailure (sprintf
"Two sorts were expected, found %s (that reduces to %s) and %s (that reduces to %s)"
(CicPp.ppterm t1) (CicPp.ppterm t1'') (CicPp.ppterm t2)
(CicPp.ppterm t2'')))
- and eat_prods subst metasenv context hetype tlbody_and_type =
+ and eat_prods subst metasenv context hetype tlbody_and_type ugraph =
let rec mk_prod metasenv context =
function
[] ->
metasenv,Cic.Prod (name,meta,target)
in
let metasenv,hetype' = mk_prod metasenv context tlbody_and_type in
- let (subst, metasenv) =
+ let (subst, metasenv,ugraph1) =
try
- fo_unif_subst subst context metasenv hetype hetype'
+ fo_unif_subst subst context metasenv hetype hetype' ugraph
with exn ->
prerr_endline (Printf.sprintf "hetype=%s\nhetype'=%s\nmetasenv=%s\nsubst=%s"
(CicPp.ppterm hetype)
raise exn
in
- let rec eat_prods metasenv subst context hetype =
+ let rec eat_prods metasenv subst context hetype ugraph =
function
- [] -> metasenv,subst,hetype
+ [] -> metasenv,subst,hetype,ugraph
| (hete, hety)::tl ->
(match hetype with
Cic.Prod (n,s,t) ->
- let subst,metasenv =
+ let subst,metasenv,ugraph1 =
try
- fo_unif_subst subst context metasenv hety s
+ fo_unif_subst subst context metasenv hety s ugraph
with exn ->
prerr_endline (Printf.sprintf "hety=%s\ns=%s\nmetasenv=%s"
(CicMetaSubst.ppterm subst hety)
*)
eat_prods metasenv subst context
(* (CicMetaSubst.subst subst hete t) tl *)
- (CicSubstitution.subst hete t) tl
+ (CicSubstitution.subst hete t) ugraph1 tl
| _ -> assert false
)
in
- let metasenv,subst,t =
- eat_prods metasenv subst context hetype' tlbody_and_type
+ let metasenv,subst,t,ugraph2 =
+ eat_prods metasenv subst context hetype' ugraph1 tlbody_and_type
in
- t,subst,metasenv
+ t,subst,metasenv,ugraph2
(* eat prods ends here! *)
in
- let ty,subst',metasenv' =
- type_of_aux [] metasenv context t
+ let ty,subst',metasenv',ugraph1 =
+ type_of_aux [] metasenv context t ugraph
in
let substituted_t = CicMetaSubst.apply_subst subst' t in
let substituted_ty = CicMetaSubst.apply_subst subst' ty in
(n,context',ty')
) substituted_metasenv
in
- (cleaned_t,cleaned_ty,cleaned_metasenv)
+ (cleaned_t,cleaned_ty,cleaned_metasenv,ugraph1)
;;
-
-
(* DEBUGGING ONLY
let type_of_aux' metasenv context term =
try
(* refines [term] and returns the refined form of [term], *)
(* its type the new metasenv. *)
val type_of_aux':
- Cic.metasenv -> Cic.context -> Cic.term ->
- Cic.term * Cic.term * Cic.metasenv
+ Cic.metasenv -> Cic.context -> Cic.term -> CicUniv.universe_graph ->
+ Cic.term * Cic.term * Cic.metasenv * CicUniv.universe_graph
let debug_print = prerr_endline
-let type_of_aux' metasenv subst context term =
+let type_of_aux' metasenv subst context term ugraph =
try
- CicTypeChecker.type_of_aux' ~subst metasenv context term
+ CicTypeChecker.type_of_aux' ~subst metasenv context term ugraph
with
CicTypeChecker.TypeCheckerFailure msg ->
let msg =
(CicMetaSubst.ppsubst subst) msg) in
raise (AssertFailure msg);;
(*
+>>>>>>> 1.40
try
- CicMetaSubst.type_of_aux' metasenv subst context term
+ CicMetaSubst.type_of_aux' metasenv subst context term ugraph
with
| CicMetaSubst.MetaSubstFailure msg ->
raise (AssertFailure
| t -> t
;;
-let rec beta_expand test_equality_only metasenv subst context t arg =
+let rec beta_expand test_equality_only metasenv subst context t arg ugraph =
let module S = CicSubstitution in
let module C = Cic in
- let rec aux metasenv subst n context t' =
+ let rec aux metasenv subst n context t' ugraph =
try
- let subst,metasenv =
- fo_unif_subst test_equality_only subst context metasenv
- (CicSubstitution.lift n arg) t'
+
+ let subst,metasenv,ugraph1 =
+ fo_unif_subst test_equality_only subst context metasenv
+ (CicSubstitution.lift n arg) t' ugraph
+
in
- subst,metasenv,C.Rel (1 + n)
+ subst,metasenv,C.Rel (1 + n),ugraph1
with
Uncertain _
| UnificationFailure _ ->
match t' with
- | C.Rel m -> subst,metasenv, if m <= n then C.Rel m else C.Rel (m+1)
+ | C.Rel m -> subst,metasenv,
+ (if m <= n then C.Rel m else C.Rel (m+1)),ugraph
| C.Var (uri,exp_named_subst) ->
- let subst,metasenv,exp_named_subst' =
- aux_exp_named_subst metasenv subst n context exp_named_subst
+ let subst,metasenv,exp_named_subst',ugraph1 =
+ aux_exp_named_subst metasenv subst n context exp_named_subst ugraph
in
- subst,metasenv,C.Var (uri,exp_named_subst')
+(* THIS WAS BEFORE ----
+ subst,metasenv,C.Var (uri,exp_named_subst'),ugraph1
+ | C.Meta (i,l) as t->
+ (try
+ let (_, t') = CicMetaSubst.lookup_subst i subst in
+ aux metasenv subst n context (CicSubstitution.lift_meta l t')
+ ugraph
+ with CicMetaSubst.SubstNotFound _ ->
+ let (subst, metasenv, context, local_context,ugraph1) =
+ List.fold_left
+ (fun (subst, metasenv, context, local_context,ugraph) t ->
+ match t with
+ | None ->
+ (subst, metasenv, context, None::local_context, ugraph)
+--------- *)
+ subst,metasenv,C.Var (uri,exp_named_subst'),ugraph1
| C.Meta (i,l) ->
(* andrea: in general, beta_expand can create badly typed
terms. This happens quite seldom in practice, UNLESS we
(function
Some t -> Some (CicSubstitution.lift 1 t)
| None -> None) l in
- subst, metasenv, C.Meta (i,l)
+ subst, metasenv, C.Meta (i,l), ugraph
(*
let (subst, metasenv, context, local_context) =
List.fold_right
(fun t (subst, metasenv, context, local_context) ->
match t with
| None -> (subst, metasenv, context, None :: local_context)
+
| Some t ->
- let (subst, metasenv, t) =
- aux metasenv subst n context t
+ let (subst, metasenv, t, ugraph1) =
+ aux metasenv subst n context t ugraph
in
+(* THIS WAS BEFORE ----
+ (subst, metasenv, context,
+ (Some t)::local_context,ugraph1))
+ (subst, metasenv, context, [],ugraph) l
+ in
+ (subst, metasenv,(C.Meta (i, local_context)),ugraph1))
+-------- *)
(subst, metasenv, context, Some t :: local_context))
l (subst, metasenv, context, [])
in
prerr_endline ("nuova meta :" ^ (CicPp.ppterm (C.Meta (i, local_context))));
(subst, metasenv, C.Meta (i, local_context)) *)
| C.Sort _
- | C.Implicit _ as t -> subst,metasenv,t
+ | C.Implicit _ as t -> subst,metasenv,t,ugraph
| C.Cast (te,ty) ->
- let subst,metasenv,te' = aux metasenv subst n context te in
- let subst,metasenv,ty' = aux metasenv subst n context ty in
- subst,metasenv,C.Cast (te', ty')
+ let subst,metasenv,te',ugraph1 =
+ aux metasenv subst n context te ugraph in
+ let subst,metasenv,ty',ugraph2 =
+ aux metasenv subst n context ty ugraph1 in
+ (* TASSI: sure this is in serial? *)
+ subst,metasenv,(C.Cast (te', ty')),ugraph2
| C.Prod (nn,s,t) ->
- let subst,metasenv,s' = aux metasenv subst n context s in
- let subst,metasenv,t' =
- aux metasenv subst (n+1) ((Some (nn, C.Decl s))::context) t
+ let subst,metasenv,s',ugraph1 =
+ aux metasenv subst n context s ugraph in
+ let subst,metasenv,t',ugraph2 =
+ aux metasenv subst (n+1) ((Some (nn, C.Decl s))::context) t
+ ugraph1
in
- subst,metasenv,C.Prod (nn, s', t')
+ (* TASSI: sure this is in serial? *)
+ subst,metasenv,(C.Prod (nn, s', t')),ugraph2
| C.Lambda (nn,s,t) ->
- let subst,metasenv,s' = aux metasenv subst n context s in
- let subst,metasenv,t' =
- aux metasenv subst (n+1) ((Some (nn, C.Decl s))::context) t
+ let subst,metasenv,s',ugraph1 =
+ aux metasenv subst n context s ugraph in
+ let subst,metasenv,t',ugraph2 =
+ aux metasenv subst (n+1) ((Some (nn, C.Decl s))::context) t ugraph1
in
- subst,metasenv,C.Lambda (nn, s', t')
+ (* TASSI: sure this is in serial? *)
+ subst,metasenv,(C.Lambda (nn, s', t')),ugraph2
| C.LetIn (nn,s,t) ->
- let subst,metasenv,s' = aux metasenv subst n context s in
- let subst,metasenv,t' =
+ let subst,metasenv,s',ugraph1 =
+ aux metasenv subst n context s ugraph in
+ let subst,metasenv,t',ugraph2 =
aux metasenv subst (n+1) ((Some (nn, C.Def (s,None)))::context) t
+ ugraph1
in
- subst,metasenv,C.LetIn (nn, s', t')
+ (* TASSI: sure this is in serial? *)
+ subst,metasenv,(C.LetIn (nn, s', t')),ugraph2
| C.Appl l ->
- let subst,metasenv,revl' =
+ let subst,metasenv,revl',ugraph1 =
List.fold_left
- (fun (subst,metasenv,appl) t ->
- let subst,metasenv,t' = aux metasenv subst n context t in
- subst,metasenv,t'::appl
- ) (subst,metasenv,[]) l
+ (fun (subst,metasenv,appl,ugraph) t ->
+ let subst,metasenv,t',ugraph1 =
+ aux metasenv subst n context t ugraph in
+ subst,metasenv,(t'::appl),ugraph1
+ ) (subst,metasenv,[],ugraph) l
in
- subst,metasenv,C.Appl (List.rev revl')
+ subst,metasenv,(C.Appl (List.rev revl')),ugraph1
| C.Const (uri,exp_named_subst) ->
- let subst,metasenv,exp_named_subst' =
- aux_exp_named_subst metasenv subst n context exp_named_subst
+ let subst,metasenv,exp_named_subst',ugraph1 =
+ aux_exp_named_subst metasenv subst n context exp_named_subst ugraph
in
- subst,metasenv,C.Const (uri,exp_named_subst')
+ subst,metasenv,(C.Const (uri,exp_named_subst')),ugraph1
| C.MutInd (uri,i,exp_named_subst) ->
- let subst,metasenv,exp_named_subst' =
- aux_exp_named_subst metasenv subst n context exp_named_subst
+ let subst,metasenv,exp_named_subst',ugraph1 =
+ aux_exp_named_subst metasenv subst n context exp_named_subst ugraph
in
- subst,metasenv,C.MutInd (uri,i,exp_named_subst')
+ subst,metasenv,(C.MutInd (uri,i,exp_named_subst')),ugraph1
| C.MutConstruct (uri,i,j,exp_named_subst) ->
- let subst,metasenv,exp_named_subst' =
- aux_exp_named_subst metasenv subst n context exp_named_subst
+ let subst,metasenv,exp_named_subst',ugraph1 =
+ aux_exp_named_subst metasenv subst n context exp_named_subst ugraph
in
- subst,metasenv,C.MutConstruct (uri,i,j,exp_named_subst')
+ subst,metasenv,(C.MutConstruct (uri,i,j,exp_named_subst')),ugraph1
| C.MutCase (sp,i,outt,t,pl) ->
- let subst,metasenv,outt' = aux metasenv subst n context outt in
- let subst,metasenv,t' = aux metasenv subst n context t in
- let subst,metasenv,revpl' =
+ let subst,metasenv,outt',ugraph1 =
+ aux metasenv subst n context outt ugraph in
+ let subst,metasenv,t',ugraph2 =
+ aux metasenv subst n context t ugraph1 in
+ let subst,metasenv,revpl',ugraph3 =
List.fold_left
- (fun (subst,metasenv,pl) t ->
- let subst,metasenv,t' = aux metasenv subst n context t in
- subst,metasenv,t'::pl
- ) (subst,metasenv,[]) pl
+ (fun (subst,metasenv,pl,ugraph) t ->
+ let subst,metasenv,t',ugraph1 =
+ aux metasenv subst n context t ugraph in
+ subst,metasenv,(t'::pl),ugraph1
+ ) (subst,metasenv,[],ugraph2) pl
in
- subst,metasenv,C.MutCase (sp,i,outt', t', List.rev revpl')
+ subst,metasenv,(C.MutCase (sp,i,outt', t', List.rev revpl')),ugraph3
+ (* TASSI: not sure this is serial *)
| C.Fix (i,fl) ->
(*CSC: not implemented
let tylen = List.length fl in
fl
in
C.Fix (i, substitutedfl)
-*) (* subst,metasenv,CicMetaSubst.lift subst 1 t' *)
- subst,metasenv,CicSubstitution.lift 1 t'
+*)
+ subst,metasenv,(CicSubstitution.lift 1 t' ),ugraph
| C.CoFix (i,fl) ->
(*CSC: not implemented
let tylen = List.length fl in
fl
in
C.CoFix (i, substitutedfl)
-*) (* subst,metasenv,CicMetasubst.lift subst 1 t' *)
- subst,metasenv,CicSubstitution.lift 1 t'
- and aux_exp_named_subst metasenv subst n context ens =
+*)
+ subst,metasenv,(CicSubstitution.lift 1 t'), ugraph
+
+ and aux_exp_named_subst metasenv subst n context ens ugraph =
List.fold_right
- (fun (uri,t) (subst,metasenv,l) ->
- let subst,metasenv,t' = aux metasenv subst n context t in
- subst,metasenv,(uri,t')::l) ens (subst,metasenv,[])
+ (fun (uri,t) (subst,metasenv,l,ugraph) ->
+ let subst,metasenv,t',ugraph1 = aux metasenv subst n context t ugraph in
+ subst,metasenv,((uri,t')::l),ugraph1) ens (subst,metasenv,[],ugraph)
in
- let argty = type_of_aux' metasenv subst context arg in
+ let argty,ugraph1 = type_of_aux' metasenv subst context arg ugraph in
let fresh_name =
FreshNamesGenerator.mk_fresh_name ~subst
metasenv context (Cic.Name "Heta") ~typ:argty
in
- let subst,metasenv,t' = aux metasenv subst 0 context t in
+ let subst,metasenv,t',ugraph2 = aux metasenv subst 0 context t ugraph1 in
(* prova *)
(* old
subst, metasenv, C.Appl [C.Lambda (fresh_name,argty,t') ; arg]
*)
- subst, metasenv, C.Lambda (fresh_name,argty,t')
+ subst, metasenv, C.Lambda (fresh_name,argty,t'), ugraph2
+
-and beta_expand_many test_equality_only metasenv subst context t args =
- let subst,metasenv,hd =
+(* WAS ---------
+and beta_expand_many test_equality_only metasenv subst context t l ugraph =
+ List.fold_left
+ (fun (subst,metasenv,t,ugraph) arg ->
+ beta_expand test_equality_only metasenv subst context t arg ugraph
+ ) (subst,metasenv,t,ugraph) l
+------- *)
+and beta_expand_many test_equality_only metasenv subst context t args ugraph =
+ let subst,metasenv,hd,ugraph =
List.fold_right
- (fun arg (subst,metasenv,t) ->
- let subst,metasenv,t =
- beta_expand test_equality_only metasenv subst context t arg in
- subst,metasenv,t
- ) args (subst,metasenv,t) in
- subst,metasenv,hd
+ (fun arg (subst,metasenv,t,ugraph) ->
+ let subst,metasenv,t,ugraph1 =
+ beta_expand test_equality_only
+ metasenv subst context t arg ugraph
+ in
+ subst,metasenv,t,ugraph1
+ ) args (subst,metasenv,t,ugraph)
+ in
+ subst,metasenv,hd,ugraph
+
(* NUOVA UNIFICAZIONE *)
(* A substitution is a (int * Cic.term) list that associates a
a new substitution which is _NOT_ unwinded. It must be unwinded before
applying it. *)
-and fo_unif_subst test_equality_only subst context metasenv t1 t2 =
+and fo_unif_subst test_equality_only subst context metasenv t1 t2 ugraph =
let module C = Cic in
let module R = CicReduction in
let module S = CicSubstitution in
let t1 = deref subst t1 in
let t2 = deref subst t2 in
- if R.are_convertible ~subst ~metasenv context t1 t2 then
- subst, metasenv
- else
- match (t1, t2) with
- (C.Meta (n,ln), C.Meta (m,lm)) when n=m ->
- let _,subst,metasenv =
+ let b,ugraph =
+ R.are_convertible ~subst ~metasenv context t1 t2 ugraph
+ in
+ if b then
+ subst, metasenv, ugraph
+ else
+ match (t1, t2) with
+ (C.Meta (n,ln), C.Meta (m,lm)) when n=m ->
+(*
+ let ok,subst,metasenv,ugraph1 =
+ try
+ List.fold_left2
+ (fun (b,subst,metasenv,ugraph) t1 t2 ->
+ if b then true,subst,metasenv,ugraph else
+ match t1,t2 with
+ None,_
+ | _,None -> true,subst,metasenv,ugraph
+ | Some t1', Some t2' ->
+ (* First possibility: restriction *)
+ (* Second possibility: unification *)
+ (* Third possibility: convertibility *)
+ let b',ugraph1 =
+ R.are_convertible subst context t1' t2' ugraph in
+ if b' then
+ true,subst,metasenv,ugraph1
+ else
+ (try
+ let subst,metasenv,ugraph2 =
+ fo_unif_subst
+ (* TASSI: is this another try that should use ugraph? *)
+ test_equality_only subst context metasenv t1' t2' ugraph
+ in
+ true,subst,metasenv,ugraph2
+ with
+ Not_found -> false,subst,metasenv,ugraph1)
+ ) (true,subst,metasenv,ugraph) ln lm
+ with
+ Invalid_argument _ ->
+ raise (UnificationFailure (sprintf
+ "Error trying to unify %s with %s: the lengths of the two local contexts do not match." (CicMetaSubst.ppterm subst t1) (CicMetaSubst.ppterm subst t2)))
+ in
+ if ok then
+ subst,metasenv,ugraph1
+ else
+ raise (UnificationFailure (sprintf
+ "Error trying to unify %s with %s: the algorithm tried to check whether the two substitutions are convertible; if they are not, it tried to unify the two substitutions. No restriction was attempted."
+ (CicMetaSubst.ppterm subst t1) (CicMetaSubst.ppterm subst t2)))
+ *)
+ let _,subst,metasenv,ugraph1 =
(try
List.fold_left2
- (fun (j,subst,metasenv) t1 t2 ->
+ (fun (j,subst,metasenv,ugraph) t1 t2 ->
match t1,t2 with
None,_
- | _,None -> j+1,subst,metasenv
+ | _,None -> j+1,subst,metasenv,ugraph
| Some t1', Some t2' ->
(* First possibility: restriction *)
(* Second possibility: unification *)
(* Third possibility: convertibility *)
- if R.are_convertible ~subst ~metasenv context t1' t2' then
- j+1,subst,metasenv
- else
- (try
- let subst,metasenv =
- fo_unif_subst
- test_equality_only
- subst context metasenv t1' t2'
- in
- j+1,subst,metasenv
- with
- Uncertain _
- | UnificationFailure _ ->
+ let b, ugraph1 =
+ R.are_convertible
+ ~subst ~metasenv context t1' t2' ugraph
+ in
+ if b then
+ j+1,subst,metasenv, ugraph1
+ else
+ (try
+ let subst,metasenv,ugraph2 =
+ fo_unif_subst
+ test_equality_only
+ subst context metasenv t1' t2' ugraph
+ in
+ j+1,subst,metasenv,ugraph2
+ with
+ Uncertain _
+ | UnificationFailure _ ->
prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (string_of_int j));
let metasenv, subst =
CicMetaSubst.restrict
subst [(n,j)] metasenv in
- j+1,subst,metasenv)
- ) (1,subst,metasenv) ln lm
+ j+1,subst,metasenv,ugraph1)
+ ) (1,subst,metasenv,ugraph) ln lm
with
Exit ->
raise
(*
(sprintf
"Error trying to unify %s with %s: the lengths of the two local contexts do not match." (CicMetaSubst.ppterm subst t1) (CicMetaSubst.ppterm subst t2))))*)
- in subst,metasenv
+ in subst,metasenv,ugraph1
+
| (C.Meta (n,_), C.Meta (m,_)) when n>m ->
- fo_unif_subst test_equality_only subst context metasenv t2 t1
+ fo_unif_subst test_equality_only subst context metasenv t2 t1 ugraph
| (C.Meta (n,l), t)
| (t, C.Meta (n,l)) ->
let swap =
let lower = fun x y -> if swap then y else x in
let upper = fun x y -> if swap then x else y in
let fo_unif_subst_ordered
- test_equality_only subst context metasenv m1 m2 =
+ test_equality_only subst context metasenv m1 m2 ugraph =
fo_unif_subst test_equality_only subst context metasenv
- (lower m1 m2) (upper m1 m2)
+ (lower m1 m2) (upper m1 m2) ugraph
in
+(*
+ begin
+ try
+ let (_, oldt) = CicMetaSubst.lookup_subst n subst in
+ let lifted_oldt = S.lift_meta l oldt in
+ let ty_lifted_oldt,ugraph1 =
+ type_of_aux' metasenv subst context lifted_oldt ugraph
+ in
+ let tyt,ugraph2 = type_of_aux' metasenv subst context t ugraph1 in
+ let (subst, metasenv, ugraph3) =
+ fo_unif_subst_ordered test_equality_only subst context metasenv
+ tyt ty_lifted_oldt ugraph2
+ in
+ fo_unif_subst_ordered
+ test_equality_only subst context metasenv t lifted_oldt ugraph3
+ with CicMetaSubst.SubstNotFound _ ->
+ (* First of all we unify the type of the meta with the type of the term *)
+ let subst,metasenv,ugraph1 =
+ let (_,_,meta_type) = CicUtil.lookup_meta n metasenv in
+ (try
+ let tyt,ugraph1 = type_of_aux' metasenv subst context t ugraph in
+ fo_unif_subst
+ test_equality_only
+ subst context metasenv tyt (S.lift_meta l meta_type) ugraph1
+ with AssertFailure _ ->
+ (* TODO huge hack!!!!
+ * we keep on unifying/refining in the hope that the problem will be
+ * eventually solved. In the meantime we're breaking a big invariant:
+ * the terms that we are unifying are no longer well typed in the
+ * current context (in the worst case we could even diverge)
+ *)
+(*
+prerr_endline "********* FROM NOW ON EVERY REASONABLE INVARIANT IS BROKEN.";
+prerr_endline "********* PROCEED AT YOUR OWN RISK. AND GOOD LUCK." ;
+*)
+ (subst, metasenv,ugraph))
+ in
+ let t',metasenv,subst =
+ try
+ (* TASSI: I hope delift does nothing with universes *)
+ CicMetaSubst.delift n subst context metasenv l t
+ with
+ (CicMetaSubst.MetaSubstFailure msg)-> raise(UnificationFailure msg)
+ | (CicMetaSubst.Uncertain msg) -> raise (Uncertain msg)
+ in
+ let t'',ugraph2 =
+ match t' with
+ C.Sort (C.Type u) when not test_equality_only ->
+ let u' = CicUniv.fresh () in
+ let s = C.Sort (C.Type u') in
+ let ugraph2 =
+ CicUniv.add_ge (upper u u') (lower u u') ugraph1 in
+ s,ugraph2
+ | _ -> t',ugraph1
+ in
+ (* Unifying the types may have already instantiated n. Let's check *)
+ try
+ let (_, oldt) = CicMetaSubst.lookup_subst n subst in
+ let lifted_oldt = S.lift_meta l oldt in
+ fo_unif_subst_ordered
+ test_equality_only subst context metasenv t lifted_oldt ugraph2
+ with
+ CicMetaSubst.SubstNotFound _ ->
+ let (_, context, _) = CicUtil.lookup_meta n metasenv in
+ let subst = (n, (context, t'')) :: subst in
+ let metasenv =
+(* CicMetaSubst.apply_subst_metasenv [n,(context, t'')] metasenv *)
+ CicMetaSubst.apply_subst_metasenv subst metasenv
+ in
+ subst, metasenv,ugraph2
+(* (n,t'')::subst, metasenv *)
+ end
+*)
begin
- let subst,metasenv =
+ let subst,metasenv,ugraph1 =
let (_,_,meta_type) = CicUtil.lookup_meta n metasenv in
(try
- let tyt = type_of_aux' metasenv subst context t in
+ let tyt,ugraph1 =
+ type_of_aux' metasenv subst context t ugraph
+ in
fo_unif_subst
test_equality_only
- subst context metasenv tyt (S.lift_meta l meta_type)
+ subst context metasenv tyt (S.lift_meta l meta_type) ugraph1
with
UnificationFailure msg
| Uncertain msg ->
* the terms that we are unifying are no longer well
* typed in the current context (in the worst case
* we could even diverge) *)
- (subst, metasenv)) in
+ (subst, metasenv,ugraph)) in
let t',metasenv,subst =
try
CicMetaSubst.delift n subst context metasenv l t
raise (UnificationFailure msg)
| (CicMetaSubst.Uncertain msg) -> raise (Uncertain msg)
in
- let t'' =
+ let t'',ugraph2 =
match t' with
C.Sort (C.Type u) when not test_equality_only ->
let u' = CicUniv.fresh () in
let s = C.Sort (C.Type u') in
- ignore (CicUniv.add_ge (upper u u') (lower u u')) ;
- s
- | _ -> t'
+ let ugraph2 =
+ CicUniv.add_ge (upper u u') (lower u u') ugraph1
+ in
+ s,ugraph2
+ | _ -> t',ugraph1
in
(* Unifying the types may have already instantiated n. Let's check *)
try
let (_, oldt,_) = CicUtil.lookup_subst n subst in
let lifted_oldt = S.lift_meta l oldt in
fo_unif_subst_ordered
- test_equality_only subst context metasenv t lifted_oldt
+ test_equality_only subst context metasenv t lifted_oldt ugraph2
with
CicUtil.Subst_not_found _ ->
let (_, context, ty) = CicUtil.lookup_meta n metasenv in
let subst = (n, (context, t'',ty)) :: subst in
let metasenv =
List.filter (fun (m,_,_) -> not (n = m)) metasenv in
- subst, metasenv
+ subst, metasenv, ugraph2
end
+
| (C.Var (uri1,exp_named_subst1),C.Var (uri2,exp_named_subst2))
| (C.Const (uri1,exp_named_subst1),C.Const (uri2,exp_named_subst2)) ->
if UriManager.eq uri1 uri2 then
fo_unif_subst_exp_named_subst test_equality_only subst context metasenv
- exp_named_subst1 exp_named_subst2
+ exp_named_subst1 exp_named_subst2 ugraph
else
raise (UnificationFailure "3")
(* (sprintf
| C.MutInd (uri1,i1,exp_named_subst1),C.MutInd (uri2,i2,exp_named_subst2) ->
if UriManager.eq uri1 uri2 && i1 = i2 then
fo_unif_subst_exp_named_subst test_equality_only subst context metasenv
- exp_named_subst1 exp_named_subst2
+ exp_named_subst1 exp_named_subst2 ugraph
else
raise (UnificationFailure "4")
(* (sprintf
C.MutConstruct (uri2,i2,j2,exp_named_subst2) ->
if UriManager.eq uri1 uri2 && i1 = i2 && j1 = j2 then
fo_unif_subst_exp_named_subst test_equality_only subst context metasenv
- exp_named_subst1 exp_named_subst2
+ exp_named_subst1 exp_named_subst2 ugraph
else
raise (UnificationFailure "5")
(* (sprintf
(CicMetaSubst.ppterm subst t1) (CicMetaSubst.ppterm subst t2))) *)
| (C.Implicit _, _) | (_, C.Implicit _) -> assert false
| (C.Cast (te,ty), t2) -> fo_unif_subst test_equality_only
- subst context metasenv te t2
+ subst context metasenv te t2 ugraph
| (t1, C.Cast (te,ty)) -> fo_unif_subst test_equality_only
- subst context metasenv t1 te
+ subst context metasenv t1 te ugraph
| (C.Prod (n1,s1,t1), C.Prod (_,s2,t2)) ->
- (* TASSI: this is the only case in which we want == *)
- let subst',metasenv' = fo_unif_subst true
- subst context metasenv s1 s2 in
- fo_unif_subst test_equality_only
- subst' ((Some (n1,(C.Decl s1)))::context) metasenv' t1 t2
+ let subst',metasenv',ugraph1 =
+ fo_unif_subst true subst context metasenv s1 s2 ugraph
+ in
+ fo_unif_subst test_equality_only
+ subst' ((Some (n1,(C.Decl s1)))::context) metasenv' t1 t2 ugraph1
| (C.Lambda (n1,s1,t1), C.Lambda (_,s2,t2)) ->
- (* TASSI: ask someone a reason for not putting true here *)
- let subst',metasenv' = fo_unif_subst test_equality_only
- subst context metasenv s1 s2 in
- fo_unif_subst test_equality_only
- subst' ((Some (n1,(C.Decl s1)))::context) metasenv' t1 t2
+ let subst',metasenv',ugraph1 =
+ fo_unif_subst test_equality_only subst context metasenv s1 s2 ugraph
+ in
+ fo_unif_subst test_equality_only
+ subst' ((Some (n1,(C.Decl s1)))::context) metasenv' t1 t2 ugraph1
| (C.LetIn (_,s1,t1), t2)
| (t2, C.LetIn (_,s1,t1)) ->
fo_unif_subst
- test_equality_only subst context metasenv t2 (S.subst s1 t1)
+ test_equality_only subst context metasenv t2 (S.subst s1 t1) ugraph
| (C.Appl l1, C.Appl l2) ->
+(* WAS BEFORE ----------
+ let subst,metasenv,t1',t2',ugraph1 =
+ match l1,l2 with
+ C.Meta (i,_)::_, C.Meta (j,_)::_ when i = j ->
+ subst,metasenv,t1,t2,ugraph
+ (* In the first two cases when we reach the next begin ... end
+ section useless work is done since, by construction, the list
+ of arguments will be equal.
+ *)
+----------------- *)
(* andrea: this case should be probably rewritten in the
spirit of deref *)
let rec beta_reduce =
(subst,metasenv) l1 l2
with (Invalid_argument msg) -> raise (UnificationFailure msg))
| C.Meta (i,l)::args, _ ->
+<<<<<<< cicUnification.ml
+ let subst,metasenv,t2',ugraph1 =
+ beta_expand_many test_equality_only metasenv subst context t2 args
+ ugraph
+ in
+ subst,metasenv,t1,t2',ugraph1
+=======
(try
let (_,t,_) = CicUtil.lookup_subst i subst in
let lifted = S.lift_meta l t in
test_equality_only metasenv subst context t2 args in
fo_unif_subst test_equality_only subst context metasenv
(C.Meta (i,l)) beta_expanded)
+>>>>>>> 1.40
| _, C.Meta (i,l)::args ->
+<<<<<<< cicUnification.ml
+ let subst,metasenv,t1',ugraph1 =
+ beta_expand_many test_equality_only metasenv subst context t1 args
+ ugraph
+ in
+ subst,metasenv,t1',t2,ugraph1
+=======
(try
let (_,t,_) = CicUtil.lookup_subst i subst in
let lifted = S.lift_meta l t in
fo_unif_subst test_equality_only subst context metasenv
(C.Meta (i,l)) beta_expanded)
*)
+
| _,_ ->
+(* WAS BEFORE -----
+<<<<<<< cicUnification.ml
+ subst,metasenv,t1,t2,ugraph
+ in
+ begin
+ match t1',t2' with
+ C.Appl l1, C.Appl l2 ->
+ let lr1 = List.rev l1 in
+=======
+--------*)
let lr1 = List.rev l1 in
let lr2 = List.rev l2 in
- let rec fo_unif_l test_equality_only subst metasenv =
- function
- [],_
- | _,[] -> assert false
- | ([h1],[h2]) ->
- fo_unif_subst test_equality_only subst context metasenv h1 h2
- | ([h],l)
- | (l,[h]) ->
+ let rec
+ fo_unif_l test_equality_only subst metasenv (l1,l2) ugraph =
+ match (l1,l2) with
+ [],_
+ | _,[] -> assert false
+ | ([h1],[h2]) ->
+ fo_unif_subst
+ test_equality_only subst context metasenv h1 h2 ugraph
+ | ([h],l)
+ | (l,[h]) ->
fo_unif_subst test_equality_only subst context metasenv
- h (C.Appl (List.rev l))
- | ((h1::l1),(h2::l2)) ->
- let subst', metasenv' =
- fo_unif_subst test_equality_only subst context metasenv h1 h2
+ h (C.Appl (List.rev l)) ugraph
+ | ((h1::l1),(h2::l2)) ->
+ let subst', metasenv',ugraph1 =
+ fo_unif_subst
+ test_equality_only subst context metasenv h1 h2 ugraph
in
- fo_unif_l test_equality_only subst' metasenv' (l1,l2)
+ fo_unif_l
+ test_equality_only subst' metasenv' (l1,l2) ugraph1
in
- fo_unif_l test_equality_only subst metasenv (lr1, lr2) )
+ fo_unif_l
+ test_equality_only subst metasenv (lr1, lr2) ) ugraph(*1*)
| (C.MutCase (_,_,outt1,t1',pl1), C.MutCase (_,_,outt2,t2',pl2))->
- let subst', metasenv' =
- fo_unif_subst test_equality_only subst context metasenv outt1 outt2 in
- let subst'',metasenv'' =
- fo_unif_subst test_equality_only subst' context metasenv' t1' t2' in
+ let subst', metasenv',ugraph1 =
+ fo_unif_subst test_equality_only subst context metasenv outt1 outt2
+ ugraph in
+ let subst'',metasenv'',ugraph2 =
+ fo_unif_subst test_equality_only subst' context metasenv' t1' t2'
+ ugraph1 in
(try
List.fold_left2
- (function (subst,metasenv) ->
- fo_unif_subst test_equality_only subst context metasenv
- ) (subst'',metasenv'') pl1 pl2
+ (fun (subst,metasenv,ugraph) t1 t2 ->
+ fo_unif_subst
+ test_equality_only subst context metasenv t1 t2 ugraph
+ ) (subst'',metasenv'',ugraph2) pl1 pl2
with
Invalid_argument _ ->
raise (UnificationFailure "6"))
"Error trying to unify %s with %s: the number of branches is not the same." (CicMetaSubst.ppterm subst t1) (CicMetaSubst.ppterm subst t2)))) *)
| (C.Rel _, _) | (_, C.Rel _) ->
if t1 = t2 then
- subst, metasenv
+ subst, metasenv,ugraph
else
raise (UnificationFailure "6")
(* (sprintf
| (C.MutConstruct _, _) | (_, C.MutConstruct _)
| (C.Fix _, _) | (_, C.Fix _)
| (C.CoFix _, _) | (_, C.CoFix _) ->
- if t1 = t2 || R.are_convertible ~subst ~metasenv context t1 t2 then
- subst, metasenv
- else
- raise (UnificationFailure "7")
- (* (sprintf
- "Can't unify %s with %s because they are not convertible"
- (CicMetaSubst.ppterm subst t1) (CicMetaSubst.ppterm subst t2))) *)
+ if t1 = t2 then
+ subst, metasenv, ugraph
+ else
+ let b,ugraph1 =
+ R.are_convertible ~subst ~metasenv context t1 t2 ugraph
+ in
+ if b then
+ subst, metasenv, ugraph1
+ else
+ raise (UnificationFailure "7")
+ (* (sprintf
+ "Can't unify %s with %s because they are not convertible"
+ (CicMetaSubst.ppterm subst t1)
+ (CicMetaSubst.ppterm subst t2))) *)
| (_,_) ->
- if R.are_convertible ~subst ~metasenv context t1 t2 then
- subst, metasenv
- else
- raise (UnificationFailure "8")
- (* (sprintf
- "Can't unify %s with %s because they are not convertible"
- (CicMetaSubst.ppterm subst t1) (CicMetaSubst.ppterm subst t2))) *)
+ let b,ugraph1 =
+ R.are_convertible ~subst ~metasenv context t1 t2 ugraph
+ in
+ if b then
+ subst, metasenv, ugraph1
+ else
+ raise (UnificationFailure "8")
+ (* (sprintf
+ "Can't unify %s with %s because they are not convertible"
+ (CicMetaSubst.ppterm subst t1)
+ (CicMetaSubst.ppterm subst t2))) *)
and fo_unif_subst_exp_named_subst test_equality_only subst context metasenv
- exp_named_subst1 exp_named_subst2
+ exp_named_subst1 exp_named_subst2 ugraph
=
try
List.fold_left2
- (fun (subst,metasenv) (uri1,t1) (uri2,t2) ->
+ (fun (subst,metasenv,ugraph) (uri1,t1) (uri2,t2) ->
assert (uri1=uri2) ;
- fo_unif_subst test_equality_only subst context metasenv t1 t2
- ) (subst,metasenv) exp_named_subst1 exp_named_subst2
+ fo_unif_subst test_equality_only subst context metasenv t1 t2 ugraph
+ ) (subst,metasenv,ugraph) exp_named_subst1 exp_named_subst2
with
Invalid_argument _ ->
let print_ens ens =
(* a new substitution which is already unwinded and ready to be applied and *)
(* a new metasenv in which some hypothesis in the contexts of the *)
(* metavariables may have been restricted. *)
-let fo_unif metasenv context t1 t2 =
- fo_unif_subst false [] context metasenv t1 t2 ;;
+let fo_unif metasenv context t1 t2 ugraph =
+ fo_unif_subst false [] context metasenv t1 t2 ugraph ;;
-let fo_unif_subst subst context metasenv t1 t2 =
+let fo_unif_subst subst context metasenv t1 t2 ugraph =
let enrich_msg msg = (* "bella roba" *)
sprintf "Unification error unifying %s of type %s with %s of type %s in context\n%s\nand metasenv\n%s\nand substitution\n%s\nbecause %s"
(CicMetaSubst.ppterm subst t1)
(try
- CicPp.ppterm (type_of_aux' metasenv subst context t1)
+ let ty_t1,_ = type_of_aux' metasenv subst context t1 ugraph in
+ CicPp.ppterm ty_t1
with _ -> "MALFORMED")
(CicMetaSubst.ppterm subst t2)
(try
- CicPp.ppterm (type_of_aux' metasenv subst context t2)
+ let ty_t2,_ = type_of_aux' metasenv subst context t2 ugraph in
+ CicPp.ppterm ty_t2
with _ -> "MALFORMED")
(CicMetaSubst.ppcontext subst context)
(CicMetaSubst.ppmetasenv metasenv subst)
(CicMetaSubst.ppsubst subst) msg
in
try
- fo_unif_subst false subst context metasenv t1 t2
+ fo_unif_subst false subst context metasenv t1 t2 ugraph
with
| AssertFailure msg -> raise (AssertFailure (enrich_msg msg))
| UnificationFailure msg -> raise (UnificationFailure (enrich_msg msg))
(* The returned substitution can be directly *)
(* withouth first unwinding it. *)
val fo_unif :
- Cic.metasenv -> Cic.context -> Cic.term -> Cic.term ->
- Cic.substitution * Cic.metasenv
+ Cic.metasenv -> Cic.context ->
+ Cic.term -> Cic.term -> CicUniv.universe_graph ->
+ Cic.substitution * Cic.metasenv * CicUniv.universe_graph
(* fo_unif_subst metasenv subst context t1 t2 *)
(* unifies [t1] and [t2] in a context [context] *)
(*CSC: fare un tipo unione Unwinded o ToUnwind e fare gestire la
cosa all'apply_subst!!!*)
val fo_unif_subst :
- Cic.substitution ->
- Cic.context -> Cic.metasenv -> Cic.term -> Cic.term ->
- Cic.substitution * Cic.metasenv
+ Cic.substitution -> Cic.context -> Cic.metasenv ->
+ Cic.term -> Cic.term -> CicUniv.universe_graph ->
+ Cic.substitution * Cic.metasenv * CicUniv.universe_graph
C.Anonymous ->
(*CSC: great space for improvements here *)
(try
- (match CicTypeChecker.type_of_aux' ~subst metasenv context typ with
+ let ty,_ =
+ CicTypeChecker.type_of_aux' ~subst metasenv context typ
+ CicUniv.empty_ugraph in
+ (match ty with
C.Sort C.Prop
| C.Sort C.CProp -> "H"
| C.Sort C.Set -> "x"
http_getter_types.cmo http_getter_common.cmi
http_getter_common.cmx: http_getter_env.cmx http_getter_misc.cmx \
http_getter_types.cmx http_getter_common.cmi
-http_getter_map.cmo: http_getter_map.cmi
-http_getter_map.cmx: http_getter_map.cmi
+http_getter_map.cmo: http_getter_types.cmo http_getter_map.cmi
+http_getter_map.cmx: http_getter_types.cmx http_getter_map.cmi
http_getter_cache.cmo: http_getter_common.cmi http_getter_env.cmi \
http_getter_logger.cmi http_getter_misc.cmi http_getter_types.cmo \
http_getter_cache.cmi
| uri when is_nuprl_uri uri -> Lazy.force nuprl_map
| uri when is_rdf_uri uri -> Lazy.force rdf_map
| uri when is_xsl_uri uri -> Lazy.force xsl_map
- | uri -> raise (Unresolvable_URI uri)
+ | uri -> prerr_endline "BBBBB";raise (Unresolvable_URI uri)
let update_from_server logger server_url = (* use global maps *)
Http_getter_logger.log ("Updating information from " ^ server_url);
res := Exception (Unresolvable_URI uri)
| Pxp_types.E_start_tag ("not_found",[],_,_) ->
res := Exception (Key_not_found uri)
- | Pxp_types.E_start_tag _ -> res := Exception UnexpectedGetterOutput
+ | Pxp_types.E_start_tag (x,_,_,_) ->
+ prerr_endline ("UnexpectedGetterOutput: "^x);
+ res := Exception UnexpectedGetterOutput
| _ -> ());
match !res with
- | Unknown -> raise UnexpectedGetterOutput
- | Exception e -> raise e
+ | Unknown ->
+ prerr_endline ("UnexpectedGetterOutput: Unknown!");
+ raise UnexpectedGetterOutput
+ | Exception e ->
+ prerr_endline ("Exception : ??????");
+ raise e
| Resolved url -> url
let register_remote ~uri ~url =
if remote () then
resolve_remote uri
else
- (map_of_uri uri)#resolve uri
-
+
+ (**** FIXME ******)
+ if is_cic_uri uri && Pcre.pmatch ~pat:"\\.univ$" uri then
+ begin
+ prerr_endline "!!! E' in ~tassi !!!";
+ "file:///home/tassi/mylib" ^
+ (String.sub uri 4 ((String.length uri) - 4)) ^ ".xml.gz"
+ end
+ else
+ (map_of_uri uri)#resolve uri
+
let register ~uri ~url =
if remote () then
register_remote ~uri ~url
if remote () then
getxml_remote ~format ~patch_dtd uri
else begin
+Http_getter_logger.log ("GETXML: " ^ uri);
let url = resolve uri in
+Http_getter_logger.log ("RESOLVED_URI: " ^ url) ;
let (fname, outchan) = temp_file_of_uri uri in
Http_getter_cache.respond_xml ~via_http:false ~enc:format ~patch:patch_dtd
~uri ~url outchan;
if remote () then
getxslt_remote ~patch_dtd uri
else begin
+
let url = resolve uri in
let (fname, outchan) = temp_file_of_uri uri in
Http_getter_cache.respond_xsl ~via_http:false ~url ~patch:patch_dtd outchan;
let sorted_keys =
List.sort compare (Hashtbl.fold (fun key _ keys -> key::keys) tbl [])
in
- List.iter (fun k -> f k (Hashtbl.find tbl k)) sorted_keys
+ List.iter (fun k -> f k (Hashtbl.find tbl k)) sorted_keys
let cp src dst =
- let (ic, oc) = (open_in src, open_out dst) in
- let buf = String.create bufsiz in
- (try
- while true do
- let bytes = input ic buf 0 bufsiz in
- if bytes = 0 then raise End_of_file else output oc buf 0 bytes
- done
- with End_of_file -> ());
- close_in ic; close_out oc
+ try
+ let ic = open_in src in
+ try
+ let oc = open_out dst in
+ let buf = String.create bufsiz in
+ (try
+ while true do
+ let bytes = input ic buf 0 bufsiz in
+ if bytes = 0 then raise End_of_file else output oc buf 0 bytes
+ done
+ with
+ End_of_file -> ()
+ );
+ close_in ic; close_out oc
+ with
+ Sys_error s ->
+ Http_getter_logger.log s;
+ close_in ic
+ | e ->
+ Http_getter_logger.log (Printexc.to_string e);
+ close_in ic;
+ raise e
+ with
+ Sys_error s ->
+ Http_getter_logger.log s
+ | e ->
+ Http_getter_logger.log (Printexc.to_string e);
+ raise e
let wget ?output url =
Http_getter_logger.log
if bytes = 0 then raise End_of_file else Pervasives.output oc buf 0 bytes
done
with End_of_file -> ());
- close_out oc
+ close_out oc;
+ Gzip.close_in ic
with
e -> close_in zic ; raise e
end ;
- close_in zic ;
if not keep then Sys.remove fname
;;
| Cic.Prod (_, _, t) -> degree_aux t
| _ -> 2
in
- let u = TC.type_of_aux' metasenv context t in
+ let u,_ = TC.type_of_aux' metasenv context t CicUniv.empty_ugraph in
degree_aux (Red.whd context u)
in
let entry_eq (s1, b1, v1) (s2, b2, v2) =
metadataConstraints.cmi: metadataTypes.cmo
metadataExtractor.cmo: metadataTypes.cmo metadataExtractor.cmi
metadataExtractor.cmx: metadataTypes.cmx metadataExtractor.cmi
-metadataPp.cmo: metadataPp.cmi
-metadataPp.cmx: metadataPp.cmi
+metadataPp.cmo: metadataTypes.cmo metadataPp.cmi
+metadataPp.cmx: metadataTypes.cmx metadataPp.cmi
metadataDb.cmo: metadataExtractor.cmi metadataPp.cmi metadataTypes.cmo \
metadataDb.cmi
metadataDb.cmx: metadataExtractor.cmx metadataPp.cmx metadataTypes.cmx \
let module U = UriManager in
let module P = PrimitiveTactics in
let module T = Tacticals in
- let _,metasenv,_,_ = proof in
- let _,context,_ = CicUtil.lookup_meta goal metasenv in
- let termty = (CicTypeChecker.type_of_aux' metasenv context term) in
- ProofEngineTypes.apply_tactic
+ let _,metasenv,_,_ = proof in
+ let _,context,_ = CicUtil.lookup_meta goal metasenv in
+ let termty,_ = (* TASSI: FIXME *)
+ CicTypeChecker.type_of_aux' metasenv context term CicUniv.empty_ugraph in
+ ProofEngineTypes.apply_tactic
(match termty with
(C.Appl [(C.MutInd (equri, 0, [])) ; tty ; t1 ; t2])
when (U.eq equri Logic.eq_URI) -> (
let module U = UriManager in
let module P = PrimitiveTactics in
let module T = Tacticals in
- let _,metasenv,_,_ = proof in
- let _,context,_ = CicUtil.lookup_meta goal metasenv in
- let termty = (CicTypeChecker.type_of_aux' metasenv context term) in
- match termty with (* an equality *)
- (C.Appl [(C.MutInd (equri, 0, [])) ; tty ; t1 ; t2])
+ let _,metasenv,_,_ = proof in
+ let _,context,_ = CicUtil.lookup_meta goal metasenv in
+ let termty,_ = (* TASSI: FIXME *)
+ CicTypeChecker.type_of_aux' metasenv context term CicUniv.empty_ugraph in
+ match termty with (* an equality *)
+ (C.Appl [(C.MutInd (equri, 0, [])) ; tty ; t1 ; t2])
when (U.eq equri Logic.eq_URI) -> (
match tty with (* some inductive type *)
(C.MutInd (turi,typeno,exp_named_subst))
(List.nth applist1 (i-1)),(List.nth applist2 (i-1)),consno2
| _ -> raise (ProofEngineTypes.Fail "Injection: qui non dovrei capitarci mai")
in
- let tty' = (CicTypeChecker.type_of_aux' metasenv context t1') in
+ let tty',_ =
+ CicTypeChecker.type_of_aux' metasenv context t1'
+ CicUniv.empty_ugraph in
prerr_endline ("XXXX tty' " ^ CicPp.ppterm tty') ;
prerr_endline ("XXXX t1' " ^ CicPp.ppterm t1') ;
prerr_endline ("XXXX t2' " ^ CicPp.ppterm t2') ;
prerr_endline ("XXXX consno " ^ string_of_int consno) ;
let pattern =
- match (CicEnvironment.get_obj turi) with
+ match fst(CicEnvironment.get_obj turi
+ CicUniv.empty_ugraph ) with
C.InductiveDefinition (ind_type_list,_,nr_ind_params_dx) ->
let _,_,_,constructor_list = (List.nth ind_type_list typeno) in
let i_constr_id,_ = List.nth constructor_list (consno - 1) in
let module U = UriManager in
let module P = PrimitiveTactics in
let module T = Tacticals in
- let _,metasenv,_,_ = proof in
- let _,context,_ = CicUtil.lookup_meta goal metasenv in
- let termty = (CicTypeChecker.type_of_aux' metasenv context term) in
+ let _,metasenv,_,_ = proof in
+ let _,context,_ = CicUtil.lookup_meta goal metasenv in
+ let termty,_ =
+ CicTypeChecker.type_of_aux' metasenv context term CicUniv.empty_ugraph in
match termty with
(C.Appl [(C.MutInd (equri, 0, [])) ; tty ; t1 ; t2])
when (U.eq equri Logic.eq_URI) -> (
let pattern =
(* a list of "True" except for the element in position consno2 which is "False" *)
- match (CicEnvironment.get_obj turi) with
+ match fst(CicEnvironment.get_obj turi
+ CicUniv.empty_ugraph) with
C.InductiveDefinition (ind_type_list,_,nr_ind_params) ->
prerr_endline ("XXXX nth " ^ (string_of_int (List.length ind_type_list)) ^ " " ^ (string_of_int typeno)) ;
let _,_,_,constructor_list = (List.nth ind_type_list typeno) in
)
~continuation:
(
-prerr_endline ("XXXX rewrite<-: " ^ CicPp.ppterm (CicTypeChecker.type_of_aux' metasenv' context' (C.Appl [(C.MutInd (equri,0,[])) ; tty ; t1 ; t2])));
+let u = CicUniv.empty_ugraph in
+prerr_endline ("XXXX rewrite<-: " ^ CicPp.ppterm (fst (CicTypeChecker.type_of_aux' metasenv' context' (C.Appl [(C.MutInd (equri,0,[])) ; tty ; t1 ; t2]) u)));
prerr_endline ("XXXX rewrite<-: " ^ CicPp.ppterm (C.Appl [(C.MutInd (equri,0,[])) ; tty ; t1 ; t2])) ;
prerr_endline ("XXXX equri: " ^ U.string_of_uri equri) ;
prerr_endline ("XXXX tty : " ^ CicPp.ppterm tty) ;
-prerr_endline ("XXXX tt1': " ^ CicPp.ppterm (CicTypeChecker.type_of_aux' metasenv' context' t1)) ;
-prerr_endline ("XXXX tt2': " ^ CicPp.ppterm (CicTypeChecker.type_of_aux' metasenv' context' t2)) ;
-if (CicTypeChecker.type_of_aux' metasenv' context' t1) <> tty then prerr_endline ("XXXX tt1': " ^ CicPp.ppterm (CicTypeChecker.type_of_aux' metasenv' context' t1)) ;
-if (CicTypeChecker.type_of_aux' metasenv' context' t2) <> tty then prerr_endline ("XXXX tt2': " ^ CicPp.ppterm (CicTypeChecker.type_of_aux' metasenv' context' t2)) ;
-if (CicTypeChecker.type_of_aux' metasenv' context' t1) <> (CicTypeChecker.type_of_aux' metasenv' context' t2)
- then prerr_endline ("XXXX tt1': " ^ CicPp.ppterm (CicTypeChecker.type_of_aux' metasenv' context' t1)) ; prerr_endline ("XXXX tt2': " ^ CicPp.ppterm (CicTypeChecker.type_of_aux' metasenv' context' t2)) ;
-prerr_endline ("XXXX rewrite<- " ^ CicPp.ppterm term ^ " : " ^ CicPp.ppterm (CicTypeChecker.type_of_aux' metasenv' context' term));
+prerr_endline ("XXXX tt1': " ^ CicPp.ppterm (fst(CicTypeChecker.type_of_aux' metasenv' context' t1 u))) ;
+prerr_endline ("XXXX tt2': " ^ CicPp.ppterm (fst(CicTypeChecker.type_of_aux' metasenv' context' t2 u))) ;
+if (fst (CicTypeChecker.type_of_aux' metasenv' context' t1 u)) <> tty then
+prerr_endline ("XXXX tt1': " ^ CicPp.ppterm (fst (CicTypeChecker.type_of_aux' metasenv' context' t1 u))) ;
+if (fst(CicTypeChecker.type_of_aux' metasenv' context' t2 u)) <> tty then
+prerr_endline ("XXXX tt2': " ^ CicPp.ppterm (fst(CicTypeChecker.type_of_aux' metasenv' context' t2 u))) ;
+if (fst(CicTypeChecker.type_of_aux' metasenv' context' t1 u)) <>
+(fst (CicTypeChecker.type_of_aux' metasenv' context' t2 u))
+ then prerr_endline ("XXXX tt1': " ^ CicPp.ppterm (fst(CicTypeChecker.type_of_aux' metasenv' context' t1 u))) ; prerr_endline ("XXXX tt2': " ^ CicPp.ppterm (fst(CicTypeChecker.type_of_aux' metasenv' context' t2 u))) ;
+prerr_endline ("XXXX rewrite<- " ^ CicPp.ppterm term ^ " : " ^ CicPp.ppterm (fst(CicTypeChecker.type_of_aux' metasenv' context' term u)));
T.then_
~start:(EqualityTactics.rewrite_back_simpl_tac ~term)
~continuation:(IntroductionTactics.constructor_tac ~n:1)
let pattern =
(* a list of "True" except for the element in position consno2' which is "False" *)
- match (CicEnvironment.get_obj turi) with
+ match fst(CicEnvironment.get_obj turi
+ CicUniv.empty_ugraph) with
C.InductiveDefinition (ind_type_list,_,nr_ind_params) ->
prerr_endline ("XXXX nth " ^ (string_of_int (List.length ind_type_list)) ^ " " ^ (string_of_int typeno)) ;
let _,_,_,constructor_list = (List.nth ind_type_list typeno) in
let _,metasenv,_,_ = proof in
let _,context,ty = CicUtil.lookup_meta goal metasenv in
let old_context_len = List.length context in
- let termty = CicTypeChecker.type_of_aux' metasenv context term in
-
- let rec make_list termty =
+ let termty,_ =
+ CicTypeChecker.type_of_aux' metasenv context term CicUniv.empty_ugraph in
+ let rec make_list termty =
(* N.B.: altamente inefficente? *)
let rec search_inductive_types urilist termty =
(* search in term the Inductive Types and return a list of uris as triples like this: (uri,typeno,exp_named_subst) *)
let _,metasenv,_,_ = proof in
let _,context,_ = CicUtil.lookup_meta goal metasenv in
let old_context_len = List.length context in
- let termty = CicTypeChecker.type_of_aux' metasenv context term' in
+ let termty,_ =
+ CicTypeChecker.type_of_aux' metasenv context term'
+ CicUniv.empty_ugraph in
warn ("elim_clear termty= " ^ CicPp.ppterm termty);
match termty with
C.MutInd (uri,typeno,exp_named_subst)
*)
let rewrite_tac ~term:equality =
- let rewrite_tac ~term:equality (proof,goal) =
- let module C = Cic in
- let module U = UriManager in
- let curi,metasenv,pbo,pty = proof in
- let metano,context,gty = CicUtil.lookup_meta goal metasenv in
+ let rewrite_tac ~term:equality (proof,goal) =
+ let module C = Cic in
+ let module U = UriManager in
+ let curi,metasenv,pbo,pty = proof in
+ let metano,context,gty = CicUtil.lookup_meta goal metasenv in
+ let ty_eq,_ =
+ CicTypeChecker.type_of_aux' metasenv context equality
+ CicUniv.empty_ugraph in
let eq_ind_r,ty,t1,t2 =
- match CicTypeChecker.type_of_aux' metasenv context equality with
+ match ty_eq with
C.Appl [C.MutInd (uri,0,[]) ; ty ; t1 ; t2]
when U.eq uri HelmLibraryObjects.Logic.eq_URI ->
let eq_ind_r =
[eq_ind_r ; ty ; t2 ; pred ; C.Meta (fresh_meta,irl) ; t1 ;equality])) ((curi,metasenv',pbo,pty),goal)
in
assert (List.length goals = 0) ;
- (proof',[fresh_meta])
- in
- ProofEngineTypes.mk_tactic (rewrite_tac ~term:equality)
+ (proof',[fresh_meta])
+ in
+ ProofEngineTypes.mk_tactic (rewrite_tac ~term:equality)
;;
(ReductionTactics.simpl_tac ~also_in_hypotheses:false ~terms:None))
status
in
- ProofEngineTypes.mk_tactic (rewrite_simpl_tac ~term)
+ ProofEngineTypes.mk_tactic (rewrite_simpl_tac ~term)
;;
let module U = UriManager in
let curi,metasenv,pbo,pty = proof in
let metano,context,gty = CicUtil.lookup_meta goal metasenv in
+ let ty_eq,_ =
+ CicTypeChecker.type_of_aux' metasenv context equality
+ CicUniv.empty_ugraph in
let eq_ind_r,ty,t1,t2 =
- match CicTypeChecker.type_of_aux' metasenv context equality with
+ match ty_eq with
C.Appl [C.MutInd (uri,0,[]) ; ty ; t1 ; t2]
when U.eq uri HelmLibraryObjects.Logic.eq_URI ->
let eq_ind_r =
let module U = UriManager in
let module P = PrimitiveTactics in
let module T = Tacticals in
- let _,metasenv,_,_ = proof in
- let _,context,_ = CicUtil.lookup_meta goal metasenv in
- let wty = CicTypeChecker.type_of_aux' metasenv context what in
- try
- if (wty = (CicTypeChecker.type_of_aux' metasenv context with_what))
- then
+ let _,metasenv,_,_ = proof in
+ let _,context,_ = CicUtil.lookup_meta goal metasenv in
+ let wty,u = (* TASSI: FIXME *)
+ CicTypeChecker.type_of_aux' metasenv context what CicUniv.empty_ugraph in
+ let wwty,_ = CicTypeChecker.type_of_aux' metasenv context with_what u in
+ try
+ if (wty = wwty) then
ProofEngineTypes.apply_tactic
- (T.thens
- ~start:(
- P.cut_tac
- (C.Appl [
- (C.MutInd (HelmLibraryObjects.Logic.eq_URI, 0, [])) ;
- wty ;
- what ;
- with_what]))
- ~continuations:[
- T.then_
- ~start:(rewrite_simpl_tac ~term:(C.Rel 1))
- ~continuation:(
- ProofEngineStructuralRules.clear
- ~hyp:(List.hd context)) ;
- T.id_tac])
+ (T.thens
+ ~start:(
+ P.cut_tac
+ (C.Appl [
+ (C.MutInd (HelmLibraryObjects.Logic.eq_URI, 0, [])) ;
+ wty ;
+ what ;
+ with_what]))
+ ~continuations:[
+
+ T.then_ ~start:(rewrite_simpl_tac ~term:(C.Rel 1))
+ ~continuation:(
+ ProofEngineStructuralRules.clear
+ ~hyp:(List.hd context)) ;
+ T.id_tac])
status
- else raise (ProofEngineTypes.Fail "Replace: terms not replaceable")
- with (Failure "hd") ->
- raise (ProofEngineTypes.Fail "Replace: empty context")
+ else raise (ProofEngineTypes.Fail "Replace: terms not replaceable")
+ with (Failure "hd") ->
+ raise (ProofEngineTypes.Fail "Replace: empty context")
in
- ProofEngineTypes.mk_tactic (replace_tac ~what ~with_what)
+ ProofEngineTypes.mk_tactic (replace_tac ~what ~with_what)
;;
let _,metasenv,_,_ = proof in
let (_, ey1, ty1) = CicUtil.lookup_meta goal1 metasenv in
let (_, ey2, ty2) = CicUtil.lookup_meta goal2 metasenv in
- let ty_sort1 = CicTypeChecker.type_of_aux' metasenv ey1 ty1 in
- let ty_sort2 = CicTypeChecker.type_of_aux' metasenv ey2 ty2 in
+ let ty_sort1,_ =
+ CicTypeChecker.type_of_aux' metasenv ey1 ty1 CicUniv.empty_ugraph
+ in
+ let ty_sort2,_ =
+ CicTypeChecker.type_of_aux' metasenv ey2 ty2 CicUniv.empty_ugraph
+ in
let prop1 =
- if CicReduction.are_convertible ey1 (Cic.Sort Cic.Prop) ty_sort1 then 0
- else 1
+ let b,_ =
+ CicReduction.are_convertible
+ ey1 (Cic.Sort Cic.Prop) ty_sort1 CicUniv.empty_ugraph
+ in
+ if b then 0
+ else 1
in
let prop2 =
- if CicReduction.are_convertible ey2 (Cic.Sort Cic.Prop) ty_sort2 then 0
- else 1
+ let b,_ =
+ CicReduction.are_convertible
+ ey2 (Cic.Sort Cic.Prop) ty_sort2 CicUniv.empty_ugraph
+ in
+ if b then 0
+ else 1
in
prop1 - prop2
let module C = Cic in
let module U = UriManager in
let module P = PrimitiveTactics in
- let _,metasenv,_,_ = proof in
- let _,context,ty = CicUtil.lookup_meta goal metasenv in
- if ((CicTypeChecker.type_of_aux' metasenv context term) = (C.Sort C.Prop)) (* ma questo controllo serve?? *)
- then ProofEngineTypes.apply_tactic
- (P.apply_tac
- ~term:(
- C.Appl [(C.Const (HelmLibraryObjects.Logic.absurd_URI , [] )) ;
- term ; ty])
- )
- status
- else raise (ProofEngineTypes.Fail "Absurd: Not a Proposition")
+ let _,metasenv,_,_ = proof in
+ let _,context,ty = CicUtil.lookup_meta goal metasenv in
+ let ty_term,_ =
+ CicTypeChecker.type_of_aux' metasenv context term CicUniv.empty_ugraph in
+ if (ty_term = (C.Sort C.Prop)) (* ma questo controllo serve?? *)
+ then ProofEngineTypes.apply_tactic
+ (P.apply_tac
+ ~term:(
+ C.Appl [(C.Const (HelmLibraryObjects.Logic.absurd_URI , [] )) ;
+ term ; ty])
+ )
+ status
+ else raise (ProofEngineTypes.Fail "Absurd: Not a Proposition")
in
- ProofEngineTypes.mk_tactic (absurd_tac ~term)
+ ProofEngineTypes.mk_tactic (absurd_tac ~term)
;;
let contradiction_tac =
and aux_exp_named_subst n =
List.map (function uri,t -> uri,aux n t)
in
- let argty =
- T.type_of_aux' metasenv context arg
+ let argty,_ =
+ T.type_of_aux' metasenv context arg CicUniv.empty_ugraph (* TASSI: FIXME *)
in
let fresh_name =
FreshNamesGenerator.mk_fresh_name ~subst:[]
=
let module C = Cic in
let params =
- match CicEnvironment.get_obj uri with
- C.Constant (_,_,_,params)
- | C.CurrentProof (_,_,_,_,params)
- | C.Variable (_,_,_,params)
- | C.InductiveDefinition (_,params,_) -> params
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
+ C.Constant (_,_,_,params)
+ | C.CurrentProof (_,_,_,_,params)
+ | C.Variable (_,_,_,params)
+ | C.InductiveDefinition (_,params,_) -> params
in
let exp_named_subst_diff,new_fresh_meta,newmetasenvfragment,exp_named_subst'=
let next_fresh_meta = ref newmeta in
[],[] -> []
| uri::tl,[] ->
let ty =
- match CicEnvironment.get_obj uri with
- C.Variable (_,_,ty,_) ->
- CicSubstitution.subst_vars !exp_named_subst_diff ty
- | _ -> raise (WrongUriToVariable (UriManager.string_of_uri uri))
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
+ C.Variable (_,_,ty,_) ->
+ CicSubstitution.subst_vars !exp_named_subst_diff ty
+ | _ -> raise (WrongUriToVariable (UriManager.string_of_uri uri))
in
(* CSC: patch to generate ?1 : ?2 : Type in place of ?1 : Type to simulate ?1 :< Type
(match ty with
| _ -> [],newmeta,[],term
in
let metasenv' = metasenv@newmetasenvfragment in
+ let termty,_ = (* TASSI:FIXME *)
+ CicTypeChecker.type_of_aux' metasenv' context term CicUniv.empty_ugraph in
let termty =
- CicSubstitution.subst_vars exp_named_subst_diff
- (CicTypeChecker.type_of_aux' metasenv' context term)
+ CicSubstitution.subst_vars exp_named_subst_diff termty
in
(* newmeta is the lowest index of the new metas introduced *)
let (consthead,newmetas,arguments,_) =
new_metasenv_for_apply newmeta' proof context termty
in
let newmetasenv = metasenv'@newmetas in
- let subst,newmetasenv' =
- CicUnification.fo_unif newmetasenv context consthead ty
+ let subst,newmetasenv',_ = (* TASSI:FIXME *)
+ CicUnification.fo_unif newmetasenv context consthead ty
+ CicUniv.empty_ugraph
in
let in_subst_domain i = List.exists (function (j,_) -> i=j) subst in
let apply_subst = CicMetaSubst.apply_subst subst in
let intros_tac ?(mk_fresh_name_callback = FreshNamesGenerator.mk_fresh_name ~subst:[]) ()=
let intros_tac
- ?(mk_fresh_name_callback = FreshNamesGenerator.mk_fresh_name ~subst:[]) ()
+ ?(mk_fresh_name_callback = (FreshNamesGenerator.mk_fresh_name ~subst:[])) ()
(proof, goal)
=
let module C = Cic in
let module C = Cic in
let curi,metasenv,pbo,pty = proof in
let metano,context,ty = CicUtil.lookup_meta goal metasenv in
- let _ = CicTypeChecker.type_of_aux' metasenv context term in
+ let _,_ = (* TASSI: FIXME *)
+ CicTypeChecker.type_of_aux' metasenv context term CicUniv.empty_ugraph in
let newmeta = new_meta_of_proof ~proof in
let fresh_name =
mk_fresh_name_callback metasenv context (Cic.Name "Hletin") ~typ:term in
let metano,context,ty = CicUtil.lookup_meta goal metasenv in
let module T = CicTypeChecker in
let module R = CicReduction in
- if R.are_convertible context (T.type_of_aux' metasenv context term) ty then
+ let ty_term,u = T.type_of_aux' metasenv context term CicUniv.empty_ugraph in
+ let b,_ = R.are_convertible context ty_term ty u in (* TASSI: FIXME *)
+ if b then
begin
let (newproof, metasenv') =
subst_meta_in_proof proof metano term [] in
let module C = Cic in
let (curi,metasenv,proofbo,proofty) = proof in
let metano,context,ty = CicUtil.lookup_meta goal metasenv in
- let termty = T.type_of_aux' metasenv context term in
+ let termty,_ = T.type_of_aux' metasenv context term CicUniv.empty_ugraph in
+ (* TASSI: FIXME *)
let uri,exp_named_subst,typeno,args =
match termty with
C.MutInd (uri,typeno,exp_named_subst) -> (uri,exp_named_subst,typeno,[])
let eliminator_uri =
let buri = U.buri_of_uri uri in
let name =
- match CicEnvironment.get_obj uri with
+ let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.InductiveDefinition (tys,_,_) ->
let (name,_,_,_) = List.nth tys typeno in
name
| _ -> assert false
in
+ let ty_ty,_ = T.type_of_aux' metasenv context ty CicUniv.empty_ugraph in
+ (* TASSI: FIXME *)
let ext =
- match T.type_of_aux' metasenv context ty with
+ match ty_ty with
C.Sort C.Prop -> "_ind"
| C.Sort C.Set -> "_rec"
| C.Sort C.CProp -> "_rec"
- | C.Sort (C.Type _)-> "_rect" (* TASSI *)
+ | C.Sort (C.Type _)-> "_rect"
| _ -> assert false
in
U.uri_of_string (buri ^ "/" ^ name ^ ext ^ ".con")
in
let eliminator_ref = C.Const (eliminator_uri,exp_named_subst) in
- let ety = T.type_of_aux' metasenv context eliminator_ref in
+ let ety,_ =
+ T.type_of_aux' metasenv context eliminator_ref CicUniv.empty_ugraph in
let rec find_args_no =
function
C.Prod (_,_,t) -> 1 + find_args_no t
in
let metasenv', term_to_refine' =
CicMkImplicit.expand_implicits metasenv [] context term_to_refine in
- let refined_term,_,metasenv'' =
- CicRefine.type_of_aux' metasenv' context term_to_refine'
+ let refined_term,_,metasenv'',_ = (* TASSI: FIXME *)
+ CicRefine.type_of_aux' metasenv' context term_to_refine'
+ CicUniv.empty_ugraph
in
let new_goals =
ProofEngineHelpers.compare_metasenvs
(*CSC: So it is _NOT_ possible to use those binders in the [with_what] term. *)
(*CSC: Is that evident? Is that right? Or should it be changed? *)
let change_tac ~what ~with_what =
- let change_tac ~what ~with_what (proof, goal) =
- let curi,metasenv,pbo,pty = proof in
- let metano,context,ty = CicUtil.lookup_meta goal metasenv in
- (* are_convertible works only on well-typed terms *)
- ignore (CicTypeChecker.type_of_aux' metasenv context with_what) ;
- if CicReduction.are_convertible context what with_what then
- begin
- let replace =
- ProofEngineReduction.replace
- ~equality:(==) ~what:[what] ~with_what:[with_what]
- in
- let ty' = replace ty in
- let context' =
- List.map
- (function
- Some (name,Cic.Def (t,None))->Some (name,Cic.Def ((replace t),None))
- | Some (name,Cic.Decl t) -> Some (name,Cic.Decl (replace t))
- | None -> None
- | Some (_,Cic.Def (_,Some _)) -> assert false
- ) context
- in
- let metasenv' =
- List.map
- (function
- (n,_,_) when n = metano -> (metano,context',ty')
- | _ as t -> t
- ) metasenv
- in
- (curi,metasenv',pbo,pty), [metano]
- end
- else
- raise (ProofEngineTypes.Fail "Not convertible")
- in
- mk_tactic (change_tac ~what ~with_what)
+ let change_tac ~what ~with_what (proof, goal) =
+ let curi,metasenv,pbo,pty = proof in
+ let metano,context,ty = CicUtil.lookup_meta goal metasenv in
+ (* are_convertible works only on well-typed terms *)
+ let _,u =
+ CicTypeChecker.type_of_aux' metasenv context with_what
+ CicUniv.empty_ugraph
+ in (* TASSI: FIXME *)
+ let b,_ =
+ CicReduction.are_convertible context what with_what u
+ in
+ if b then
+ begin
+ let replace =
+ ProofEngineReduction.replace
+ ~equality:(==) ~what:[what] ~with_what:[with_what]
+ in
+ let ty' = replace ty in
+ let context' =
+ List.map
+ (function
+ Some (name,Cic.Def (t,None))->
+ Some (name,Cic.Def ((replace t),None))
+ | Some (name,Cic.Decl t) -> Some (name,Cic.Decl (replace t))
+ | None -> None
+ | Some (_,Cic.Def (_,Some _)) -> assert false
+ ) context
+ in
+ let metasenv' =
+ List.map
+ (function
+ (n,_,_) when n = metano -> (metano,context',ty')
+ | _ as t -> t
+ ) metasenv
+ in
+ (curi,metasenv',pbo,pty), [metano]
+ end
+ else
+ raise (ProofEngineTypes.Fail "Not convertible")
+ in
+ mk_tactic (change_tac ~what ~with_what)
+
let exp_named_subst' =
reduceaux_exp_named_subst context l exp_named_subst
in
- (match CicEnvironment.get_obj uri with
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.Constant _ -> raise ReferenceToConstant
| C.CurrentProof _ -> raise ReferenceToCurrentProof
| C.InductiveDefinition _ -> raise ReferenceToInductiveDefinition
let exp_named_subst' =
reduceaux_exp_named_subst context l exp_named_subst
in
- (match CicEnvironment.get_obj uri with
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.Constant (_,Some body,_,_) ->
(reduceaux context l
(CicSubstitution.subst_vars exp_named_subst' body))
C.MutConstruct (_,_,j,_) -> reduceaux context l (List.nth pl (j-1))
| C.Appl (C.MutConstruct (_,_,j,_) :: tl) ->
let (arity, r) =
- match CicEnvironment.get_obj mutind with
- C.InductiveDefinition (tl,_,r) ->
- let (_,_,arity,_) = List.nth tl i in
- (arity,r)
- | _ -> raise WrongUriToInductiveDefinition
+ let o,_ = CicEnvironment.get_obj mutind CicUniv.empty_ugraph in
+ match o with
+ C.InductiveDefinition (tl,_,r) ->
+ let (_,_,arity,_) = List.nth tl i in
+ (arity,r)
+ | _ -> raise WrongUriToInductiveDefinition
in
let ts =
let rec eat_first =
let exp_named_subst' =
reduceaux_exp_named_subst context l exp_named_subst
in
- (match CicEnvironment.get_obj uri with
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.Constant _ -> raise ReferenceToConstant
| C.CurrentProof _ -> raise ReferenceToCurrentProof
| C.InductiveDefinition _ -> raise ReferenceToInductiveDefinition
let exp_named_subst' =
reduceaux_exp_named_subst context l exp_named_subst
in
- (match CicEnvironment.get_obj uri with
+ (let o,_ = CicEnvironment.get_obj uri CicUniv.empty_ugraph in
+ match o with
C.Constant (_,Some body,_,_) ->
try_delta_expansion l
(C.Const (uri,exp_named_subst'))
C.MutConstruct (_,_,j,_) -> reduceaux context l (List.nth pl (j-1))
| C.Appl (C.MutConstruct (_,_,j,_) :: tl) ->
let (arity, r) =
- match CicEnvironment.get_obj mutind with
- C.InductiveDefinition (tl,ingredients,r) ->
- let (_,_,arity,_) = List.nth tl i in
- (arity,r)
- | _ -> raise WrongUriToInductiveDefinition
+ let o,_ = CicEnvironment.get_obj mutind CicUniv.empty_ugraph in
+ match o with
+ C.InductiveDefinition (tl,ingredients,r) ->
+ let (_,_,arity,_) = List.nth tl i in
+ (arity,r)
+ | _ -> raise WrongUriToInductiveDefinition
in
let ts =
let rec eat_first =
match entry with
t when t == hyp_to_clear_body ->
let cleared_entry =
- let ty =
+ let ty,_ =
CicTypeChecker.type_of_aux' metasenv context term
+ CicUniv.empty_ugraph (* TASSI: FIXME *)
in
Some (n_to_clear_body, Cic.Decl ty)
in
| None -> None::context
| Some (n,C.Decl t)
| Some (n,C.Def (t,None)) ->
- let _ =
+ let _,_ =
try
CicTypeChecker.type_of_aux' metasenv context t
+ CicUniv.empty_ugraph (* TASSI: FIXME *)
with
_ ->
raise
| Some (_,Cic.Def (_,Some _)) -> assert false
) canonical_context []
in
- let _ =
+ let _,_ =
try
CicTypeChecker.type_of_aux' metasenv canonical_context' ty
+ CicUniv.empty_ugraph (* TASSI: FIXME *)
with
_ ->
raise
| Some (_,Cic.Def (_,Some _)) -> assert false
| Some (n,C.Decl t)
| Some (n,C.Def (t,None)) ->
- let _ =
+ let _,_ =
try
CicTypeChecker.type_of_aux' metasenv context t
+ CicUniv.empty_ugraph (* TASSI: FIXME *)
with
_ ->
raise
entry::context
) canonical_context []
in
- let _ =
+ let _,_ =
try
CicTypeChecker.type_of_aux' metasenv canonical_context' ty
+ CicUniv.empty_ugraph (* TASSI: FIXME *)
with
_ ->
raise
universe graph if the tactic Fails
*)
let apply_tactic t status =
- let saved_univ = CicUniv.get_working() in
- try
- t status
- with Fail s ->
- CicUniv.set_working saved_univ;
- raise (Fail s)
+ t status
(** constraint: the returned value will always be constructed by Cic.Name **)
type mk_fresh_name_type =
"elim_type eqt su t1 ...", ProofEngineTypes.mk_tactic (fun status ->
let status' = (* status after 1st elim_type use *)
let context = context_of_status status in
- if not (are_convertible context t1'' t1) then begin
+ let b,_ = (*TASSI : FIXME*)
+ are_convertible context t1'' t1 CicUniv.empty_ugraph in
+ if not b then begin
warn "t1'' and t1 are NOT CONVERTIBLE";
let newstatus =
ProofEngineTypes.apply_tactic
ProofEngineTypes.mk_tactic (fun status ->
let status' =
let context = context_of_status status in
- if not (are_convertible context t2'' t2) then begin
+ let b,_ = (* TASSI:FIXME *)
+ are_convertible context t2'' t2 CicUniv.empty_ugraph
+ in
+ if not b then begin
warn "t2'' and t2 are NOT CONVERTIBLE";
let newstatus =
ProofEngineTypes.apply_tactic
--- /dev/null
+(* Copyright (C) 2000-2002, HELM Team.
+ *
+ * This file is part of HELM, an Hypertextual, Electronic
+ * Library of Mathematics, developed at the Computer Science
+ * Department, University of Bologna, Italy.
+ *
+ * HELM is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * HELM is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HELM; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ *
+ * For details, see the HELM World-Wide-Web page,
+ * http://cs.unibo.it/helm/.
+ *)
+
+(*****************************************************************************)
+(* *)
+(* PROJECT HELM *)
+(* *)
+(* Claudio Sacerdoti Coen <sacerdot@cs.unibo.it> *)
+(* 18/02/2003 *)
+(* *)
+(* *)
+(*****************************************************************************)
+
+module MQI = MQueryInterpreter
+module MQIC = MQIConn
+module I = MQueryInterpreter
+module U = MQGUtil
+module G = MQueryGenerator
+
+ (* search arguments on which Apply tactic doesn't fail *)
+let matchConclusion mqi_handle ?(output_html = (fun _ -> ())) ~choose_must() status =
+ let ((_, metasenv, _, _), metano) = status in
+ let (_, ey ,ty) = CicUtil.lookup_meta metano metasenv in
+ let list_of_must, only = CGMatchConclusion.get_constraints metasenv ey ty in
+match list_of_must with
+ [] -> []
+|_ ->
+ let must = choose_must list_of_must only in
+ let result =
+ I.execute mqi_handle
+ (G.query_of_constraints
+ (Some CGMatchConclusion.universe)
+ (must,[],[]) (Some only,None,None)) in
+ let uris =
+ List.map
+ (function uri,_ ->
+ MQueryMisc.wrong_xpointer_format_from_wrong_xpointer_format' uri
+ ) result
+ in
+ let uris =
+ (* TODO ristretto per ragioni di efficienza *)
+ prerr_endline "STO FILTRANDO";
+ List.filter (fun uri -> Pcre.pmatch ~pat:"^cic:/Coq/" uri) uris
+ in
+ prerr_endline "HO FILTRATO";
+ let uris',exc =
+ let rec filter_out =
+ function
+ [] -> [],""
+ | uri::tl ->
+ let tl',exc = filter_out tl in
+ try
+ if
+ let time = Unix.gettimeofday() in
+ (try
+ ignore(ProofEngineTypes.apply_tactic
+ (PrimitiveTactics.apply_tac
+ ~term:(MQueryMisc.term_of_cic_textual_parser_uri
+ (MQueryMisc.cic_textual_parser_uri_of_string uri)))
+ status);
+ let time1 = Unix.gettimeofday() in
+ prerr_endline (Printf.sprintf "%1.3f" (time1 -. time) );
+ true
+ with ProofEngineTypes.Fail _ ->
+ let time1 = Unix.gettimeofday() in
+ prerr_endline (Printf.sprintf "%1.3f" (time1 -. time)); false)
+ then
+ uri::tl',exc
+ else
+ tl',exc
+ with
+ (ProofEngineTypes.Fail _) as e ->
+ let exc' =
+ "<h1 color=\"red\"> ^ Exception raised trying to apply " ^
+ uri ^ ": " ^ Printexc.to_string e ^ " </h1>" ^ exc
+ in
+ tl',exc'
+ in
+ filter_out uris
+ in
+ let html' =
+ " <h1>Objects that can actually be applied: </h1> " ^
+ String.concat "<br>" uris' ^ exc ^
+ " <h1>Number of false matches: " ^
+ string_of_int (List.length uris - List.length uris') ^ "</h1>" ^
+ " <h1>Number of good matches: " ^
+ string_of_int (List.length uris') ^ "</h1>"
+ in
+ output_html html' ;
+ uris'
+;;
+
+
+(*matchConclusion modificata per evitare una doppia apply*)
+let matchConclusion2 mqi_handle ?(output_html = (fun _ -> ())) ~choose_must() status =
+ let ((_, metasenv, _, _), metano) = status in
+ let (_, ey ,ty) = CicUtil.lookup_meta metano metasenv in
+ let conn =
+ match mqi_handle.MQIConn.pgc with
+ MQIConn.MySQL_C conn -> conn
+ | _ -> assert false in
+ let uris = Match_concl.cmatch conn ty in
+ (* List.iter
+ (fun (n,u) -> prerr_endline ((string_of_int n) ^ " " ^u)) uris; *)
+ (* delete all .var uris *)
+ let isvar (_,s) =
+ let len = String.length s in
+ let suffix = String.sub s (len-4) 4 in
+ not (suffix = ".var") in
+ let uris = List.filter isvar uris in
+ (* delete all not "cic:/Coq" uris *)
+ (*
+ let uris =
+ (* TODO ristretto per ragioni di efficienza *)
+ List.filter (fun _,uri -> Pcre.pmatch ~pat:"^cic:/Coq/" uri) uris in
+ *)
+ (* concl_cost are the costants in the conclusion of the proof
+ while hyp_const are the constants in the hypothesis *)
+ let (main_concl,concl_const) = NewConstraints.mainandcons ty in
+ prerr_endline ("Ne sono rimasti" ^ string_of_int (List.length uris));
+ let hyp t set =
+ match t with
+ Some (_,Cic.Decl t) -> (NewConstraints.StringSet.union set (NewConstraints.constants_concl t))
+ | Some (_,Cic.Def (t,_)) -> (NewConstraints.StringSet.union set (NewConstraints.constants_concl t))
+ | _ -> set in
+ let hyp_const =
+ List.fold_right hyp ey NewConstraints.StringSet.empty in
+ prerr_endline (NewConstraints.pp_StringSet (NewConstraints.StringSet.union hyp_const concl_const));
+ (* uris with new constants in the proof are filtered *)
+ let all_const = NewConstraints.StringSet.union hyp_const concl_const in
+ let uris =
+ if (List.length uris < (Filter_auto.power 2 (List.length (NewConstraints.StringSet.elements all_const))))
+ then
+ (prerr_endline("metodo vecchio");List.filter (Filter_auto.filter_new_constants conn all_const) uris)
+ else Filter_auto.filter_uris conn all_const uris main_concl in
+(*
+ let uris =
+ (* ristretto all cache *)
+ prerr_endline "SOLO CACHE";
+ List.filter
+ (fun uri -> CicEnvironment.in_cache (UriManager.uri_of_string uri)) uris
+ in
+ prerr_endline "HO FILTRATO2";
+*)
+ let uris =
+ List.map
+ (fun (n,u) ->
+ (n,MQueryMisc.wrong_xpointer_format_from_wrong_xpointer_format' u))
+ uris in
+ let uris' =
+ let rec filter_out =
+ function
+ [] -> []
+ | (m,uri)::tl ->
+ let tl' = filter_out tl in
+ try
+ prerr_endline ("STO APPLICANDO " ^ uri);
+ let res = (m,
+ (ProofEngineTypes.apply_tactic( PrimitiveTactics.apply_tac
+ ~term:(MQueryMisc.term_of_cic_textual_parser_uri
+ (MQueryMisc.cic_textual_parser_uri_of_string uri)))
+ status))::tl' in
+ prerr_endline ("OK");res
+ (* with ProofEngineTypes.Fail _ -> tl' *)
+ (* patch to cover CSC's exportation bug *)
+ with _ -> prerr_endline ("FAIL");tl'
+ in
+ prerr_endline ("Ne sono rimasti 2 " ^ string_of_int (List.length uris));
+ filter_out uris
+ in
+ prerr_endline ("Ne sono rimasti 3 " ^ string_of_int (List.length uris'));
+
+ uris'
+;;
+
+(*funzione che sceglie il penultimo livello di profondita' dei must*)
+
+(*
+let choose_must list_of_must only=
+let n = (List.length list_of_must) - 1 in
+ List.nth list_of_must n
+;;*)
+
+(* questa prende solo il main *)
+let choose_must list_of_must only =
+ List.nth list_of_must 0
+
+(* livello 1
+let choose_must list_of_must only =
+ try
+ List.nth list_of_must 1
+ with _ ->
+ List.nth list_of_must 0 *)
+
+let searchTheorems mqi_handle (proof,goal) =
+ let subproofs =
+ matchConclusion2 mqi_handle ~choose_must() (proof, goal) in
+ let res =
+ List.sort
+ (fun (n1,(_,gl1)) (n2,(_,gl2)) ->
+ let l1 = List.length gl1 in
+ let l2 = List.length gl2 in
+ (* if the list of subgoals have the same lenght we use the
+ prefix tag, where higher tags have precedence *)
+ if l1 = l2 then n2 - n1
+ else l1 - l2)
+ subproofs
+ in
+ (* now we may drop the prefix tag *)
+ (*let res' =
+ List.map snd res in*)
+ let order_goal_list proof goal1 goal2 =
+ let _,metasenv,_,_ = proof in
+ let (_, ey1, ty1) = CicUtil.lookup_meta goal1 metasenv in
+ let (_, ey2, ty2) = CicUtil.lookup_meta goal2 metasenv in
+(*
+ prerr_endline "PRIMA DELLA PRIMA TYPE OF " ;
+*)
+ let ty_sort1,u = (*TASSI: FIXME *)
+ CicTypeChecker.type_of_aux' metasenv ey1 ty1 CicUniv.empty_ugraph in
+(*
+ prerr_endline (Printf.sprintf "PRIMA DELLA SECONDA TYPE OF %s \n### %s @@@%s " (CicMetaSubst.ppmetasenv metasenv []) (CicMetaSubst.ppcontext [] ey2) (CicMetaSubst.ppterm [] ty2));
+*)
+ let ty_sort2,u1 = CicTypeChecker.type_of_aux' metasenv ey2 ty2 u in
+(*
+ prerr_endline "DOPO LA SECONDA TYPE OF " ;
+*)
+ let b,u2 =
+ CicReduction.are_convertible ey1 (Cic.Sort Cic.Prop) ty_sort1 u1 in
+ let prop1 = if b then 0 else 1 in
+ let b,_ = CicReduction.are_convertible ey2 (Cic.Sort Cic.Prop) ty_sort2 u2 in
+ let prop2 = if b then 0 else 1 in
+ prop1 - prop2 in
+ List.map (
+ fun (level,(proof,goallist)) ->
+ (proof, (List.stable_sort (order_goal_list proof) goallist))
+ ) res
+;;
+
(* GENERATED FILE, DO NOT EDIT *)
-val absurd : term:Cic.term -> ProofEngineTypes.tactic
-val apply : term:Cic.term -> ProofEngineTypes.tactic
-val assumption : ProofEngineTypes.tactic
-val auto : dbd:Mysql.dbd -> ProofEngineTypes.tactic
-val auto_new : dbd:Mysql.dbd -> ProofEngineTypes.tactic
-val change : what:Cic.term -> with_what:Cic.term -> ProofEngineTypes.tactic
-val compare : term:Cic.term -> ProofEngineTypes.tactic
-val constructor : n:int -> ProofEngineTypes.tactic
-val contradiction : ProofEngineTypes.tactic
-val cut :
- ?mk_fresh_name_callback:ProofEngineTypes.mk_fresh_name_type ->
- term:Cic.term -> ProofEngineTypes.tactic
-val decide_equality : ProofEngineTypes.tactic
-val decompose :
- ?uris_choice_callback:((UriManager.uri * int *
- (UriManager.uri * Cic.term) list)
- list ->
- (UriManager.uri * int *
- (UriManager.uri * Cic.term) list)
- list) ->
- Cic.term -> ProofEngineTypes.tactic
-val discriminate : term:Cic.term -> ProofEngineTypes.tactic
-val elim_intros_simpl : term:Cic.term -> ProofEngineTypes.tactic
-val elim_type : term:Cic.term -> ProofEngineTypes.tactic
-val exact : term:Cic.term -> ProofEngineTypes.tactic
-val exists : ProofEngineTypes.tactic
-val fold :
- reduction:(Cic.context -> Cic.term -> Cic.term) ->
- also_in_hypotheses:bool -> term:Cic.term -> ProofEngineTypes.tactic
-val fourier : ProofEngineTypes.tactic
-val generalize :
- ?mk_fresh_name_callback:ProofEngineTypes.mk_fresh_name_type ->
- Cic.term list -> ProofEngineTypes.tactic
-val injection : term:Cic.term -> ProofEngineTypes.tactic
-val intros :
- ?mk_fresh_name_callback:ProofEngineTypes.mk_fresh_name_type ->
- unit -> ProofEngineTypes.tactic
-val left : ProofEngineTypes.tactic
-val letin :
- ?mk_fresh_name_callback:ProofEngineTypes.mk_fresh_name_type ->
- term:Cic.term -> ProofEngineTypes.tactic
-val reduce :
- also_in_hypotheses:bool ->
- terms:Cic.term list option -> ProofEngineTypes.tactic
-val reflexivity : ProofEngineTypes.tactic
-val replace : what:Cic.term -> with_what:Cic.term -> ProofEngineTypes.tactic
-val rewrite_back : term:Cic.term -> ProofEngineTypes.tactic
-val rewrite_back_simpl : term:Cic.term -> ProofEngineTypes.tactic
-val rewrite : term:Cic.term -> ProofEngineTypes.tactic
-val rewrite_simpl : term:Cic.term -> ProofEngineTypes.tactic
-val right : ProofEngineTypes.tactic
-val ring : ProofEngineTypes.tactic
-val simpl :
- also_in_hypotheses:bool ->
- terms:Cic.term list option -> ProofEngineTypes.tactic
-val split : ProofEngineTypes.tactic
-val symmetry : ProofEngineTypes.tactic
-val transitivity : term:Cic.term -> ProofEngineTypes.tactic
-val whd :
- also_in_hypotheses:bool ->
- terms:Cic.term list option -> ProofEngineTypes.tactic
let module R = CicReduction in
let module S = CicSubstitution in
let module PT = PrimitiveTactics in
- let _,metasenv,_,_ = proof in
- let _,context,ty = CicUtil.lookup_meta goal metasenv in
- let rec find n = function
- hd::tl ->
- (match hd with
+ let _,metasenv,_,_ = proof in
+ let _,context,ty = CicUtil.lookup_meta goal metasenv in
+ let rec find n = function
+ hd::tl ->
+ (match hd with
(Some (_, C.Decl t)) when
- (R.are_convertible context (S.lift n t) ty) -> n
+ fst (R.are_convertible context (S.lift n t) ty
+ CicUniv.empty_ugraph) -> n
| (Some (_, C.Def (_,Some ty'))) when
- (R.are_convertible context ty' ty) -> n
- | (Some (_, C.Def (t,None))) when
- (R.are_convertible context
- (CicTypeChecker.type_of_aux' metasenv context (S.lift n t)) ty) -> n
+ fst (R.are_convertible context ty' ty CicUniv.empty_ugraph) -> n
+ | (Some (_, C.Def (t,None))) ->
+ let ty_t, u = (* TASSI: FIXME *)
+ CicTypeChecker.type_of_aux' metasenv context (S.lift n t)
+ CicUniv.empty_ugraph in
+ let b,_ = R.are_convertible context ty_t ty u in
+ if b then n else find (n+1) tl
| _ -> find (n+1) tl
)
| [] -> raise (PET.Fail "Assumption: No such assumption")
let module T = Tacticals in
let _,metasenv,_,_ = proof in
let _,context,ty = CicUtil.lookup_meta goal metasenv in
- let typ =
+ let typ,_ =
match terms with
[] -> assert false
| he::tl ->
- (* We need to check that all the convertibility of all the terms *)
- List.iter
- (function t ->
- if not (CicReduction.are_convertible context he t) then
- raise AllSelectedTermsMustBeConvertible
- ) tl ;
- (CicTypeChecker.type_of_aux' metasenv context he)
+ (* We need to check that all the convertibility of all the terms *)
+ let u = List.fold_left ( (* TASSI: FIXME *)
+ fun u t ->
+ let b,u1 = CicReduction.are_convertible context he t u in
+ if not b then
+ raise AllSelectedTermsMustBeConvertible
+ else
+ u1) CicUniv.empty_ugraph tl in
+ (CicTypeChecker.type_of_aux' metasenv context he u)
in
PET.apply_tactic
(T.thens
(* GENERATED by make_table: DO NOT EDIT! *)
let macro2utf8 = Hashtbl.create 2000
-let _ = Hashtbl.add macro2utf8 "nscr" "ð\157\147\131"
-let _ = Hashtbl.add macro2utf8 "LJcy" "Ð\137"
-let _ = Hashtbl.add macro2utf8 "dd" "â\133\134"
-let _ = Hashtbl.add macro2utf8 "Omacr" "Å\140"
-let _ = Hashtbl.add macro2utf8 "npreceq" "⪯̸"
-let _ = Hashtbl.add macro2utf8 "Gcirc" "Ä\156"
-let _ = Hashtbl.add macro2utf8 "utilde" "ũ"
-let _ = Hashtbl.add macro2utf8 "rdca" "⤷"
-let _ = Hashtbl.add macro2utf8 "racute" "Å\149"
-let _ = Hashtbl.add macro2utf8 "mstpos" "â\136¾"
-let _ = Hashtbl.add macro2utf8 "supnE" "â\138\139"
-let _ = Hashtbl.add macro2utf8 "NotLessLess" "â\137ªÌ¸ï¸\128"
-let _ = Hashtbl.add macro2utf8 "iiint" "â\136"
-let _ = Hashtbl.add macro2utf8 "uscr" "ð\157\147\138"
-let _ = Hashtbl.add macro2utf8 "Sfr" "ð\157\148\150"
-let _ = Hashtbl.add macro2utf8 "nsupseteqq" "â\138\137"
-let _ = Hashtbl.add macro2utf8 "nwarrow" "â\134\150"
-let _ = Hashtbl.add macro2utf8 "nwarrow" "â\134\150"
-let _ = Hashtbl.add macro2utf8 "twoheadrightarrow" "â\134 "
-let _ = Hashtbl.add macro2utf8 "sccue" "â\137½"
-let _ = Hashtbl.add macro2utf8 "NotSquareSuperset" "â\138\144̸"
-let _ = Hashtbl.add macro2utf8 "ee" "â\133\135"
-let _ = Hashtbl.add macro2utf8 "boxbox" "â§\137"
-let _ = Hashtbl.add macro2utf8 "andand" "â©\149"
-let _ = Hashtbl.add macro2utf8 "LeftVectorBar" "â¥\146"
-let _ = Hashtbl.add macro2utf8 "eg" "âª\154"
+let _ = Hashtbl.add macro2utf8 "nscr" "\240\157\147\131"
+let _ = Hashtbl.add macro2utf8 "LJcy" "\208\137"
+let _ = Hashtbl.add macro2utf8 "dd" "\226\133\134"
+let _ = Hashtbl.add macro2utf8 "Omacr" "\197\140"
+let _ = Hashtbl.add macro2utf8 "npreceq" "\226\170\175\204\184"
+let _ = Hashtbl.add macro2utf8 "Gcirc" "\196\156"
+let _ = Hashtbl.add macro2utf8 "utilde" "\197\169"
+let _ = Hashtbl.add macro2utf8 "rdca" "\226\164\183"
+let _ = Hashtbl.add macro2utf8 "racute" "\197\149"
+let _ = Hashtbl.add macro2utf8 "mstpos" "\226\136\190"
+let _ = Hashtbl.add macro2utf8 "supnE" "\226\138\139"
+let _ = Hashtbl.add macro2utf8 "NotLessLess" "\226\137\170\204\184\239\184\128"
+let _ = Hashtbl.add macro2utf8 "iiint" "\226\136\173"
+let _ = Hashtbl.add macro2utf8 "uscr" "\240\157\147\138"
+let _ = Hashtbl.add macro2utf8 "Sfr" "\240\157\148\150"
+let _ = Hashtbl.add macro2utf8 "nsupseteqq" "\226\138\137"
+let _ = Hashtbl.add macro2utf8 "nwarrow" "\226\134\150"
+let _ = Hashtbl.add macro2utf8 "nwarrow" "\226\134\150"
+let _ = Hashtbl.add macro2utf8 "twoheadrightarrow" "\226\134\160"
+let _ = Hashtbl.add macro2utf8 "sccue" "\226\137\189"
+let _ = Hashtbl.add macro2utf8 "NotSquareSuperset" "\226\138\144\204\184"
+let _ = Hashtbl.add macro2utf8 "ee" "\226\133\135"
+let _ = Hashtbl.add macro2utf8 "boxbox" "\226\167\137"
+let _ = Hashtbl.add macro2utf8 "andand" "\226\169\149"
+let _ = Hashtbl.add macro2utf8 "LeftVectorBar" "\226\165\146"
+let _ = Hashtbl.add macro2utf8 "eg" "\226\170\154"
let _ = Hashtbl.add macro2utf8 "csc" "csc"
-let _ = Hashtbl.add macro2utf8 "NotRightTriangleEqual" "â\139"
-let _ = Hashtbl.add macro2utf8 "filig" "ï¬\129"
-let _ = Hashtbl.add macro2utf8 "atilde" "ã"
-let _ = Hashtbl.add macro2utf8 "ring" "Ë\154"
-let _ = Hashtbl.add macro2utf8 "congdot" "⩭"
-let _ = Hashtbl.add macro2utf8 "gE" "â\137§"
-let _ = Hashtbl.add macro2utf8 "rcedil" "Å\151"
-let _ = Hashtbl.add macro2utf8 "el" "âª\153"
-let _ = Hashtbl.add macro2utf8 "HorizontalLine" "â\148\128"
-let _ = Hashtbl.add macro2utf8 "incare" "â\132\133"
-let _ = Hashtbl.add macro2utf8 "hoarr" "â\135¿"
-let _ = Hashtbl.add macro2utf8 "SOFTcy" "Ь"
-let _ = Hashtbl.add macro2utf8 "conint" "â\136®"
-let _ = Hashtbl.add macro2utf8 "OverParenthesis" "︵"
-let _ = Hashtbl.add macro2utf8 "Uogon" "Ų"
-let _ = Hashtbl.add macro2utf8 "supne" "â\138\139"
+let _ = Hashtbl.add macro2utf8 "NotRightTriangleEqual" "\226\139\173"
+let _ = Hashtbl.add macro2utf8 "filig" "\239\172\129"
+let _ = Hashtbl.add macro2utf8 "atilde" "\195\163"
+let _ = Hashtbl.add macro2utf8 "ring" "\203\154"
+let _ = Hashtbl.add macro2utf8 "congdot" "\226\169\173"
+let _ = Hashtbl.add macro2utf8 "gE" "\226\137\167"
+let _ = Hashtbl.add macro2utf8 "rcedil" "\197\151"
+let _ = Hashtbl.add macro2utf8 "el" "\226\170\153"
+let _ = Hashtbl.add macro2utf8 "HorizontalLine" "\226\148\128"
+let _ = Hashtbl.add macro2utf8 "incare" "\226\132\133"
+let _ = Hashtbl.add macro2utf8 "hoarr" "\226\135\191"
+let _ = Hashtbl.add macro2utf8 "SOFTcy" "\208\172"
+let _ = Hashtbl.add macro2utf8 "conint" "\226\136\174"
+let _ = Hashtbl.add macro2utf8 "OverParenthesis" "\239\184\181"
+let _ = Hashtbl.add macro2utf8 "Uogon" "\197\178"
+let _ = Hashtbl.add macro2utf8 "supne" "\226\138\139"
let _ = Hashtbl.add macro2utf8 "num" "#"
-let _ = Hashtbl.add macro2utf8 "zcy" "з"
-let _ = Hashtbl.add macro2utf8 "Hfr" "â\132\140"
-let _ = Hashtbl.add macro2utf8 "dtri" "â\150¿"
-let _ = Hashtbl.add macro2utf8 "FilledSmallSquare" "â\151¾"
-let _ = Hashtbl.add macro2utf8 "SucceedsEqual" "â\137½"
-let _ = Hashtbl.add macro2utf8 "leftthreetimes" "â\139\139"
-let _ = Hashtbl.add macro2utf8 "ycirc" "ŷ"
-let _ = Hashtbl.add macro2utf8 "sqcup" "â\138\148"
-let _ = Hashtbl.add macro2utf8 "sqcup" "â\138\148"
-let _ = Hashtbl.add macro2utf8 "DoubleLeftArrow" "â\135\144"
-let _ = Hashtbl.add macro2utf8 "ge" "â\137¥"
-let _ = Hashtbl.add macro2utf8 "gtrless" "â\137·"
-let _ = Hashtbl.add macro2utf8 "ge" "â\137¥"
-let _ = Hashtbl.add macro2utf8 "Product" "â\136\143"
-let _ = Hashtbl.add macro2utf8 "NotExists" "â\136\132"
-let _ = Hashtbl.add macro2utf8 "gg" "â\137«"
-let _ = Hashtbl.add macro2utf8 "gg" "â\137«"
-let _ = Hashtbl.add macro2utf8 "curlyvee" "â\139\142"
-let _ = Hashtbl.add macro2utf8 "ntrianglerighteq" "â\139"
-let _ = Hashtbl.add macro2utf8 "Colon" "â\136·"
-let _ = Hashtbl.add macro2utf8 "rbrke" "â¦\140"
-let _ = Hashtbl.add macro2utf8 "LeftDownVector" "â\135\131"
-let _ = Hashtbl.add macro2utf8 "gl" "â\137·"
-let _ = Hashtbl.add macro2utf8 "lrcorner" "â\140\159"
-let _ = Hashtbl.add macro2utf8 "mapstodown" "â\134§"
+let _ = Hashtbl.add macro2utf8 "zcy" "\208\183"
+let _ = Hashtbl.add macro2utf8 "Hfr" "\226\132\140"
+let _ = Hashtbl.add macro2utf8 "dtri" "\226\150\191"
+let _ = Hashtbl.add macro2utf8 "FilledSmallSquare" "\226\151\190"
+let _ = Hashtbl.add macro2utf8 "SucceedsEqual" "\226\137\189"
+let _ = Hashtbl.add macro2utf8 "leftthreetimes" "\226\139\139"
+let _ = Hashtbl.add macro2utf8 "ycirc" "\197\183"
+let _ = Hashtbl.add macro2utf8 "sqcup" "\226\138\148"
+let _ = Hashtbl.add macro2utf8 "sqcup" "\226\138\148"
+let _ = Hashtbl.add macro2utf8 "DoubleLeftArrow" "\226\135\144"
+let _ = Hashtbl.add macro2utf8 "ge" "\226\137\165"
+let _ = Hashtbl.add macro2utf8 "gtrless" "\226\137\183"
+let _ = Hashtbl.add macro2utf8 "ge" "\226\137\165"
+let _ = Hashtbl.add macro2utf8 "Product" "\226\136\143"
+let _ = Hashtbl.add macro2utf8 "NotExists" "\226\136\132"
+let _ = Hashtbl.add macro2utf8 "gg" "\226\137\171"
+let _ = Hashtbl.add macro2utf8 "gg" "\226\137\171"
+let _ = Hashtbl.add macro2utf8 "curlyvee" "\226\139\142"
+let _ = Hashtbl.add macro2utf8 "ntrianglerighteq" "\226\139\173"
+let _ = Hashtbl.add macro2utf8 "Colon" "\226\136\183"
+let _ = Hashtbl.add macro2utf8 "rbrke" "\226\166\140"
+let _ = Hashtbl.add macro2utf8 "LeftDownVector" "\226\135\131"
+let _ = Hashtbl.add macro2utf8 "gl" "\226\137\183"
+let _ = Hashtbl.add macro2utf8 "lrcorner" "\226\140\159"
+let _ = Hashtbl.add macro2utf8 "mapstodown" "\226\134\167"
let _ = Hashtbl.add macro2utf8 "excl" "!"
-let _ = Hashtbl.add macro2utf8 "cdots" "â\139¯"
-let _ = Hashtbl.add macro2utf8 "larr" "â\134\144"
-let _ = Hashtbl.add macro2utf8 "dtdot" "â\139±"
-let _ = Hashtbl.add macro2utf8 "kgreen" "ĸ"
-let _ = Hashtbl.add macro2utf8 "rtri" "â\150¹"
-let _ = Hashtbl.add macro2utf8 "rbarr" "â¤\141"
-let _ = Hashtbl.add macro2utf8 "ocy" "о"
+let _ = Hashtbl.add macro2utf8 "cdots" "\226\139\175"
+let _ = Hashtbl.add macro2utf8 "larr" "\226\134\144"
+let _ = Hashtbl.add macro2utf8 "dtdot" "\226\139\177"
+let _ = Hashtbl.add macro2utf8 "kgreen" "\196\184"
+let _ = Hashtbl.add macro2utf8 "rtri" "\226\150\185"
+let _ = Hashtbl.add macro2utf8 "rbarr" "\226\164\141"
+let _ = Hashtbl.add macro2utf8 "ocy" "\208\190"
let _ = Hashtbl.add macro2utf8 "gt" ">"
-let _ = Hashtbl.add macro2utf8 "cup" "â\136ª"
-let _ = Hashtbl.add macro2utf8 "DownLeftRightVector" "â¥\144"
-let _ = Hashtbl.add macro2utf8 "cup" "â\136ª"
-let _ = Hashtbl.add macro2utf8 "updownarrow" "â\134\149"
-let _ = Hashtbl.add macro2utf8 "updownarrow" "â\134\149"
-let _ = Hashtbl.add macro2utf8 "Imacr" "Ī"
-let _ = Hashtbl.add macro2utf8 "cross" "â\156\151"
-let _ = Hashtbl.add macro2utf8 "Acirc" "Ã\130"
-let _ = Hashtbl.add macro2utf8 "lvertneqq" "â\137¨ï¸\128"
-let _ = Hashtbl.add macro2utf8 "ccaps" "â©\141"
-let _ = Hashtbl.add macro2utf8 "NotLeftTriangleEqual" "â\139¬"
-let _ = Hashtbl.add macro2utf8 "IJlig" "IJ"
-let _ = Hashtbl.add macro2utf8 "boxplus" "â\138\158"
-let _ = Hashtbl.add macro2utf8 "epsilon" "ϵ"
-let _ = Hashtbl.add macro2utf8 "zfr" "ð\157\148·"
-let _ = Hashtbl.add macro2utf8 "late" "⪭"
-let _ = Hashtbl.add macro2utf8 "ic" "â\128\139"
-let _ = Hashtbl.add macro2utf8 "lrhar" "â\135\139"
-let _ = Hashtbl.add macro2utf8 "gsim" "â\137³"
+let _ = Hashtbl.add macro2utf8 "cup" "\226\136\170"
+let _ = Hashtbl.add macro2utf8 "DownLeftRightVector" "\226\165\144"
+let _ = Hashtbl.add macro2utf8 "cup" "\226\136\170"
+let _ = Hashtbl.add macro2utf8 "updownarrow" "\226\134\149"
+let _ = Hashtbl.add macro2utf8 "updownarrow" "\226\134\149"
+let _ = Hashtbl.add macro2utf8 "Imacr" "\196\170"
+let _ = Hashtbl.add macro2utf8 "cross" "\226\156\151"
+let _ = Hashtbl.add macro2utf8 "Acirc" "\195\130"
+let _ = Hashtbl.add macro2utf8 "lvertneqq" "\226\137\168\239\184\128"
+let _ = Hashtbl.add macro2utf8 "ccaps" "\226\169\141"
+let _ = Hashtbl.add macro2utf8 "NotLeftTriangleEqual" "\226\139\172"
+let _ = Hashtbl.add macro2utf8 "IJlig" "\196\178"
+let _ = Hashtbl.add macro2utf8 "boxplus" "\226\138\158"
+let _ = Hashtbl.add macro2utf8 "epsilon" "\207\181"
+let _ = Hashtbl.add macro2utf8 "zfr" "\240\157\148\183"
+let _ = Hashtbl.add macro2utf8 "late" "\226\170\173"
+let _ = Hashtbl.add macro2utf8 "ic" "\226\128\139"
+let _ = Hashtbl.add macro2utf8 "lrhar" "\226\135\139"
+let _ = Hashtbl.add macro2utf8 "gsim" "\226\137\179"
let _ = Hashtbl.add macro2utf8 "inf" "inf"
-let _ = Hashtbl.add macro2utf8 "top" "â\138¤"
-let _ = Hashtbl.add macro2utf8 "top" "â\138¤"
-let _ = Hashtbl.add macro2utf8 "odsold" "⦼"
-let _ = Hashtbl.add macro2utf8 "circlearrowright" "â\134»"
-let _ = Hashtbl.add macro2utf8 "rtimes" "â\139\138"
-let _ = Hashtbl.add macro2utf8 "ii" "â\133\136"
-let _ = Hashtbl.add macro2utf8 "DoubleRightTee" "â\138¨"
-let _ = Hashtbl.add macro2utf8 "dcy" "д"
-let _ = Hashtbl.add macro2utf8 "boxdL" "â\149\149"
-let _ = Hashtbl.add macro2utf8 "duhar" "⥯"
+let _ = Hashtbl.add macro2utf8 "top" "\226\138\164"
+let _ = Hashtbl.add macro2utf8 "top" "\226\138\164"
+let _ = Hashtbl.add macro2utf8 "odsold" "\226\166\188"
+let _ = Hashtbl.add macro2utf8 "circlearrowright" "\226\134\187"
+let _ = Hashtbl.add macro2utf8 "rtimes" "\226\139\138"
+let _ = Hashtbl.add macro2utf8 "ii" "\226\133\136"
+let _ = Hashtbl.add macro2utf8 "DoubleRightTee" "\226\138\168"
+let _ = Hashtbl.add macro2utf8 "dcy" "\208\180"
+let _ = Hashtbl.add macro2utf8 "boxdL" "\226\149\149"
+let _ = Hashtbl.add macro2utf8 "duhar" "\226\165\175"
let _ = Hashtbl.add macro2utf8 "vert" "|"
-let _ = Hashtbl.add macro2utf8 "in" "â\136\136"
+let _ = Hashtbl.add macro2utf8 "in" "\226\136\136"
let _ = Hashtbl.add macro2utf8 "vert" "|"
-let _ = Hashtbl.add macro2utf8 "sacute" "Å\155"
-let _ = Hashtbl.add macro2utf8 "in" "â\136\136"
-let _ = Hashtbl.add macro2utf8 "Assign" "â\137\148"
-let _ = Hashtbl.add macro2utf8 "nsim" "â\137\129"
-let _ = Hashtbl.add macro2utf8 "boxdR" "â\149\146"
-let _ = Hashtbl.add macro2utf8 "int" "â\136«"
-let _ = Hashtbl.add macro2utf8 "o" "ο"
-let _ = Hashtbl.add macro2utf8 "radic" "â\136\154"
-let _ = Hashtbl.add macro2utf8 "it" "â\129¢"
-let _ = Hashtbl.add macro2utf8 "int" "â\136«"
-let _ = Hashtbl.add macro2utf8 "cwint" "â\136±"
-let _ = Hashtbl.add macro2utf8 "ForAll" "â\136\128"
-let _ = Hashtbl.add macro2utf8 "simplus" "⨤"
-let _ = Hashtbl.add macro2utf8 "isindot" "â\139µ"
-let _ = Hashtbl.add macro2utf8 "rightthreetimes" "â\139\140"
-let _ = Hashtbl.add macro2utf8 "supseteqq" "â\138\135"
-let _ = Hashtbl.add macro2utf8 "bnot" "â\140\144"
-let _ = Hashtbl.add macro2utf8 "rppolint" "â¨\146"
-let _ = Hashtbl.add macro2utf8 "def" "â\137\157"
-let _ = Hashtbl.add macro2utf8 "TScy" "Ц"
-let _ = Hashtbl.add macro2utf8 "lE" "â\137¦"
-let _ = Hashtbl.add macro2utf8 "ffilig" "ï¬\131"
+let _ = Hashtbl.add macro2utf8 "sacute" "\197\155"
+let _ = Hashtbl.add macro2utf8 "in" "\226\136\136"
+let _ = Hashtbl.add macro2utf8 "Assign" "\226\137\148"
+let _ = Hashtbl.add macro2utf8 "nsim" "\226\137\129"
+let _ = Hashtbl.add macro2utf8 "boxdR" "\226\149\146"
+let _ = Hashtbl.add macro2utf8 "int" "\226\136\171"
+let _ = Hashtbl.add macro2utf8 "o" "\206\191"
+let _ = Hashtbl.add macro2utf8 "radic" "\226\136\154"
+let _ = Hashtbl.add macro2utf8 "it" "\226\129\162"
+let _ = Hashtbl.add macro2utf8 "int" "\226\136\171"
+let _ = Hashtbl.add macro2utf8 "cwint" "\226\136\177"
+let _ = Hashtbl.add macro2utf8 "ForAll" "\226\136\128"
+let _ = Hashtbl.add macro2utf8 "simplus" "\226\168\164"
+let _ = Hashtbl.add macro2utf8 "isindot" "\226\139\181"
+let _ = Hashtbl.add macro2utf8 "rightthreetimes" "\226\139\140"
+let _ = Hashtbl.add macro2utf8 "supseteqq" "\226\138\135"
+let _ = Hashtbl.add macro2utf8 "bnot" "\226\140\144"
+let _ = Hashtbl.add macro2utf8 "rppolint" "\226\168\146"
+let _ = Hashtbl.add macro2utf8 "def" "\226\137\157"
+let _ = Hashtbl.add macro2utf8 "TScy" "\208\166"
+let _ = Hashtbl.add macro2utf8 "lE" "\226\137\166"
+let _ = Hashtbl.add macro2utf8 "ffilig" "\239\172\131"
let _ = Hashtbl.add macro2utf8 "deg" "deg"
-let _ = Hashtbl.add macro2utf8 "deg" "°"
+let _ = Hashtbl.add macro2utf8 "deg" "\194\176"
let _ = Hashtbl.add macro2utf8 "{" "{"
-let _ = Hashtbl.add macro2utf8 "RightVector" "â\135\128"
-let _ = Hashtbl.add macro2utf8 "ofr" "ð\157\148¬"
+let _ = Hashtbl.add macro2utf8 "RightVector" "\226\135\128"
+let _ = Hashtbl.add macro2utf8 "ofr" "\240\157\148\172"
let _ = Hashtbl.add macro2utf8 "|" "|"
let _ = Hashtbl.add macro2utf8 "liminf" "liminf"
let _ = Hashtbl.add macro2utf8 "}" "}"
-let _ = Hashtbl.add macro2utf8 "LeftUpTeeVector" "⥠"
-let _ = Hashtbl.add macro2utf8 "scirc" "Å\157"
-let _ = Hashtbl.add macro2utf8 "scedil" "Å\159"
-let _ = Hashtbl.add macro2utf8 "ufisht" "⥾"
-let _ = Hashtbl.add macro2utf8 "LeftUpDownVector" "â¥\145"
-let _ = Hashtbl.add macro2utf8 "leftarrow" "â\134\144"
-let _ = Hashtbl.add macro2utf8 "questeq" "â\137\159"
-let _ = Hashtbl.add macro2utf8 "leftarrow" "â\134\144"
-let _ = Hashtbl.add macro2utf8 "Ycy" "Ы"
-let _ = Hashtbl.add macro2utf8 "Coproduct" "â\136\144"
+let _ = Hashtbl.add macro2utf8 "LeftUpTeeVector" "\226\165\160"
+let _ = Hashtbl.add macro2utf8 "scirc" "\197\157"
+let _ = Hashtbl.add macro2utf8 "scedil" "\197\159"
+let _ = Hashtbl.add macro2utf8 "ufisht" "\226\165\190"
+let _ = Hashtbl.add macro2utf8 "LeftUpDownVector" "\226\165\145"
+let _ = Hashtbl.add macro2utf8 "leftarrow" "\226\134\144"
+let _ = Hashtbl.add macro2utf8 "questeq" "\226\137\159"
+let _ = Hashtbl.add macro2utf8 "leftarrow" "\226\134\144"
+let _ = Hashtbl.add macro2utf8 "Ycy" "\208\171"
+let _ = Hashtbl.add macro2utf8 "Coproduct" "\226\136\144"
let _ = Hashtbl.add macro2utf8 "det" "det"
-let _ = Hashtbl.add macro2utf8 "boxdl" "â\148\144"
-let _ = Hashtbl.add macro2utf8 "Aopf" "ð\157\148¸"
-let _ = Hashtbl.add macro2utf8 "srarr" "â\134\146ï¸\128"
-let _ = Hashtbl.add macro2utf8 "lbrke" "â¦\139"
-let _ = Hashtbl.add macro2utf8 "boxdr" "â\148\140"
-let _ = Hashtbl.add macro2utf8 "Ntilde" "Ã\145"
-let _ = Hashtbl.add macro2utf8 "gnap" "âª\138"
-let _ = Hashtbl.add macro2utf8 "Cap" "â\139\146"
-let _ = Hashtbl.add macro2utf8 "swarhk" "⤦"
-let _ = Hashtbl.add macro2utf8 "ogt" "â§\129"
-let _ = Hashtbl.add macro2utf8 "emptyset" "â\136\133ï¸\128"
-let _ = Hashtbl.add macro2utf8 "emptyset" "â\136\133ï¸\128"
-let _ = Hashtbl.add macro2utf8 "harrw" "â\134"
-let _ = Hashtbl.add macro2utf8 "lbarr" "â¤\140"
-let _ = Hashtbl.add macro2utf8 "delta" "δ"
-let _ = Hashtbl.add macro2utf8 "Tilde" "â\136¼"
-let _ = Hashtbl.add macro2utf8 "delta" "δ"
-let _ = Hashtbl.add macro2utf8 "Hopf" "â\132\141"
-let _ = Hashtbl.add macro2utf8 "dfr" "ð\157\148¡"
-let _ = Hashtbl.add macro2utf8 "le" "â\137¤"
-let _ = Hashtbl.add macro2utf8 "le" "â\137¤"
+let _ = Hashtbl.add macro2utf8 "boxdl" "\226\148\144"
+let _ = Hashtbl.add macro2utf8 "Aopf" "\240\157\148\184"
+let _ = Hashtbl.add macro2utf8 "srarr" "\226\134\146\239\184\128"
+let _ = Hashtbl.add macro2utf8 "lbrke" "\226\166\139"
+let _ = Hashtbl.add macro2utf8 "boxdr" "\226\148\140"
+let _ = Hashtbl.add macro2utf8 "Ntilde" "\195\145"
+let _ = Hashtbl.add macro2utf8 "gnap" "\226\170\138"
+let _ = Hashtbl.add macro2utf8 "Cap" "\226\139\146"
+let _ = Hashtbl.add macro2utf8 "swarhk" "\226\164\166"
+let _ = Hashtbl.add macro2utf8 "ogt" "\226\167\129"
+let _ = Hashtbl.add macro2utf8 "emptyset" "\226\136\133\239\184\128"
+let _ = Hashtbl.add macro2utf8 "emptyset" "\226\136\133\239\184\128"
+let _ = Hashtbl.add macro2utf8 "harrw" "\226\134\173"
+let _ = Hashtbl.add macro2utf8 "lbarr" "\226\164\140"
+let _ = Hashtbl.add macro2utf8 "delta" "\206\180"
+let _ = Hashtbl.add macro2utf8 "Tilde" "\226\136\188"
+let _ = Hashtbl.add macro2utf8 "delta" "\206\180"
+let _ = Hashtbl.add macro2utf8 "Hopf" "\226\132\141"
+let _ = Hashtbl.add macro2utf8 "dfr" "\240\157\148\161"
+let _ = Hashtbl.add macro2utf8 "le" "\226\137\164"
+let _ = Hashtbl.add macro2utf8 "le" "\226\137\164"
let _ = Hashtbl.add macro2utf8 "lg" "lg"
-let _ = Hashtbl.add macro2utf8 "lg" "â\137¶"
-let _ = Hashtbl.add macro2utf8 "ohm" "â\132¦"
-let _ = Hashtbl.add macro2utf8 "Jsercy" "Ð\136"
-let _ = Hashtbl.add macro2utf8 "quaternions" "â\132\141"
-let _ = Hashtbl.add macro2utf8 "DoubleLongLeftArrow" "ï\149¹"
-let _ = Hashtbl.add macro2utf8 "ll" "â\137ª"
-let _ = Hashtbl.add macro2utf8 "nabla" "â\136\135"
-let _ = Hashtbl.add macro2utf8 "Ncy" "Ð\157"
-let _ = Hashtbl.add macro2utf8 "nabla" "â\136\135"
-let _ = Hashtbl.add macro2utf8 "ltcir" "⩹"
-let _ = Hashtbl.add macro2utf8 "ll" "â\137ª"
+let _ = Hashtbl.add macro2utf8 "lg" "\226\137\182"
+let _ = Hashtbl.add macro2utf8 "ohm" "\226\132\166"
+let _ = Hashtbl.add macro2utf8 "Jsercy" "\208\136"
+let _ = Hashtbl.add macro2utf8 "quaternions" "\226\132\141"
+let _ = Hashtbl.add macro2utf8 "DoubleLongLeftArrow" "\239\149\185"
+let _ = Hashtbl.add macro2utf8 "ll" "\226\137\170"
+let _ = Hashtbl.add macro2utf8 "nabla" "\226\136\135"
+let _ = Hashtbl.add macro2utf8 "Ncy" "\208\157"
+let _ = Hashtbl.add macro2utf8 "nabla" "\226\136\135"
+let _ = Hashtbl.add macro2utf8 "ltcir" "\226\169\185"
+let _ = Hashtbl.add macro2utf8 "ll" "\226\137\170"
let _ = Hashtbl.add macro2utf8 "ln" "ln"
-let _ = Hashtbl.add macro2utf8 "rmoust" "â\142±"
-let _ = Hashtbl.add macro2utf8 "Oopf" "ð\157\149\134"
-let _ = Hashtbl.add macro2utf8 "nbsp" " "
-let _ = Hashtbl.add macro2utf8 "Kcedil" "Ķ"
-let _ = Hashtbl.add macro2utf8 "vdots" "â\139®"
-let _ = Hashtbl.add macro2utf8 "NotLessTilde" "â\137´"
+let _ = Hashtbl.add macro2utf8 "rmoust" "\226\142\177"
+let _ = Hashtbl.add macro2utf8 "Oopf" "\240\157\149\134"
+let _ = Hashtbl.add macro2utf8 "nbsp" "\194\160"
+let _ = Hashtbl.add macro2utf8 "Kcedil" "\196\182"
+let _ = Hashtbl.add macro2utf8 "vdots" "\226\139\174"
+let _ = Hashtbl.add macro2utf8 "NotLessTilde" "\226\137\180"
let _ = Hashtbl.add macro2utf8 "lt" "<"
-let _ = Hashtbl.add macro2utf8 "djcy" "Ñ\146"
-let _ = Hashtbl.add macro2utf8 "DownRightTeeVector" "â¥\159"
-let _ = Hashtbl.add macro2utf8 "Ograve" "Ã\146"
-let _ = Hashtbl.add macro2utf8 "boxhD" "â\149¥"
-let _ = Hashtbl.add macro2utf8 "nsime" "â\137\132"
-let _ = Hashtbl.add macro2utf8 "egsdot" "âª\152"
-let _ = Hashtbl.add macro2utf8 "bigodot" "â\138\153"
-let _ = Hashtbl.add macro2utf8 "mDDot" "â\136º"
-let _ = Hashtbl.add macro2utf8 "bigodot" "â\138\153"
-let _ = Hashtbl.add macro2utf8 "Vopf" "ð\157\149\141"
-let _ = Hashtbl.add macro2utf8 "looparrowright" "â\134¬"
-let _ = Hashtbl.add macro2utf8 "yucy" "Ñ\142"
-let _ = Hashtbl.add macro2utf8 "trade" "â\132¢"
-let _ = Hashtbl.add macro2utf8 "Yfr" "ð\157\148\156"
-let _ = Hashtbl.add macro2utf8 "kjcy" "Ñ\156"
-let _ = Hashtbl.add macro2utf8 "mp" "â\136\147"
-let _ = Hashtbl.add macro2utf8 "mp" "â\136\147"
-let _ = Hashtbl.add macro2utf8 "leftrightarrows" "â\135\134"
-let _ = Hashtbl.add macro2utf8 "uharl" "â\134¿"
-let _ = Hashtbl.add macro2utf8 "ncap" "â©\131"
-let _ = Hashtbl.add macro2utf8 "Iogon" "Į"
-let _ = Hashtbl.add macro2utf8 "NotSubset" "â\138\132"
-let _ = Hashtbl.add macro2utf8 "Bumpeq" "â\137\142"
-let _ = Hashtbl.add macro2utf8 "mu" "μ"
-let _ = Hashtbl.add macro2utf8 "mu" "μ"
-let _ = Hashtbl.add macro2utf8 "FilledVerySmallSquare" "ï\150\155"
-let _ = Hashtbl.add macro2utf8 "breve" "Ë\152"
-let _ = Hashtbl.add macro2utf8 "boxhU" "â\149¨"
-let _ = Hashtbl.add macro2utf8 "Sigma" "Σ"
-let _ = Hashtbl.add macro2utf8 "Sigma" "Σ"
-let _ = Hashtbl.add macro2utf8 "uharr" "â\134¾"
-let _ = Hashtbl.add macro2utf8 "ne" "â\137 "
-let _ = Hashtbl.add macro2utf8 "xrArr" "ï\149º"
-let _ = Hashtbl.add macro2utf8 "ne" "â\137 "
-let _ = Hashtbl.add macro2utf8 "oS" "â\147\136"
-let _ = Hashtbl.add macro2utf8 "xodot" "â\138\153"
-let _ = Hashtbl.add macro2utf8 "ni" "â\136\139"
-let _ = Hashtbl.add macro2utf8 "ni" "â\136\139"
-let _ = Hashtbl.add macro2utf8 "mdash" "â\128\148"
-let _ = Hashtbl.add macro2utf8 "Verbar" "â\128\150"
-let _ = Hashtbl.add macro2utf8 "die" "¨"
-let _ = Hashtbl.add macro2utf8 "veebar" "â\138»"
-let _ = Hashtbl.add macro2utf8 "UpArrowBar" "â¤\146"
-let _ = Hashtbl.add macro2utf8 "Ncaron" "Å\135"
-let _ = Hashtbl.add macro2utf8 "RightArrowBar" "â\135¥"
-let _ = Hashtbl.add macro2utf8 "LongLeftArrow" "ï\149¶"
-let _ = Hashtbl.add macro2utf8 "rceil" "â\140\137"
-let _ = Hashtbl.add macro2utf8 "rceil" "â\140\137"
-let _ = Hashtbl.add macro2utf8 "LeftDownVectorBar" "â¥\153"
-let _ = Hashtbl.add macro2utf8 "umacr" "ū"
-let _ = Hashtbl.add macro2utf8 "Hacek" "Ë\135"
-let _ = Hashtbl.add macro2utf8 "odblac" "Å\145"
-let _ = Hashtbl.add macro2utf8 "lmidot" "Å\128"
-let _ = Hashtbl.add macro2utf8 "dopf" "ð\157\149\149"
-let _ = Hashtbl.add macro2utf8 "boxhd" "â\148¬"
+let _ = Hashtbl.add macro2utf8 "djcy" "\209\146"
+let _ = Hashtbl.add macro2utf8 "DownRightTeeVector" "\226\165\159"
+let _ = Hashtbl.add macro2utf8 "Ograve" "\195\146"
+let _ = Hashtbl.add macro2utf8 "boxhD" "\226\149\165"
+let _ = Hashtbl.add macro2utf8 "nsime" "\226\137\132"
+let _ = Hashtbl.add macro2utf8 "egsdot" "\226\170\152"
+let _ = Hashtbl.add macro2utf8 "bigodot" "\226\138\153"
+let _ = Hashtbl.add macro2utf8 "mDDot" "\226\136\186"
+let _ = Hashtbl.add macro2utf8 "bigodot" "\226\138\153"
+let _ = Hashtbl.add macro2utf8 "Vopf" "\240\157\149\141"
+let _ = Hashtbl.add macro2utf8 "looparrowright" "\226\134\172"
+let _ = Hashtbl.add macro2utf8 "yucy" "\209\142"
+let _ = Hashtbl.add macro2utf8 "trade" "\226\132\162"
+let _ = Hashtbl.add macro2utf8 "Yfr" "\240\157\148\156"
+let _ = Hashtbl.add macro2utf8 "kjcy" "\209\156"
+let _ = Hashtbl.add macro2utf8 "mp" "\226\136\147"
+let _ = Hashtbl.add macro2utf8 "mp" "\226\136\147"
+let _ = Hashtbl.add macro2utf8 "leftrightarrows" "\226\135\134"
+let _ = Hashtbl.add macro2utf8 "uharl" "\226\134\191"
+let _ = Hashtbl.add macro2utf8 "ncap" "\226\169\131"
+let _ = Hashtbl.add macro2utf8 "Iogon" "\196\174"
+let _ = Hashtbl.add macro2utf8 "NotSubset" "\226\138\132"
+let _ = Hashtbl.add macro2utf8 "Bumpeq" "\226\137\142"
+let _ = Hashtbl.add macro2utf8 "mu" "\206\188"
+let _ = Hashtbl.add macro2utf8 "mu" "\206\188"
+let _ = Hashtbl.add macro2utf8 "FilledVerySmallSquare" "\239\150\155"
+let _ = Hashtbl.add macro2utf8 "breve" "\203\152"
+let _ = Hashtbl.add macro2utf8 "boxhU" "\226\149\168"
+let _ = Hashtbl.add macro2utf8 "Sigma" "\206\163"
+let _ = Hashtbl.add macro2utf8 "Sigma" "\206\163"
+let _ = Hashtbl.add macro2utf8 "uharr" "\226\134\190"
+let _ = Hashtbl.add macro2utf8 "ne" "\226\137\160"
+let _ = Hashtbl.add macro2utf8 "xrArr" "\239\149\186"
+let _ = Hashtbl.add macro2utf8 "ne" "\226\137\160"
+let _ = Hashtbl.add macro2utf8 "oS" "\226\147\136"
+let _ = Hashtbl.add macro2utf8 "xodot" "\226\138\153"
+let _ = Hashtbl.add macro2utf8 "ni" "\226\136\139"
+let _ = Hashtbl.add macro2utf8 "ni" "\226\136\139"
+let _ = Hashtbl.add macro2utf8 "mdash" "\226\128\148"
+let _ = Hashtbl.add macro2utf8 "Verbar" "\226\128\150"
+let _ = Hashtbl.add macro2utf8 "die" "\194\168"
+let _ = Hashtbl.add macro2utf8 "veebar" "\226\138\187"
+let _ = Hashtbl.add macro2utf8 "UpArrowBar" "\226\164\146"
+let _ = Hashtbl.add macro2utf8 "Ncaron" "\197\135"
+let _ = Hashtbl.add macro2utf8 "RightArrowBar" "\226\135\165"
+let _ = Hashtbl.add macro2utf8 "LongLeftArrow" "\239\149\182"
+let _ = Hashtbl.add macro2utf8 "rceil" "\226\140\137"
+let _ = Hashtbl.add macro2utf8 "rceil" "\226\140\137"
+let _ = Hashtbl.add macro2utf8 "LeftDownVectorBar" "\226\165\153"
+let _ = Hashtbl.add macro2utf8 "umacr" "\197\171"
+let _ = Hashtbl.add macro2utf8 "Hacek" "\203\135"
+let _ = Hashtbl.add macro2utf8 "odblac" "\197\145"
+let _ = Hashtbl.add macro2utf8 "lmidot" "\197\128"
+let _ = Hashtbl.add macro2utf8 "dopf" "\240\157\149\149"
+let _ = Hashtbl.add macro2utf8 "boxhd" "\226\148\172"
let _ = Hashtbl.add macro2utf8 "dim" "dim"
-let _ = Hashtbl.add macro2utf8 "vnsub" "â\138\132"
-let _ = Hashtbl.add macro2utf8 "Bscr" "â\132¬"
-let _ = Hashtbl.add macro2utf8 "plussim" "⨦"
-let _ = Hashtbl.add macro2utf8 "doublebarwedge" "â\140\134"
-let _ = Hashtbl.add macro2utf8 "nu" "ν"
-let _ = Hashtbl.add macro2utf8 "nu" "ν"
-let _ = Hashtbl.add macro2utf8 "eqcolon" "â\137\149"
-let _ = Hashtbl.add macro2utf8 "luruhar" "⥦"
-let _ = Hashtbl.add macro2utf8 "Nfr" "ð\157\148\145"
-let _ = Hashtbl.add macro2utf8 "preceq" "⪯"
-let _ = Hashtbl.add macro2utf8 "preceq" "⪯"
-let _ = Hashtbl.add macro2utf8 "div" "÷"
-let _ = Hashtbl.add macro2utf8 "LeftTee" "â\138£"
-let _ = Hashtbl.add macro2utf8 "div" "÷"
-let _ = Hashtbl.add macro2utf8 "nVDash" "â\138¯"
-let _ = Hashtbl.add macro2utf8 "kopf" "ð\157\149\156"
-let _ = Hashtbl.add macro2utf8 "Iscr" "â\132\144"
-let _ = Hashtbl.add macro2utf8 "vnsup" "â\138\133"
-let _ = Hashtbl.add macro2utf8 "gneq" "â\137©"
-let _ = Hashtbl.add macro2utf8 "backepsilon" "϶"
-let _ = Hashtbl.add macro2utf8 "boxhu" "â\148´"
-let _ = Hashtbl.add macro2utf8 "ominus" "â\138\150"
-let _ = Hashtbl.add macro2utf8 "ominus" "â\138\150"
-let _ = Hashtbl.add macro2utf8 "or" "â\136¨"
-let _ = Hashtbl.add macro2utf8 "lesdot" "⩿"
-let _ = Hashtbl.add macro2utf8 "RightVectorBar" "â¥\147"
-let _ = Hashtbl.add macro2utf8 "tcedil" "ţ"
-let _ = Hashtbl.add macro2utf8 "hstrok" "ħ"
-let _ = Hashtbl.add macro2utf8 "nrarrc" "⤳̸"
-let _ = Hashtbl.add macro2utf8 "ropf" "ð\157\149£"
-let _ = Hashtbl.add macro2utf8 "diamond" "â\139\132"
-let _ = Hashtbl.add macro2utf8 "diamond" "â\139\132"
-let _ = Hashtbl.add macro2utf8 "smid" "â\136£ï¸\128"
-let _ = Hashtbl.add macro2utf8 "nltri" "â\139ª"
-let _ = Hashtbl.add macro2utf8 "Pscr" "ð\157\146«"
-let _ = Hashtbl.add macro2utf8 "vartheta" "Ï\145"
-let _ = Hashtbl.add macro2utf8 "vartheta" "Ï\145"
-let _ = Hashtbl.add macro2utf8 "therefore" "â\136´"
-let _ = Hashtbl.add macro2utf8 "pi" "Ï\128"
-let _ = Hashtbl.add macro2utf8 "pi" "Ï\128"
-let _ = Hashtbl.add macro2utf8 "ntrianglelefteq" "â\139¬"
-let _ = Hashtbl.add macro2utf8 "nearrow" "â\134\151"
-let _ = Hashtbl.add macro2utf8 "nearrow" "â\134\151"
-let _ = Hashtbl.add macro2utf8 "pm" "±"
-let _ = Hashtbl.add macro2utf8 "natural" "â\153®"
-let _ = Hashtbl.add macro2utf8 "pm" "±"
-let _ = Hashtbl.add macro2utf8 "natural" "â\153®"
-let _ = Hashtbl.add macro2utf8 "ucy" "Ñ\131"
-let _ = Hashtbl.add macro2utf8 "olt" "â§\128"
-let _ = Hashtbl.add macro2utf8 "Cfr" "â\132"
-let _ = Hashtbl.add macro2utf8 "yopf" "ð\157\149ª"
-let _ = Hashtbl.add macro2utf8 "Otilde" "Ã\149"
-let _ = Hashtbl.add macro2utf8 "ntriangleleft" "â\139ª"
-let _ = Hashtbl.add macro2utf8 "pr" "â\137º"
-let _ = Hashtbl.add macro2utf8 "Wscr" "ð\157\146²"
-let _ = Hashtbl.add macro2utf8 "midcir" "⫰"
-let _ = Hashtbl.add macro2utf8 "Lacute" "Ĺ"
-let _ = Hashtbl.add macro2utf8 "DoubleDot" "¨"
-let _ = Hashtbl.add macro2utf8 "Tstrok" "Ŧ"
-let _ = Hashtbl.add macro2utf8 "nrarrw" "â\134\157̸"
-let _ = Hashtbl.add macro2utf8 "uArr" "â\135\145"
-let _ = Hashtbl.add macro2utf8 "nLtv" "â\137ªÌ¸ï¸\128"
-let _ = Hashtbl.add macro2utf8 "rangle" "â\140ª"
-let _ = Hashtbl.add macro2utf8 "rangle" "â\140ª"
-let _ = Hashtbl.add macro2utf8 "olcir" "⦾"
-let _ = Hashtbl.add macro2utf8 "Auml" "Ã\132"
-let _ = Hashtbl.add macro2utf8 "Succeeds" "â\137»"
-let _ = Hashtbl.add macro2utf8 "DoubleLongLeftRightArrow" "ï\149»"
-let _ = Hashtbl.add macro2utf8 "TSHcy" "Ð\139"
-let _ = Hashtbl.add macro2utf8 "gammad" "Ï\156"
-let _ = Hashtbl.add macro2utf8 "epsiv" "É\155"
-let _ = Hashtbl.add macro2utf8 "notinva" "â\136\137̸"
-let _ = Hashtbl.add macro2utf8 "notinvb" "â\139·"
-let _ = Hashtbl.add macro2utf8 "eqvparsl" "⧥"
-let _ = Hashtbl.add macro2utf8 "notinvc" "â\139¶"
-let _ = Hashtbl.add macro2utf8 "nsubE" "â\138\136"
-let _ = Hashtbl.add macro2utf8 "supplus" "â«\128"
-let _ = Hashtbl.add macro2utf8 "RightUpDownVector" "â¥\143"
+let _ = Hashtbl.add macro2utf8 "vnsub" "\226\138\132"
+let _ = Hashtbl.add macro2utf8 "Bscr" "\226\132\172"
+let _ = Hashtbl.add macro2utf8 "plussim" "\226\168\166"
+let _ = Hashtbl.add macro2utf8 "doublebarwedge" "\226\140\134"
+let _ = Hashtbl.add macro2utf8 "nu" "\206\189"
+let _ = Hashtbl.add macro2utf8 "nu" "\206\189"
+let _ = Hashtbl.add macro2utf8 "eqcolon" "\226\137\149"
+let _ = Hashtbl.add macro2utf8 "luruhar" "\226\165\166"
+let _ = Hashtbl.add macro2utf8 "Nfr" "\240\157\148\145"
+let _ = Hashtbl.add macro2utf8 "preceq" "\226\170\175"
+let _ = Hashtbl.add macro2utf8 "preceq" "\226\170\175"
+let _ = Hashtbl.add macro2utf8 "div" "\195\183"
+let _ = Hashtbl.add macro2utf8 "LeftTee" "\226\138\163"
+let _ = Hashtbl.add macro2utf8 "div" "\195\183"
+let _ = Hashtbl.add macro2utf8 "nVDash" "\226\138\175"
+let _ = Hashtbl.add macro2utf8 "kopf" "\240\157\149\156"
+let _ = Hashtbl.add macro2utf8 "Iscr" "\226\132\144"
+let _ = Hashtbl.add macro2utf8 "vnsup" "\226\138\133"
+let _ = Hashtbl.add macro2utf8 "gneq" "\226\137\169"
+let _ = Hashtbl.add macro2utf8 "backepsilon" "\207\182"
+let _ = Hashtbl.add macro2utf8 "boxhu" "\226\148\180"
+let _ = Hashtbl.add macro2utf8 "ominus" "\226\138\150"
+let _ = Hashtbl.add macro2utf8 "ominus" "\226\138\150"
+let _ = Hashtbl.add macro2utf8 "or" "\226\136\168"
+let _ = Hashtbl.add macro2utf8 "lesdot" "\226\169\191"
+let _ = Hashtbl.add macro2utf8 "RightVectorBar" "\226\165\147"
+let _ = Hashtbl.add macro2utf8 "tcedil" "\197\163"
+let _ = Hashtbl.add macro2utf8 "hstrok" "\196\167"
+let _ = Hashtbl.add macro2utf8 "nrarrc" "\226\164\179\204\184"
+let _ = Hashtbl.add macro2utf8 "ropf" "\240\157\149\163"
+let _ = Hashtbl.add macro2utf8 "diamond" "\226\139\132"
+let _ = Hashtbl.add macro2utf8 "diamond" "\226\139\132"
+let _ = Hashtbl.add macro2utf8 "smid" "\226\136\163\239\184\128"
+let _ = Hashtbl.add macro2utf8 "nltri" "\226\139\170"
+let _ = Hashtbl.add macro2utf8 "Pscr" "\240\157\146\171"
+let _ = Hashtbl.add macro2utf8 "vartheta" "\207\145"
+let _ = Hashtbl.add macro2utf8 "vartheta" "\207\145"
+let _ = Hashtbl.add macro2utf8 "therefore" "\226\136\180"
+let _ = Hashtbl.add macro2utf8 "pi" "\207\128"
+let _ = Hashtbl.add macro2utf8 "pi" "\207\128"
+let _ = Hashtbl.add macro2utf8 "ntrianglelefteq" "\226\139\172"
+let _ = Hashtbl.add macro2utf8 "nearrow" "\226\134\151"
+let _ = Hashtbl.add macro2utf8 "nearrow" "\226\134\151"
+let _ = Hashtbl.add macro2utf8 "pm" "\194\177"
+let _ = Hashtbl.add macro2utf8 "natural" "\226\153\174"
+let _ = Hashtbl.add macro2utf8 "pm" "\194\177"
+let _ = Hashtbl.add macro2utf8 "natural" "\226\153\174"
+let _ = Hashtbl.add macro2utf8 "ucy" "\209\131"
+let _ = Hashtbl.add macro2utf8 "olt" "\226\167\128"
+let _ = Hashtbl.add macro2utf8 "Cfr" "\226\132\173"
+let _ = Hashtbl.add macro2utf8 "yopf" "\240\157\149\170"
+let _ = Hashtbl.add macro2utf8 "Otilde" "\195\149"
+let _ = Hashtbl.add macro2utf8 "ntriangleleft" "\226\139\170"
+let _ = Hashtbl.add macro2utf8 "pr" "\226\137\186"
+let _ = Hashtbl.add macro2utf8 "Wscr" "\240\157\146\178"
+let _ = Hashtbl.add macro2utf8 "midcir" "\226\171\176"
+let _ = Hashtbl.add macro2utf8 "Lacute" "\196\185"
+let _ = Hashtbl.add macro2utf8 "DoubleDot" "\194\168"
+let _ = Hashtbl.add macro2utf8 "Tstrok" "\197\166"
+let _ = Hashtbl.add macro2utf8 "nrarrw" "\226\134\157\204\184"
+let _ = Hashtbl.add macro2utf8 "uArr" "\226\135\145"
+let _ = Hashtbl.add macro2utf8 "nLtv" "\226\137\170\204\184\239\184\128"
+let _ = Hashtbl.add macro2utf8 "rangle" "\226\140\170"
+let _ = Hashtbl.add macro2utf8 "rangle" "\226\140\170"
+let _ = Hashtbl.add macro2utf8 "olcir" "\226\166\190"
+let _ = Hashtbl.add macro2utf8 "Auml" "\195\132"
+let _ = Hashtbl.add macro2utf8 "Succeeds" "\226\137\187"
+let _ = Hashtbl.add macro2utf8 "DoubleLongLeftRightArrow" "\239\149\187"
+let _ = Hashtbl.add macro2utf8 "TSHcy" "\208\139"
+let _ = Hashtbl.add macro2utf8 "gammad" "\207\156"
+let _ = Hashtbl.add macro2utf8 "epsiv" "\201\155"
+let _ = Hashtbl.add macro2utf8 "notinva" "\226\136\137\204\184"
+let _ = Hashtbl.add macro2utf8 "notinvb" "\226\139\183"
+let _ = Hashtbl.add macro2utf8 "eqvparsl" "\226\167\165"
+let _ = Hashtbl.add macro2utf8 "notinvc" "\226\139\182"
+let _ = Hashtbl.add macro2utf8 "nsubE" "\226\138\136"
+let _ = Hashtbl.add macro2utf8 "supplus" "\226\171\128"
+let _ = Hashtbl.add macro2utf8 "RightUpDownVector" "\226\165\143"
let _ = Hashtbl.add macro2utf8 "Tab" "\t"
-let _ = Hashtbl.add macro2utf8 "Lcedil" "Ļ"
+let _ = Hashtbl.add macro2utf8 "Lcedil" "\196\187"
let _ = Hashtbl.add macro2utf8 "backslash" "\\"
-let _ = Hashtbl.add macro2utf8 "pointint" "â¨\149"
-let _ = Hashtbl.add macro2utf8 "jcy" "й"
-let _ = Hashtbl.add macro2utf8 "iocy" "Ñ\145"
-let _ = Hashtbl.add macro2utf8 "escr" "â\132¯"
-let _ = Hashtbl.add macro2utf8 "submult" "â«\129"
-let _ = Hashtbl.add macro2utf8 "iiota" "â\132©"
-let _ = Hashtbl.add macro2utf8 "lceil" "â\140\136"
-let _ = Hashtbl.add macro2utf8 "lceil" "â\140\136"
-let _ = Hashtbl.add macro2utf8 "omacr" "Å\141"
-let _ = Hashtbl.add macro2utf8 "gneqq" "â\137©"
-let _ = Hashtbl.add macro2utf8 "gcirc" "Ä\157"
-let _ = Hashtbl.add macro2utf8 "dotsquare" "â\138¡"
-let _ = Hashtbl.add macro2utf8 "ccaron" "Ä\141"
-let _ = Hashtbl.add macro2utf8 "Square" "â\150¡"
-let _ = Hashtbl.add macro2utf8 "RightDownTeeVector" "â¥\157"
-let _ = Hashtbl.add macro2utf8 "Ouml" "Ã\150"
-let _ = Hashtbl.add macro2utf8 "lurdshar" "â¥\138"
-let _ = Hashtbl.add macro2utf8 "setminus" "â\136\150"
-let _ = Hashtbl.add macro2utf8 "SuchThat" "â\136\139"
-let _ = Hashtbl.add macro2utf8 "setminus" "â\136\150"
-let _ = Hashtbl.add macro2utf8 "lscr" "â\132\147"
-let _ = Hashtbl.add macro2utf8 "LessLess" "⪡"
-let _ = Hashtbl.add macro2utf8 "Sub" "â\139\144"
-let _ = Hashtbl.add macro2utf8 "sc" "â\137»"
-let _ = Hashtbl.add macro2utf8 "rx" "â\132\158"
-let _ = Hashtbl.add macro2utf8 "RightFloor" "â\140\139"
-let _ = Hashtbl.add macro2utf8 "blacksquare" "â\150ª"
-let _ = Hashtbl.add macro2utf8 "ufr" "ð\157\148²"
-let _ = Hashtbl.add macro2utf8 "block" "â\150\136"
-let _ = Hashtbl.add macro2utf8 "dots" "â\128¦"
-let _ = Hashtbl.add macro2utf8 "nvsim" "â\137\129̸"
-let _ = Hashtbl.add macro2utf8 "caret" "â\129\129"
-let _ = Hashtbl.add macro2utf8 "demptyv" "⦱"
-let _ = Hashtbl.add macro2utf8 "Sum" "â\136\145"
-let _ = Hashtbl.add macro2utf8 "sscr" "ð\157\147\136"
-let _ = Hashtbl.add macro2utf8 "nsube" "â\138\136"
-let _ = Hashtbl.add macro2utf8 "Sup" "â\139\145"
-let _ = Hashtbl.add macro2utf8 "ccupssm" "â©\144"
-let _ = Hashtbl.add macro2utf8 "Because" "â\136µ"
-let _ = Hashtbl.add macro2utf8 "harrcir" "â¥\136"
-let _ = Hashtbl.add macro2utf8 "capbrcup" "â©\137"
-let _ = Hashtbl.add macro2utf8 "RightUpVectorBar" "â¥\148"
-let _ = Hashtbl.add macro2utf8 "caps" "â\136©ï¸\128"
-let _ = Hashtbl.add macro2utf8 "ohbar" "⦵"
-let _ = Hashtbl.add macro2utf8 "laemptyv" "⦴"
-let _ = Hashtbl.add macro2utf8 "uacute" "ú"
-let _ = Hashtbl.add macro2utf8 "straightphi" "Ï\134"
-let _ = Hashtbl.add macro2utf8 "RightDoubleBracket" "ã\128\155"
-let _ = Hashtbl.add macro2utf8 "zscr" "ð\157\147\143"
-let _ = Hashtbl.add macro2utf8 "uogon" "ų"
-let _ = Hashtbl.add macro2utf8 "Uarr" "â\134\159"
-let _ = Hashtbl.add macro2utf8 "nsucc" "â\138\129"
-let _ = Hashtbl.add macro2utf8 "RBarr" "â¤\144"
-let _ = Hashtbl.add macro2utf8 "NotRightTriangleBar" "â§\144̸"
-let _ = Hashtbl.add macro2utf8 "to" "â\134\146"
+let _ = Hashtbl.add macro2utf8 "pointint" "\226\168\149"
+let _ = Hashtbl.add macro2utf8 "jcy" "\208\185"
+let _ = Hashtbl.add macro2utf8 "iocy" "\209\145"
+let _ = Hashtbl.add macro2utf8 "escr" "\226\132\175"
+let _ = Hashtbl.add macro2utf8 "submult" "\226\171\129"
+let _ = Hashtbl.add macro2utf8 "iiota" "\226\132\169"
+let _ = Hashtbl.add macro2utf8 "lceil" "\226\140\136"
+let _ = Hashtbl.add macro2utf8 "lceil" "\226\140\136"
+let _ = Hashtbl.add macro2utf8 "omacr" "\197\141"
+let _ = Hashtbl.add macro2utf8 "gneqq" "\226\137\169"
+let _ = Hashtbl.add macro2utf8 "gcirc" "\196\157"
+let _ = Hashtbl.add macro2utf8 "dotsquare" "\226\138\161"
+let _ = Hashtbl.add macro2utf8 "ccaron" "\196\141"
+let _ = Hashtbl.add macro2utf8 "Square" "\226\150\161"
+let _ = Hashtbl.add macro2utf8 "RightDownTeeVector" "\226\165\157"
+let _ = Hashtbl.add macro2utf8 "Ouml" "\195\150"
+let _ = Hashtbl.add macro2utf8 "lurdshar" "\226\165\138"
+let _ = Hashtbl.add macro2utf8 "setminus" "\226\136\150"
+let _ = Hashtbl.add macro2utf8 "SuchThat" "\226\136\139"
+let _ = Hashtbl.add macro2utf8 "setminus" "\226\136\150"
+let _ = Hashtbl.add macro2utf8 "lscr" "\226\132\147"
+let _ = Hashtbl.add macro2utf8 "LessLess" "\226\170\161"
+let _ = Hashtbl.add macro2utf8 "Sub" "\226\139\144"
+let _ = Hashtbl.add macro2utf8 "sc" "\226\137\187"
+let _ = Hashtbl.add macro2utf8 "rx" "\226\132\158"
+let _ = Hashtbl.add macro2utf8 "RightFloor" "\226\140\139"
+let _ = Hashtbl.add macro2utf8 "blacksquare" "\226\150\170"
+let _ = Hashtbl.add macro2utf8 "ufr" "\240\157\148\178"
+let _ = Hashtbl.add macro2utf8 "block" "\226\150\136"
+let _ = Hashtbl.add macro2utf8 "dots" "\226\128\166"
+let _ = Hashtbl.add macro2utf8 "nvsim" "\226\137\129\204\184"
+let _ = Hashtbl.add macro2utf8 "caret" "\226\129\129"
+let _ = Hashtbl.add macro2utf8 "demptyv" "\226\166\177"
+let _ = Hashtbl.add macro2utf8 "Sum" "\226\136\145"
+let _ = Hashtbl.add macro2utf8 "sscr" "\240\157\147\136"
+let _ = Hashtbl.add macro2utf8 "nsube" "\226\138\136"
+let _ = Hashtbl.add macro2utf8 "Sup" "\226\139\145"
+let _ = Hashtbl.add macro2utf8 "ccupssm" "\226\169\144"
+let _ = Hashtbl.add macro2utf8 "Because" "\226\136\181"
+let _ = Hashtbl.add macro2utf8 "harrcir" "\226\165\136"
+let _ = Hashtbl.add macro2utf8 "capbrcup" "\226\169\137"
+let _ = Hashtbl.add macro2utf8 "RightUpVectorBar" "\226\165\148"
+let _ = Hashtbl.add macro2utf8 "caps" "\226\136\169\239\184\128"
+let _ = Hashtbl.add macro2utf8 "ohbar" "\226\166\181"
+let _ = Hashtbl.add macro2utf8 "laemptyv" "\226\166\180"
+let _ = Hashtbl.add macro2utf8 "uacute" "\195\186"
+let _ = Hashtbl.add macro2utf8 "straightphi" "\207\134"
+let _ = Hashtbl.add macro2utf8 "RightDoubleBracket" "\227\128\155"
+let _ = Hashtbl.add macro2utf8 "zscr" "\240\157\147\143"
+let _ = Hashtbl.add macro2utf8 "uogon" "\197\179"
+let _ = Hashtbl.add macro2utf8 "Uarr" "\226\134\159"
+let _ = Hashtbl.add macro2utf8 "nsucc" "\226\138\129"
+let _ = Hashtbl.add macro2utf8 "RBarr" "\226\164\144"
+let _ = Hashtbl.add macro2utf8 "NotRightTriangleBar" "\226\167\144\204\184"
+let _ = Hashtbl.add macro2utf8 "to" "\226\134\146"
let _ = Hashtbl.add macro2utf8 "rpar" ")"
-let _ = Hashtbl.add macro2utf8 "rdsh" "â\134³"
-let _ = Hashtbl.add macro2utf8 "jfr" "ð\157\148§"
-let _ = Hashtbl.add macro2utf8 "ldquor" "â\128\158"
-let _ = Hashtbl.add macro2utf8 "bsime" "â\139\141"
-let _ = Hashtbl.add macro2utf8 "lAtail" "â¤\155"
-let _ = Hashtbl.add macro2utf8 "Hcirc" "Ĥ"
-let _ = Hashtbl.add macro2utf8 "aacute" "á"
-let _ = Hashtbl.add macro2utf8 "dot" "Ë\153"
-let _ = Hashtbl.add macro2utf8 "Tcy" "Т"
-let _ = Hashtbl.add macro2utf8 "nsub" "â\138\132"
-let _ = Hashtbl.add macro2utf8 "kappa" "κ"
-let _ = Hashtbl.add macro2utf8 "kappa" "κ"
-let _ = Hashtbl.add macro2utf8 "ovbar" "â\140½"
-let _ = Hashtbl.add macro2utf8 "shcy" "Ñ\136"
-let _ = Hashtbl.add macro2utf8 "kappav" "ϰ"
-let _ = Hashtbl.add macro2utf8 "ropar" "ã\128\153"
-let _ = Hashtbl.add macro2utf8 "gtcc" "⪧"
-let _ = Hashtbl.add macro2utf8 "ecolon" "â\137\149"
-let _ = Hashtbl.add macro2utf8 "circledast" "â\138\155"
+let _ = Hashtbl.add macro2utf8 "rdsh" "\226\134\179"
+let _ = Hashtbl.add macro2utf8 "jfr" "\240\157\148\167"
+let _ = Hashtbl.add macro2utf8 "ldquor" "\226\128\158"
+let _ = Hashtbl.add macro2utf8 "bsime" "\226\139\141"
+let _ = Hashtbl.add macro2utf8 "lAtail" "\226\164\155"
+let _ = Hashtbl.add macro2utf8 "Hcirc" "\196\164"
+let _ = Hashtbl.add macro2utf8 "aacute" "\195\161"
+let _ = Hashtbl.add macro2utf8 "dot" "\203\153"
+let _ = Hashtbl.add macro2utf8 "Tcy" "\208\162"
+let _ = Hashtbl.add macro2utf8 "nsub" "\226\138\132"
+let _ = Hashtbl.add macro2utf8 "kappa" "\206\186"
+let _ = Hashtbl.add macro2utf8 "kappa" "\206\186"
+let _ = Hashtbl.add macro2utf8 "ovbar" "\226\140\189"
+let _ = Hashtbl.add macro2utf8 "shcy" "\209\136"
+let _ = Hashtbl.add macro2utf8 "kappav" "\207\176"
+let _ = Hashtbl.add macro2utf8 "ropar" "\227\128\153"
+let _ = Hashtbl.add macro2utf8 "gtcc" "\226\170\167"
+let _ = Hashtbl.add macro2utf8 "ecolon" "\226\137\149"
+let _ = Hashtbl.add macro2utf8 "circledast" "\226\138\155"
let _ = Hashtbl.add macro2utf8 "colon" ":"
-let _ = Hashtbl.add macro2utf8 "timesbar" "⨱"
-let _ = Hashtbl.add macro2utf8 "precnsim" "â\139¨"
-let _ = Hashtbl.add macro2utf8 "ord" "â©\157"
-let _ = Hashtbl.add macro2utf8 "real" "â\132\156"
-let _ = Hashtbl.add macro2utf8 "nexists" "â\136\132"
-let _ = Hashtbl.add macro2utf8 "nsup" "â\138\133"
-let _ = Hashtbl.add macro2utf8 "zhcy" "ж"
-let _ = Hashtbl.add macro2utf8 "imacr" "ī"
-let _ = Hashtbl.add macro2utf8 "egrave" "è"
-let _ = Hashtbl.add macro2utf8 "acirc" "â"
+let _ = Hashtbl.add macro2utf8 "timesbar" "\226\168\177"
+let _ = Hashtbl.add macro2utf8 "precnsim" "\226\139\168"
+let _ = Hashtbl.add macro2utf8 "ord" "\226\169\157"
+let _ = Hashtbl.add macro2utf8 "real" "\226\132\156"
+let _ = Hashtbl.add macro2utf8 "nexists" "\226\136\132"
+let _ = Hashtbl.add macro2utf8 "nsup" "\226\138\133"
+let _ = Hashtbl.add macro2utf8 "zhcy" "\208\182"
+let _ = Hashtbl.add macro2utf8 "imacr" "\196\171"
+let _ = Hashtbl.add macro2utf8 "egrave" "\195\168"
+let _ = Hashtbl.add macro2utf8 "acirc" "\195\162"
let _ = Hashtbl.add macro2utf8 "grave" "`"
-let _ = Hashtbl.add macro2utf8 "biguplus" "â\138\142"
-let _ = Hashtbl.add macro2utf8 "biguplus" "â\138\142"
-let _ = Hashtbl.add macro2utf8 "HumpEqual" "â\137\143"
-let _ = Hashtbl.add macro2utf8 "GreaterSlantEqual" "⩾"
-let _ = Hashtbl.add macro2utf8 "capand" "â©\132"
-let _ = Hashtbl.add macro2utf8 "yuml" "ÿ"
-let _ = Hashtbl.add macro2utf8 "orv" "â©\155"
-let _ = Hashtbl.add macro2utf8 "Icy" "Ð\152"
-let _ = Hashtbl.add macro2utf8 "rightharpoondown" "â\135\129"
-let _ = Hashtbl.add macro2utf8 "upsilon" "Ï\133"
-let _ = Hashtbl.add macro2utf8 "upsilon" "Ï\133"
-let _ = Hashtbl.add macro2utf8 "preccurlyeq" "â\137¼"
-let _ = Hashtbl.add macro2utf8 "ShortUpArrow" "â\140\131ï¸\128"
-let _ = Hashtbl.add macro2utf8 "searhk" "⤥"
+let _ = Hashtbl.add macro2utf8 "biguplus" "\226\138\142"
+let _ = Hashtbl.add macro2utf8 "biguplus" "\226\138\142"
+let _ = Hashtbl.add macro2utf8 "HumpEqual" "\226\137\143"
+let _ = Hashtbl.add macro2utf8 "GreaterSlantEqual" "\226\169\190"
+let _ = Hashtbl.add macro2utf8 "capand" "\226\169\132"
+let _ = Hashtbl.add macro2utf8 "yuml" "\195\191"
+let _ = Hashtbl.add macro2utf8 "orv" "\226\169\155"
+let _ = Hashtbl.add macro2utf8 "Icy" "\208\152"
+let _ = Hashtbl.add macro2utf8 "rightharpoondown" "\226\135\129"
+let _ = Hashtbl.add macro2utf8 "upsilon" "\207\133"
+let _ = Hashtbl.add macro2utf8 "upsilon" "\207\133"
+let _ = Hashtbl.add macro2utf8 "preccurlyeq" "\226\137\188"
+let _ = Hashtbl.add macro2utf8 "ShortUpArrow" "\226\140\131\239\184\128"
+let _ = Hashtbl.add macro2utf8 "searhk" "\226\164\165"
let _ = Hashtbl.add macro2utf8 "commat" "@"
-let _ = Hashtbl.add macro2utf8 "Sqrt" "â\136\154"
-let _ = Hashtbl.add macro2utf8 "wp" "â\132\152"
-let _ = Hashtbl.add macro2utf8 "wp" "â\132\152"
-let _ = Hashtbl.add macro2utf8 "succnapprox" "â\139©"
-let _ = Hashtbl.add macro2utf8 "wr" "â\137\128"
-let _ = Hashtbl.add macro2utf8 "wr" "â\137\128"
-let _ = Hashtbl.add macro2utf8 "NotTildeTilde" "â\137\137"
-let _ = Hashtbl.add macro2utf8 "dcaron" "Ä\143"
-let _ = Hashtbl.add macro2utf8 "bigwedge" "â\139\128"
-let _ = Hashtbl.add macro2utf8 "Tfr" "ð\157\148\151"
-let _ = Hashtbl.add macro2utf8 "bigwedge" "â\139\128"
-let _ = Hashtbl.add macro2utf8 "DScy" "Ð\133"
-let _ = Hashtbl.add macro2utf8 "nrtrie" "â\139"
-let _ = Hashtbl.add macro2utf8 "esim" "â\137\130"
-let _ = Hashtbl.add macro2utf8 "Not" "⫬"
-let _ = Hashtbl.add macro2utf8 "xmap" "ï\149½"
-let _ = Hashtbl.add macro2utf8 "rect" "â\150"
-let _ = Hashtbl.add macro2utf8 "Fouriertrf" "â\132±"
-let _ = Hashtbl.add macro2utf8 "xi" "ξ"
-let _ = Hashtbl.add macro2utf8 "xi" "ξ"
-let _ = Hashtbl.add macro2utf8 "NotTilde" "â\137\129"
-let _ = Hashtbl.add macro2utf8 "gbreve" "Ä\159"
-let _ = Hashtbl.add macro2utf8 "par" "â\136¥"
-let _ = Hashtbl.add macro2utf8 "ddots" "â\139±"
-let _ = Hashtbl.add macro2utf8 "nhArr" "â\135\142"
-let _ = Hashtbl.add macro2utf8 "lsim" "â\137²"
-let _ = Hashtbl.add macro2utf8 "RightCeiling" "â\140\137"
-let _ = Hashtbl.add macro2utf8 "nedot" "â\137 ï¸\128"
-let _ = Hashtbl.add macro2utf8 "thksim" "â\136¼ï¸\128"
-let _ = Hashtbl.add macro2utf8 "lEg" "â\139\154"
-let _ = Hashtbl.add macro2utf8 "Ifr" "â\132\145"
-let _ = Hashtbl.add macro2utf8 "emsp" "â\128\131"
-let _ = Hashtbl.add macro2utf8 "lopar" "ã\128\152"
-let _ = Hashtbl.add macro2utf8 "iiiint" "â¨\140"
-let _ = Hashtbl.add macro2utf8 "straightepsilon" "ε"
-let _ = Hashtbl.add macro2utf8 "intlarhk" "â¨\151"
-let _ = Hashtbl.add macro2utf8 "image" "â\132\145"
-let _ = Hashtbl.add macro2utf8 "Leftrightarrow" "â\135\148"
-let _ = Hashtbl.add macro2utf8 "sqsubseteq" "â\138\145"
-let _ = Hashtbl.add macro2utf8 "lnapprox" "âª\137"
-let _ = Hashtbl.add macro2utf8 "Leftrightarrow" "â\135\148"
-let _ = Hashtbl.add macro2utf8 "cemptyv" "⦲"
-let _ = Hashtbl.add macro2utf8 "alpha" "α"
-let _ = Hashtbl.add macro2utf8 "alpha" "α"
-let _ = Hashtbl.add macro2utf8 "uml" "¨"
-let _ = Hashtbl.add macro2utf8 "barwedge" "â\138¼"
-let _ = Hashtbl.add macro2utf8 "KHcy" "Х"
-let _ = Hashtbl.add macro2utf8 "tilde" "Ë\156"
-let _ = Hashtbl.add macro2utf8 "Superset" "â\138\131"
-let _ = Hashtbl.add macro2utf8 "bigoplus" "â\138\149"
-let _ = Hashtbl.add macro2utf8 "gesles" "âª\148"
-let _ = Hashtbl.add macro2utf8 "bigoplus" "â\138\149"
-let _ = Hashtbl.add macro2utf8 "boxuL" "â\149\155"
-let _ = Hashtbl.add macro2utf8 "rbbrk" "ã\128\149"
-let _ = Hashtbl.add macro2utf8 "nrightarrow" "â\134\155"
-let _ = Hashtbl.add macro2utf8 "hkswarow" "⤦"
-let _ = Hashtbl.add macro2utf8 "DiacriticalDoubleAcute" "Ë\157"
-let _ = Hashtbl.add macro2utf8 "nbumpe" "â\137\143̸"
-let _ = Hashtbl.add macro2utf8 "uhblk" "â\150\128"
-let _ = Hashtbl.add macro2utf8 "NotSupersetEqual" "â\138\137"
-let _ = Hashtbl.add macro2utf8 "ntgl" "â\137¹"
-let _ = Hashtbl.add macro2utf8 "Fopf" "ð\157\148½"
-let _ = Hashtbl.add macro2utf8 "boxuR" "â\149\152"
-let _ = Hashtbl.add macro2utf8 "swarr" "â\134\153"
-let _ = Hashtbl.add macro2utf8 "nsqsube" "â\139¢"
-let _ = Hashtbl.add macro2utf8 "pluscir" "⨢"
-let _ = Hashtbl.add macro2utf8 "pcy" "п"
-let _ = Hashtbl.add macro2utf8 "leqslant" "⩽"
-let _ = Hashtbl.add macro2utf8 "lnap" "âª\137"
-let _ = Hashtbl.add macro2utf8 "lthree" "â\139\139"
-let _ = Hashtbl.add macro2utf8 "smte" "⪬"
-let _ = Hashtbl.add macro2utf8 "olcross" "⦻"
-let _ = Hashtbl.add macro2utf8 "nvrArr" "â\135\143"
-let _ = Hashtbl.add macro2utf8 "andslope" "â©\152"
-let _ = Hashtbl.add macro2utf8 "MediumSpace" "â\129\159"
-let _ = Hashtbl.add macro2utf8 "boxvH" "â\149ª"
-let _ = Hashtbl.add macro2utf8 "Nacute" "Å\131"
-let _ = Hashtbl.add macro2utf8 "nGtv" "â\137«Ì¸ï¸\128"
-let _ = Hashtbl.add macro2utf8 "Mopf" "ð\157\149\132"
-let _ = Hashtbl.add macro2utf8 "dfisht" "⥿"
-let _ = Hashtbl.add macro2utf8 "boxvL" "â\149¡"
-let _ = Hashtbl.add macro2utf8 "pertenk" "â\128±"
-let _ = Hashtbl.add macro2utf8 "NotPrecedes" "â\138\128"
-let _ = Hashtbl.add macro2utf8 "profalar" "â\140®"
-let _ = Hashtbl.add macro2utf8 "roplus" "⨮"
-let _ = Hashtbl.add macro2utf8 "boxvR" "â\149\158"
-let _ = Hashtbl.add macro2utf8 "utrif" "â\150´"
-let _ = Hashtbl.add macro2utf8 "uHar" "⥣"
-let _ = Hashtbl.add macro2utf8 "nltrie" "â\139¬"
-let _ = Hashtbl.add macro2utf8 "NotNestedGreaterGreater" "â\146¢Ì¸"
-let _ = Hashtbl.add macro2utf8 "smtes" "⪬ï¸\128"
-let _ = Hashtbl.add macro2utf8 "LeftAngleBracket" "â\140©"
-let _ = Hashtbl.add macro2utf8 "iogon" "į"
-let _ = Hashtbl.add macro2utf8 "ExponentialE" "â\133\135"
-let _ = Hashtbl.add macro2utf8 "Topf" "ð\157\149\139"
-let _ = Hashtbl.add macro2utf8 "GreaterEqual" "â\137¥"
-let _ = Hashtbl.add macro2utf8 "DownTee" "â\138¤"
-let _ = Hashtbl.add macro2utf8 "boxul" "â\148\152"
-let _ = Hashtbl.add macro2utf8 "wreath" "â\137\128"
-let _ = Hashtbl.add macro2utf8 "sigma" "Ï\131"
-let _ = Hashtbl.add macro2utf8 "sigma" "Ï\131"
-let _ = Hashtbl.add macro2utf8 "ENG" "Å\138"
-let _ = Hashtbl.add macro2utf8 "Ncedil" "Å\133"
-let _ = Hashtbl.add macro2utf8 "ecy" "Ñ\141"
-let _ = Hashtbl.add macro2utf8 "nsubset" "â\138\132"
-let _ = Hashtbl.add macro2utf8 "LessFullEqual" "â\137¦"
-let _ = Hashtbl.add macro2utf8 "bsolb" "â§\133"
-let _ = Hashtbl.add macro2utf8 "boxur" "â\148\148"
-let _ = Hashtbl.add macro2utf8 "ThinSpace" "â\128\137"
-let _ = Hashtbl.add macro2utf8 "supdsub" "â«\152"
-let _ = Hashtbl.add macro2utf8 "colone" "â\137\148"
-let _ = Hashtbl.add macro2utf8 "curren" "¤"
-let _ = Hashtbl.add macro2utf8 "boxvh" "â\148¼"
-let _ = Hashtbl.add macro2utf8 "ecaron" "Ä\155"
-let _ = Hashtbl.add macro2utf8 "UnderBrace" "︸"
-let _ = Hashtbl.add macro2utf8 "caron" "Ë\135"
-let _ = Hashtbl.add macro2utf8 "ultri" "â\151¸"
-let _ = Hashtbl.add macro2utf8 "boxvl" "â\148¤"
-let _ = Hashtbl.add macro2utf8 "scap" "â\137¿"
-let _ = Hashtbl.add macro2utf8 "boxvr" "â\148\156"
-let _ = Hashtbl.add macro2utf8 "bopf" "ð\157\149\147"
-let _ = Hashtbl.add macro2utf8 "pfr" "ð\157\148"
-let _ = Hashtbl.add macro2utf8 "nspar" "â\136¦ï¸\128"
-let _ = Hashtbl.add macro2utf8 "NegativeMediumSpace" "â\129\159ï¸\128"
-let _ = Hashtbl.add macro2utf8 "simgE" "⪠"
-let _ = Hashtbl.add macro2utf8 "nvDash" "â\138"
-let _ = Hashtbl.add macro2utf8 "NotGreaterFullEqual" "â\137°"
-let _ = Hashtbl.add macro2utf8 "uparrow" "â\134\145"
-let _ = Hashtbl.add macro2utf8 "uparrow" "â\134\145"
-let _ = Hashtbl.add macro2utf8 "nsupset" "â\138\133"
-let _ = Hashtbl.add macro2utf8 "simeq" "â\137\131"
-let _ = Hashtbl.add macro2utf8 "simeq" "â\137\131"
-let _ = Hashtbl.add macro2utf8 "Zcy" "Ð\151"
-let _ = Hashtbl.add macro2utf8 "RightTriangle" "â\138³"
-let _ = Hashtbl.add macro2utf8 "Lang" "ã\128\138"
-let _ = Hashtbl.add macro2utf8 "Ucirc" "Ã\155"
-let _ = Hashtbl.add macro2utf8 "iopf" "ð\157\149\154"
-let _ = Hashtbl.add macro2utf8 "leftrightsquigarrow" "â\134"
-let _ = Hashtbl.add macro2utf8 "Gscr" "ð\157\146¢"
-let _ = Hashtbl.add macro2utf8 "lfloor" "â\140\138"
-let _ = Hashtbl.add macro2utf8 "lfloor" "â\140\138"
-let _ = Hashtbl.add macro2utf8 "lbbrk" "ã\128\148"
-let _ = Hashtbl.add macro2utf8 "bigvee" "â\139\129"
-let _ = Hashtbl.add macro2utf8 "bigvee" "â\139\129"
-let _ = Hashtbl.add macro2utf8 "ordf" "ª"
-let _ = Hashtbl.add macro2utf8 "rsquo" "â\128\153"
-let _ = Hashtbl.add macro2utf8 "parallel" "â\136¥"
-let _ = Hashtbl.add macro2utf8 "half" "½"
-let _ = Hashtbl.add macro2utf8 "supseteq" "â\138\135"
-let _ = Hashtbl.add macro2utf8 "supseteq" "â\138\135"
-let _ = Hashtbl.add macro2utf8 "ngeqq" "â\137±"
-let _ = Hashtbl.add macro2utf8 "popf" "ð\157\149¡"
-let _ = Hashtbl.add macro2utf8 "NonBreakingSpace" " "
-let _ = Hashtbl.add macro2utf8 "softcy" "Ñ\140"
-let _ = Hashtbl.add macro2utf8 "ordm" "º"
-let _ = Hashtbl.add macro2utf8 "Nscr" "ð\157\146©"
-let _ = Hashtbl.add macro2utf8 "owns" "â\136\139"
-let _ = Hashtbl.add macro2utf8 "phi" "Ï\149"
-let _ = Hashtbl.add macro2utf8 "phi" "Ï\134"
-let _ = Hashtbl.add macro2utf8 "efr" "ð\157\148¢"
-let _ = Hashtbl.add macro2utf8 "nesear" "⤨"
-let _ = Hashtbl.add macro2utf8 "marker" "â\150®"
-let _ = Hashtbl.add macro2utf8 "lneq" "â\137¨"
+let _ = Hashtbl.add macro2utf8 "Sqrt" "\226\136\154"
+let _ = Hashtbl.add macro2utf8 "wp" "\226\132\152"
+let _ = Hashtbl.add macro2utf8 "wp" "\226\132\152"
+let _ = Hashtbl.add macro2utf8 "succnapprox" "\226\139\169"
+let _ = Hashtbl.add macro2utf8 "wr" "\226\137\128"
+let _ = Hashtbl.add macro2utf8 "wr" "\226\137\128"
+let _ = Hashtbl.add macro2utf8 "NotTildeTilde" "\226\137\137"
+let _ = Hashtbl.add macro2utf8 "dcaron" "\196\143"
+let _ = Hashtbl.add macro2utf8 "bigwedge" "\226\139\128"
+let _ = Hashtbl.add macro2utf8 "Tfr" "\240\157\148\151"
+let _ = Hashtbl.add macro2utf8 "bigwedge" "\226\139\128"
+let _ = Hashtbl.add macro2utf8 "DScy" "\208\133"
+let _ = Hashtbl.add macro2utf8 "nrtrie" "\226\139\173"
+let _ = Hashtbl.add macro2utf8 "esim" "\226\137\130"
+let _ = Hashtbl.add macro2utf8 "Not" "\226\171\172"
+let _ = Hashtbl.add macro2utf8 "xmap" "\239\149\189"
+let _ = Hashtbl.add macro2utf8 "rect" "\226\150\173"
+let _ = Hashtbl.add macro2utf8 "Fouriertrf" "\226\132\177"
+let _ = Hashtbl.add macro2utf8 "xi" "\206\190"
+let _ = Hashtbl.add macro2utf8 "xi" "\206\190"
+let _ = Hashtbl.add macro2utf8 "NotTilde" "\226\137\129"
+let _ = Hashtbl.add macro2utf8 "gbreve" "\196\159"
+let _ = Hashtbl.add macro2utf8 "par" "\226\136\165"
+let _ = Hashtbl.add macro2utf8 "ddots" "\226\139\177"
+let _ = Hashtbl.add macro2utf8 "nhArr" "\226\135\142"
+let _ = Hashtbl.add macro2utf8 "lsim" "\226\137\178"
+let _ = Hashtbl.add macro2utf8 "RightCeiling" "\226\140\137"
+let _ = Hashtbl.add macro2utf8 "nedot" "\226\137\160\239\184\128"
+let _ = Hashtbl.add macro2utf8 "thksim" "\226\136\188\239\184\128"
+let _ = Hashtbl.add macro2utf8 "lEg" "\226\139\154"
+let _ = Hashtbl.add macro2utf8 "Ifr" "\226\132\145"
+let _ = Hashtbl.add macro2utf8 "emsp" "\226\128\131"
+let _ = Hashtbl.add macro2utf8 "lopar" "\227\128\152"
+let _ = Hashtbl.add macro2utf8 "iiiint" "\226\168\140"
+let _ = Hashtbl.add macro2utf8 "straightepsilon" "\206\181"
+let _ = Hashtbl.add macro2utf8 "intlarhk" "\226\168\151"
+let _ = Hashtbl.add macro2utf8 "image" "\226\132\145"
+let _ = Hashtbl.add macro2utf8 "Leftrightarrow" "\226\135\148"
+let _ = Hashtbl.add macro2utf8 "sqsubseteq" "\226\138\145"
+let _ = Hashtbl.add macro2utf8 "lnapprox" "\226\170\137"
+let _ = Hashtbl.add macro2utf8 "Leftrightarrow" "\226\135\148"
+let _ = Hashtbl.add macro2utf8 "cemptyv" "\226\166\178"
+let _ = Hashtbl.add macro2utf8 "alpha" "\206\177"
+let _ = Hashtbl.add macro2utf8 "alpha" "\206\177"
+let _ = Hashtbl.add macro2utf8 "uml" "\194\168"
+let _ = Hashtbl.add macro2utf8 "barwedge" "\226\138\188"
+let _ = Hashtbl.add macro2utf8 "KHcy" "\208\165"
+let _ = Hashtbl.add macro2utf8 "tilde" "\203\156"
+let _ = Hashtbl.add macro2utf8 "Superset" "\226\138\131"
+let _ = Hashtbl.add macro2utf8 "bigoplus" "\226\138\149"
+let _ = Hashtbl.add macro2utf8 "gesles" "\226\170\148"
+let _ = Hashtbl.add macro2utf8 "bigoplus" "\226\138\149"
+let _ = Hashtbl.add macro2utf8 "boxuL" "\226\149\155"
+let _ = Hashtbl.add macro2utf8 "rbbrk" "\227\128\149"
+let _ = Hashtbl.add macro2utf8 "nrightarrow" "\226\134\155"
+let _ = Hashtbl.add macro2utf8 "hkswarow" "\226\164\166"
+let _ = Hashtbl.add macro2utf8 "DiacriticalDoubleAcute" "\203\157"
+let _ = Hashtbl.add macro2utf8 "nbumpe" "\226\137\143\204\184"
+let _ = Hashtbl.add macro2utf8 "uhblk" "\226\150\128"
+let _ = Hashtbl.add macro2utf8 "NotSupersetEqual" "\226\138\137"
+let _ = Hashtbl.add macro2utf8 "ntgl" "\226\137\185"
+let _ = Hashtbl.add macro2utf8 "Fopf" "\240\157\148\189"
+let _ = Hashtbl.add macro2utf8 "boxuR" "\226\149\152"
+let _ = Hashtbl.add macro2utf8 "swarr" "\226\134\153"
+let _ = Hashtbl.add macro2utf8 "nsqsube" "\226\139\162"
+let _ = Hashtbl.add macro2utf8 "pluscir" "\226\168\162"
+let _ = Hashtbl.add macro2utf8 "pcy" "\208\191"
+let _ = Hashtbl.add macro2utf8 "leqslant" "\226\169\189"
+let _ = Hashtbl.add macro2utf8 "lnap" "\226\170\137"
+let _ = Hashtbl.add macro2utf8 "lthree" "\226\139\139"
+let _ = Hashtbl.add macro2utf8 "smte" "\226\170\172"
+let _ = Hashtbl.add macro2utf8 "olcross" "\226\166\187"
+let _ = Hashtbl.add macro2utf8 "nvrArr" "\226\135\143"
+let _ = Hashtbl.add macro2utf8 "andslope" "\226\169\152"
+let _ = Hashtbl.add macro2utf8 "MediumSpace" "\226\129\159"
+let _ = Hashtbl.add macro2utf8 "boxvH" "\226\149\170"
+let _ = Hashtbl.add macro2utf8 "Nacute" "\197\131"
+let _ = Hashtbl.add macro2utf8 "nGtv" "\226\137\171\204\184\239\184\128"
+let _ = Hashtbl.add macro2utf8 "Mopf" "\240\157\149\132"
+let _ = Hashtbl.add macro2utf8 "dfisht" "\226\165\191"
+let _ = Hashtbl.add macro2utf8 "boxvL" "\226\149\161"
+let _ = Hashtbl.add macro2utf8 "pertenk" "\226\128\177"
+let _ = Hashtbl.add macro2utf8 "NotPrecedes" "\226\138\128"
+let _ = Hashtbl.add macro2utf8 "profalar" "\226\140\174"
+let _ = Hashtbl.add macro2utf8 "roplus" "\226\168\174"
+let _ = Hashtbl.add macro2utf8 "boxvR" "\226\149\158"
+let _ = Hashtbl.add macro2utf8 "utrif" "\226\150\180"
+let _ = Hashtbl.add macro2utf8 "uHar" "\226\165\163"
+let _ = Hashtbl.add macro2utf8 "nltrie" "\226\139\172"
+let _ = Hashtbl.add macro2utf8 "NotNestedGreaterGreater" "\226\146\162\204\184"
+let _ = Hashtbl.add macro2utf8 "smtes" "\226\170\172\239\184\128"
+let _ = Hashtbl.add macro2utf8 "LeftAngleBracket" "\226\140\169"
+let _ = Hashtbl.add macro2utf8 "iogon" "\196\175"
+let _ = Hashtbl.add macro2utf8 "ExponentialE" "\226\133\135"
+let _ = Hashtbl.add macro2utf8 "Topf" "\240\157\149\139"
+let _ = Hashtbl.add macro2utf8 "GreaterEqual" "\226\137\165"
+let _ = Hashtbl.add macro2utf8 "DownTee" "\226\138\164"
+let _ = Hashtbl.add macro2utf8 "boxul" "\226\148\152"
+let _ = Hashtbl.add macro2utf8 "wreath" "\226\137\128"
+let _ = Hashtbl.add macro2utf8 "sigma" "\207\131"
+let _ = Hashtbl.add macro2utf8 "sigma" "\207\131"
+let _ = Hashtbl.add macro2utf8 "ENG" "\197\138"
+let _ = Hashtbl.add macro2utf8 "Ncedil" "\197\133"
+let _ = Hashtbl.add macro2utf8 "ecy" "\209\141"
+let _ = Hashtbl.add macro2utf8 "nsubset" "\226\138\132"
+let _ = Hashtbl.add macro2utf8 "LessFullEqual" "\226\137\166"
+let _ = Hashtbl.add macro2utf8 "bsolb" "\226\167\133"
+let _ = Hashtbl.add macro2utf8 "boxur" "\226\148\148"
+let _ = Hashtbl.add macro2utf8 "ThinSpace" "\226\128\137"
+let _ = Hashtbl.add macro2utf8 "supdsub" "\226\171\152"
+let _ = Hashtbl.add macro2utf8 "colone" "\226\137\148"
+let _ = Hashtbl.add macro2utf8 "curren" "\194\164"
+let _ = Hashtbl.add macro2utf8 "boxvh" "\226\148\188"
+let _ = Hashtbl.add macro2utf8 "ecaron" "\196\155"
+let _ = Hashtbl.add macro2utf8 "UnderBrace" "\239\184\184"
+let _ = Hashtbl.add macro2utf8 "caron" "\203\135"
+let _ = Hashtbl.add macro2utf8 "ultri" "\226\151\184"
+let _ = Hashtbl.add macro2utf8 "boxvl" "\226\148\164"
+let _ = Hashtbl.add macro2utf8 "scap" "\226\137\191"
+let _ = Hashtbl.add macro2utf8 "boxvr" "\226\148\156"
+let _ = Hashtbl.add macro2utf8 "bopf" "\240\157\149\147"
+let _ = Hashtbl.add macro2utf8 "pfr" "\240\157\148\173"
+let _ = Hashtbl.add macro2utf8 "nspar" "\226\136\166\239\184\128"
+let _ = Hashtbl.add macro2utf8 "NegativeMediumSpace" "\226\129\159\239\184\128"
+let _ = Hashtbl.add macro2utf8 "simgE" "\226\170\160"
+let _ = Hashtbl.add macro2utf8 "nvDash" "\226\138\173"
+let _ = Hashtbl.add macro2utf8 "NotGreaterFullEqual" "\226\137\176"
+let _ = Hashtbl.add macro2utf8 "uparrow" "\226\134\145"
+let _ = Hashtbl.add macro2utf8 "uparrow" "\226\134\145"
+let _ = Hashtbl.add macro2utf8 "nsupset" "\226\138\133"
+let _ = Hashtbl.add macro2utf8 "simeq" "\226\137\131"
+let _ = Hashtbl.add macro2utf8 "simeq" "\226\137\131"
+let _ = Hashtbl.add macro2utf8 "Zcy" "\208\151"
+let _ = Hashtbl.add macro2utf8 "RightTriangle" "\226\138\179"
+let _ = Hashtbl.add macro2utf8 "Lang" "\227\128\138"
+let _ = Hashtbl.add macro2utf8 "Ucirc" "\195\155"
+let _ = Hashtbl.add macro2utf8 "iopf" "\240\157\149\154"
+let _ = Hashtbl.add macro2utf8 "leftrightsquigarrow" "\226\134\173"
+let _ = Hashtbl.add macro2utf8 "Gscr" "\240\157\146\162"
+let _ = Hashtbl.add macro2utf8 "lfloor" "\226\140\138"
+let _ = Hashtbl.add macro2utf8 "lfloor" "\226\140\138"
+let _ = Hashtbl.add macro2utf8 "lbbrk" "\227\128\148"
+let _ = Hashtbl.add macro2utf8 "bigvee" "\226\139\129"
+let _ = Hashtbl.add macro2utf8 "bigvee" "\226\139\129"
+let _ = Hashtbl.add macro2utf8 "ordf" "\194\170"
+let _ = Hashtbl.add macro2utf8 "rsquo" "\226\128\153"
+let _ = Hashtbl.add macro2utf8 "parallel" "\226\136\165"
+let _ = Hashtbl.add macro2utf8 "half" "\194\189"
+let _ = Hashtbl.add macro2utf8 "supseteq" "\226\138\135"
+let _ = Hashtbl.add macro2utf8 "supseteq" "\226\138\135"
+let _ = Hashtbl.add macro2utf8 "ngeqq" "\226\137\177"
+let _ = Hashtbl.add macro2utf8 "popf" "\240\157\149\161"
+let _ = Hashtbl.add macro2utf8 "NonBreakingSpace" "\194\160"
+let _ = Hashtbl.add macro2utf8 "softcy" "\209\140"
+let _ = Hashtbl.add macro2utf8 "ordm" "\194\186"
+let _ = Hashtbl.add macro2utf8 "Nscr" "\240\157\146\169"
+let _ = Hashtbl.add macro2utf8 "owns" "\226\136\139"
+let _ = Hashtbl.add macro2utf8 "phi" "\207\149"
+let _ = Hashtbl.add macro2utf8 "phi" "\207\134"
+let _ = Hashtbl.add macro2utf8 "efr" "\240\157\148\162"
+let _ = Hashtbl.add macro2utf8 "nesear" "\226\164\168"
+let _ = Hashtbl.add macro2utf8 "marker" "\226\150\174"
+let _ = Hashtbl.add macro2utf8 "lneq" "\226\137\168"
let _ = Hashtbl.add macro2utf8 "parallet" "????"
-let _ = Hashtbl.add macro2utf8 "ndash" "â\128\147"
-let _ = Hashtbl.add macro2utf8 "DoubleLeftTee" "⫤"
-let _ = Hashtbl.add macro2utf8 "lArr" "â\135\144"
-let _ = Hashtbl.add macro2utf8 "becaus" "â\136µ"
-let _ = Hashtbl.add macro2utf8 "RightTee" "â\138¢"
-let _ = Hashtbl.add macro2utf8 "Ocy" "Ð\158"
-let _ = Hashtbl.add macro2utf8 "ntlg" "â\137¸"
-let _ = Hashtbl.add macro2utf8 "cacute" "Ä\135"
-let _ = Hashtbl.add macro2utf8 "wopf" "ð\157\149¨"
-let _ = Hashtbl.add macro2utf8 "Cup" "â\139\147"
-let _ = Hashtbl.add macro2utf8 "Uscr" "ð\157\146°"
-let _ = Hashtbl.add macro2utf8 "NotHumpEqual" "â\137\143̸"
-let _ = Hashtbl.add macro2utf8 "rnmid" "⫮"
-let _ = Hashtbl.add macro2utf8 "nsupE" "â\138\137"
-let _ = Hashtbl.add macro2utf8 "bemptyv" "⦰"
+let _ = Hashtbl.add macro2utf8 "ndash" "\226\128\147"
+let _ = Hashtbl.add macro2utf8 "DoubleLeftTee" "\226\171\164"
+let _ = Hashtbl.add macro2utf8 "lArr" "\226\135\144"
+let _ = Hashtbl.add macro2utf8 "becaus" "\226\136\181"
+let _ = Hashtbl.add macro2utf8 "RightTee" "\226\138\162"
+let _ = Hashtbl.add macro2utf8 "Ocy" "\208\158"
+let _ = Hashtbl.add macro2utf8 "ntlg" "\226\137\184"
+let _ = Hashtbl.add macro2utf8 "cacute" "\196\135"
+let _ = Hashtbl.add macro2utf8 "wopf" "\240\157\149\168"
+let _ = Hashtbl.add macro2utf8 "Cup" "\226\139\147"
+let _ = Hashtbl.add macro2utf8 "Uscr" "\240\157\146\176"
+let _ = Hashtbl.add macro2utf8 "NotHumpEqual" "\226\137\143\204\184"
+let _ = Hashtbl.add macro2utf8 "rnmid" "\226\171\174"
+let _ = Hashtbl.add macro2utf8 "nsupE" "\226\138\137"
+let _ = Hashtbl.add macro2utf8 "bemptyv" "\226\166\176"
let _ = Hashtbl.add macro2utf8 "lsqb" "["
-let _ = Hashtbl.add macro2utf8 "nrarr" "â\134\155"
-let _ = Hashtbl.add macro2utf8 "egs" "â\139\157"
-let _ = Hashtbl.add macro2utf8 "reals" "â\132\157"
-let _ = Hashtbl.add macro2utf8 "CupCap" "â\137\141"
-let _ = Hashtbl.add macro2utf8 "Oacute" "Ã\147"
-let _ = Hashtbl.add macro2utf8 "Zfr" "â\132¨"
-let _ = Hashtbl.add macro2utf8 "ReverseEquilibrium" "â\135\139"
-let _ = Hashtbl.add macro2utf8 "ccedil" "ç"
-let _ = Hashtbl.add macro2utf8 "bigtriangleup" "â\150³"
-let _ = Hashtbl.add macro2utf8 "bigtriangleup" "â\150³"
-let _ = Hashtbl.add macro2utf8 "piv" "Ï\150"
-let _ = Hashtbl.add macro2utf8 "cirscir" "â§\130"
-let _ = Hashtbl.add macro2utf8 "exists" "â\136\131"
-let _ = Hashtbl.add macro2utf8 "Uarrocir" "â¥\137"
-let _ = Hashtbl.add macro2utf8 "Dcy" "Ð\148"
-let _ = Hashtbl.add macro2utf8 "cscr" "ð\157\146¸"
-let _ = Hashtbl.add macro2utf8 "zcaron" "ž"
-let _ = Hashtbl.add macro2utf8 "isinE" "â\139¹"
-let _ = Hashtbl.add macro2utf8 "gtcir" "⩺"
-let _ = Hashtbl.add macro2utf8 "hookrightarrow" "â\134ª"
-let _ = Hashtbl.add macro2utf8 "hookrightarrow" "â\134ª"
-let _ = Hashtbl.add macro2utf8 "Int" "â\136¬"
-let _ = Hashtbl.add macro2utf8 "nsupe" "â\138\137"
-let _ = Hashtbl.add macro2utf8 "dotplus" "â\136\148"
-let _ = Hashtbl.add macro2utf8 "ncup" "â©\130"
-let _ = Hashtbl.add macro2utf8 "jscr" "ð\157\146¿"
-let _ = Hashtbl.add macro2utf8 "angmsdaa" "⦨"
-let _ = Hashtbl.add macro2utf8 "flat" "â\153"
-let _ = Hashtbl.add macro2utf8 "Iukcy" "Ð\134"
-let _ = Hashtbl.add macro2utf8 "flat" "â\153"
-let _ = Hashtbl.add macro2utf8 "bNot" "⫭"
-let _ = Hashtbl.add macro2utf8 "angmsdab" "⦩"
-let _ = Hashtbl.add macro2utf8 "angmsdac" "⦪"
-let _ = Hashtbl.add macro2utf8 "iota" "ι"
-let _ = Hashtbl.add macro2utf8 "xdtri" "â\150½"
-let _ = Hashtbl.add macro2utf8 "iota" "ι"
-let _ = Hashtbl.add macro2utf8 "angmsdad" "⦫"
-let _ = Hashtbl.add macro2utf8 "angmsdae" "⦬"
-let _ = Hashtbl.add macro2utf8 "rightarrowtail" "â\134£"
-let _ = Hashtbl.add macro2utf8 "angmsdaf" "⦭"
-let _ = Hashtbl.add macro2utf8 "Ocirc" "Ã\148"
-let _ = Hashtbl.add macro2utf8 "angmsdag" "⦮"
-let _ = Hashtbl.add macro2utf8 "Ofr" "ð\157\148\146"
-let _ = Hashtbl.add macro2utf8 "maltese" "â\156 "
-let _ = Hashtbl.add macro2utf8 "angmsdah" "⦯"
-let _ = Hashtbl.add macro2utf8 "Del" "â\136\135"
-let _ = Hashtbl.add macro2utf8 "Barwed" "â\140\134"
-let _ = Hashtbl.add macro2utf8 "drbkarow" "â¤\144"
-let _ = Hashtbl.add macro2utf8 "qscr" "ð\157\147\134"
-let _ = Hashtbl.add macro2utf8 "ETH" "Ã\144"
-let _ = Hashtbl.add macro2utf8 "operp" "⦹"
-let _ = Hashtbl.add macro2utf8 "daleth" "â\132¸"
-let _ = Hashtbl.add macro2utf8 "bull" "â\128¢"
-let _ = Hashtbl.add macro2utf8 "simlE" "âª\159"
-let _ = Hashtbl.add macro2utf8 "lsquo" "â\128\152"
-let _ = Hashtbl.add macro2utf8 "Larr" "â\134\158"
-let _ = Hashtbl.add macro2utf8 "curarr" "â\134·"
-let _ = Hashtbl.add macro2utf8 "blacktriangleleft" "â\151\130"
-let _ = Hashtbl.add macro2utf8 "hellip" "â\128¦"
-let _ = Hashtbl.add macro2utf8 "DoubleVerticalBar" "â\136¥"
-let _ = Hashtbl.add macro2utf8 "rBarr" "â¤\143"
-let _ = Hashtbl.add macro2utf8 "chcy" "Ñ\135"
-let _ = Hashtbl.add macro2utf8 "varpi" "Ï\150"
-let _ = Hashtbl.add macro2utf8 "varpi" "Ï\150"
-let _ = Hashtbl.add macro2utf8 "Cconint" "â\136°"
-let _ = Hashtbl.add macro2utf8 "xlarr" "ï\149¶"
-let _ = Hashtbl.add macro2utf8 "xscr" "ð\157\147\141"
-let _ = Hashtbl.add macro2utf8 "DoubleLongRightArrow" "ï\149º"
-let _ = Hashtbl.add macro2utf8 "CounterClockwiseContourIntegral" "â\136³"
-let _ = Hashtbl.add macro2utf8 "urcrop" "â\140\142"
-let _ = Hashtbl.add macro2utf8 "RightAngleBracket" "â\140ª"
-let _ = Hashtbl.add macro2utf8 "Rcaron" "Å\152"
-let _ = Hashtbl.add macro2utf8 "latail" "â¤\153"
-let _ = Hashtbl.add macro2utf8 "pitchfork" "â\139\148"
-let _ = Hashtbl.add macro2utf8 "nvinfin" "â§\158"
-let _ = Hashtbl.add macro2utf8 "hcirc" "ĥ"
-let _ = Hashtbl.add macro2utf8 "nexist" "â\136\132"
-let _ = Hashtbl.add macro2utf8 "checkmark" "â\156\147"
-let _ = Hashtbl.add macro2utf8 "tridot" "â\151¬"
-let _ = Hashtbl.add macro2utf8 "vcy" "в"
-let _ = Hashtbl.add macro2utf8 "isins" "â\139´"
-let _ = Hashtbl.add macro2utf8 "fllig" "ï¬\130"
-let _ = Hashtbl.add macro2utf8 "Dfr" "ð\157\148\135"
-let _ = Hashtbl.add macro2utf8 "hercon" "â\138¹"
-let _ = Hashtbl.add macro2utf8 "aleph" "â\132µ"
-let _ = Hashtbl.add macro2utf8 "gEl" "â\139\155"
-let _ = Hashtbl.add macro2utf8 "bump" "â\137\142"
-let _ = Hashtbl.add macro2utf8 "aleph" "â\132µ"
-let _ = Hashtbl.add macro2utf8 "Ubreve" "Ŭ"
-let _ = Hashtbl.add macro2utf8 "isinv" "â\136\136"
-let _ = Hashtbl.add macro2utf8 "smile" "â\140£"
-let _ = Hashtbl.add macro2utf8 "smile" "â\140£"
-let _ = Hashtbl.add macro2utf8 "llcorner" "â\140\158"
-let _ = Hashtbl.add macro2utf8 "boxH" "â\149\144"
-let _ = Hashtbl.add macro2utf8 "ecir" "â\137\150"
-let _ = Hashtbl.add macro2utf8 "varnothing" "â\136\133"
-let _ = Hashtbl.add macro2utf8 "iuml" "ï"
-let _ = Hashtbl.add macro2utf8 "mlcp" "â«\155"
-let _ = Hashtbl.add macro2utf8 "leftrightharpoons" "â\135\139"
-let _ = Hashtbl.add macro2utf8 "ncong" "â\137\135"
-let _ = Hashtbl.add macro2utf8 "Vert" "â\128\150"
-let _ = Hashtbl.add macro2utf8 "Vert" "â\128\150"
-let _ = Hashtbl.add macro2utf8 "vee" "â\136¨"
-let _ = Hashtbl.add macro2utf8 "star" "â\139\134"
-let _ = Hashtbl.add macro2utf8 "vee" "â\136¨"
-let _ = Hashtbl.add macro2utf8 "star" "â\139\134"
-let _ = Hashtbl.add macro2utf8 "boxV" "â\149\145"
-let _ = Hashtbl.add macro2utf8 "leftrightarrow" "â\134\148"
-let _ = Hashtbl.add macro2utf8 "LeftRightArrow" "â\134\148"
-let _ = Hashtbl.add macro2utf8 "leftrightarrow" "â\134\148"
-let _ = Hashtbl.add macro2utf8 "ell" "â\132\147"
-let _ = Hashtbl.add macro2utf8 "lstrok" "Å\130"
-let _ = Hashtbl.add macro2utf8 "ell" "â\132\147"
-let _ = Hashtbl.add macro2utf8 "VerticalSeparator" "â\157\152"
-let _ = Hashtbl.add macro2utf8 "Ubrcy" "Ð\142"
-let _ = Hashtbl.add macro2utf8 "NotGreater" "â\137¯"
-let _ = Hashtbl.add macro2utf8 "Abreve" "Ä\130"
-let _ = Hashtbl.add macro2utf8 "TildeTilde" "â\137\136"
-let _ = Hashtbl.add macro2utf8 "CircleTimes" "â\138\151"
-let _ = Hashtbl.add macro2utf8 "subsetneq" "â\138\138"
-let _ = Hashtbl.add macro2utf8 "ltcc" "⪦"
-let _ = Hashtbl.add macro2utf8 "els" "â\139\156"
-let _ = Hashtbl.add macro2utf8 "succneqq" "⪶"
-let _ = Hashtbl.add macro2utf8 "kcy" "к"
-let _ = Hashtbl.add macro2utf8 "nshortmid" "â\136¤ï¸\128"
-let _ = Hashtbl.add macro2utf8 "mldr" "â\128¦"
-let _ = Hashtbl.add macro2utf8 "harr" "â\134\148"
-let _ = Hashtbl.add macro2utf8 "gimel" "â\132·"
-let _ = Hashtbl.add macro2utf8 "Otimes" "⨷"
-let _ = Hashtbl.add macro2utf8 "vsubnE" "â\138\138ï¸\128"
-let _ = Hashtbl.add macro2utf8 "ltdot" "â\139\150"
-let _ = Hashtbl.add macro2utf8 "boxh" "â\148\128"
-let _ = Hashtbl.add macro2utf8 "notin" "â\136\137"
-let _ = Hashtbl.add macro2utf8 "notin" "â\136\137"
-let _ = Hashtbl.add macro2utf8 "RuleDelayed" "⧴"
-let _ = Hashtbl.add macro2utf8 "sqsube" "â\138\145"
-let _ = Hashtbl.add macro2utf8 "macr" "¯"
-let _ = Hashtbl.add macro2utf8 "Icirc" "Ã\142"
+let _ = Hashtbl.add macro2utf8 "nrarr" "\226\134\155"
+let _ = Hashtbl.add macro2utf8 "egs" "\226\139\157"
+let _ = Hashtbl.add macro2utf8 "reals" "\226\132\157"
+let _ = Hashtbl.add macro2utf8 "CupCap" "\226\137\141"
+let _ = Hashtbl.add macro2utf8 "Oacute" "\195\147"
+let _ = Hashtbl.add macro2utf8 "Zfr" "\226\132\168"
+let _ = Hashtbl.add macro2utf8 "ReverseEquilibrium" "\226\135\139"
+let _ = Hashtbl.add macro2utf8 "ccedil" "\195\167"
+let _ = Hashtbl.add macro2utf8 "bigtriangleup" "\226\150\179"
+let _ = Hashtbl.add macro2utf8 "bigtriangleup" "\226\150\179"
+let _ = Hashtbl.add macro2utf8 "piv" "\207\150"
+let _ = Hashtbl.add macro2utf8 "cirscir" "\226\167\130"
+let _ = Hashtbl.add macro2utf8 "exists" "\226\136\131"
+let _ = Hashtbl.add macro2utf8 "Uarrocir" "\226\165\137"
+let _ = Hashtbl.add macro2utf8 "Dcy" "\208\148"
+let _ = Hashtbl.add macro2utf8 "cscr" "\240\157\146\184"
+let _ = Hashtbl.add macro2utf8 "zcaron" "\197\190"
+let _ = Hashtbl.add macro2utf8 "isinE" "\226\139\185"
+let _ = Hashtbl.add macro2utf8 "gtcir" "\226\169\186"
+let _ = Hashtbl.add macro2utf8 "hookrightarrow" "\226\134\170"
+let _ = Hashtbl.add macro2utf8 "hookrightarrow" "\226\134\170"
+let _ = Hashtbl.add macro2utf8 "Int" "\226\136\172"
+let _ = Hashtbl.add macro2utf8 "nsupe" "\226\138\137"
+let _ = Hashtbl.add macro2utf8 "dotplus" "\226\136\148"
+let _ = Hashtbl.add macro2utf8 "ncup" "\226\169\130"
+let _ = Hashtbl.add macro2utf8 "jscr" "\240\157\146\191"
+let _ = Hashtbl.add macro2utf8 "angmsdaa" "\226\166\168"
+let _ = Hashtbl.add macro2utf8 "flat" "\226\153\173"
+let _ = Hashtbl.add macro2utf8 "Iukcy" "\208\134"
+let _ = Hashtbl.add macro2utf8 "flat" "\226\153\173"
+let _ = Hashtbl.add macro2utf8 "bNot" "\226\171\173"
+let _ = Hashtbl.add macro2utf8 "angmsdab" "\226\166\169"
+let _ = Hashtbl.add macro2utf8 "angmsdac" "\226\166\170"
+let _ = Hashtbl.add macro2utf8 "iota" "\206\185"
+let _ = Hashtbl.add macro2utf8 "xdtri" "\226\150\189"
+let _ = Hashtbl.add macro2utf8 "iota" "\206\185"
+let _ = Hashtbl.add macro2utf8 "angmsdad" "\226\166\171"
+let _ = Hashtbl.add macro2utf8 "angmsdae" "\226\166\172"
+let _ = Hashtbl.add macro2utf8 "rightarrowtail" "\226\134\163"
+let _ = Hashtbl.add macro2utf8 "angmsdaf" "\226\166\173"
+let _ = Hashtbl.add macro2utf8 "Ocirc" "\195\148"
+let _ = Hashtbl.add macro2utf8 "angmsdag" "\226\166\174"
+let _ = Hashtbl.add macro2utf8 "Ofr" "\240\157\148\146"
+let _ = Hashtbl.add macro2utf8 "maltese" "\226\156\160"
+let _ = Hashtbl.add macro2utf8 "angmsdah" "\226\166\175"
+let _ = Hashtbl.add macro2utf8 "Del" "\226\136\135"
+let _ = Hashtbl.add macro2utf8 "Barwed" "\226\140\134"
+let _ = Hashtbl.add macro2utf8 "drbkarow" "\226\164\144"
+let _ = Hashtbl.add macro2utf8 "qscr" "\240\157\147\134"
+let _ = Hashtbl.add macro2utf8 "ETH" "\195\144"
+let _ = Hashtbl.add macro2utf8 "operp" "\226\166\185"
+let _ = Hashtbl.add macro2utf8 "daleth" "\226\132\184"
+let _ = Hashtbl.add macro2utf8 "bull" "\226\128\162"
+let _ = Hashtbl.add macro2utf8 "simlE" "\226\170\159"
+let _ = Hashtbl.add macro2utf8 "lsquo" "\226\128\152"
+let _ = Hashtbl.add macro2utf8 "Larr" "\226\134\158"
+let _ = Hashtbl.add macro2utf8 "curarr" "\226\134\183"
+let _ = Hashtbl.add macro2utf8 "blacktriangleleft" "\226\151\130"
+let _ = Hashtbl.add macro2utf8 "hellip" "\226\128\166"
+let _ = Hashtbl.add macro2utf8 "DoubleVerticalBar" "\226\136\165"
+let _ = Hashtbl.add macro2utf8 "rBarr" "\226\164\143"
+let _ = Hashtbl.add macro2utf8 "chcy" "\209\135"
+let _ = Hashtbl.add macro2utf8 "varpi" "\207\150"
+let _ = Hashtbl.add macro2utf8 "varpi" "\207\150"
+let _ = Hashtbl.add macro2utf8 "Cconint" "\226\136\176"
+let _ = Hashtbl.add macro2utf8 "xlarr" "\239\149\182"
+let _ = Hashtbl.add macro2utf8 "xscr" "\240\157\147\141"
+let _ = Hashtbl.add macro2utf8 "DoubleLongRightArrow" "\239\149\186"
+let _ = Hashtbl.add macro2utf8 "CounterClockwiseContourIntegral" "\226\136\179"
+let _ = Hashtbl.add macro2utf8 "urcrop" "\226\140\142"
+let _ = Hashtbl.add macro2utf8 "RightAngleBracket" "\226\140\170"
+let _ = Hashtbl.add macro2utf8 "Rcaron" "\197\152"
+let _ = Hashtbl.add macro2utf8 "latail" "\226\164\153"
+let _ = Hashtbl.add macro2utf8 "pitchfork" "\226\139\148"
+let _ = Hashtbl.add macro2utf8 "nvinfin" "\226\167\158"
+let _ = Hashtbl.add macro2utf8 "hcirc" "\196\165"
+let _ = Hashtbl.add macro2utf8 "nexist" "\226\136\132"
+let _ = Hashtbl.add macro2utf8 "checkmark" "\226\156\147"
+let _ = Hashtbl.add macro2utf8 "tridot" "\226\151\172"
+let _ = Hashtbl.add macro2utf8 "vcy" "\208\178"
+let _ = Hashtbl.add macro2utf8 "isins" "\226\139\180"
+let _ = Hashtbl.add macro2utf8 "fllig" "\239\172\130"
+let _ = Hashtbl.add macro2utf8 "Dfr" "\240\157\148\135"
+let _ = Hashtbl.add macro2utf8 "hercon" "\226\138\185"
+let _ = Hashtbl.add macro2utf8 "aleph" "\226\132\181"
+let _ = Hashtbl.add macro2utf8 "gEl" "\226\139\155"
+let _ = Hashtbl.add macro2utf8 "bump" "\226\137\142"
+let _ = Hashtbl.add macro2utf8 "aleph" "\226\132\181"
+let _ = Hashtbl.add macro2utf8 "Ubreve" "\197\172"
+let _ = Hashtbl.add macro2utf8 "isinv" "\226\136\136"
+let _ = Hashtbl.add macro2utf8 "smile" "\226\140\163"
+let _ = Hashtbl.add macro2utf8 "smile" "\226\140\163"
+let _ = Hashtbl.add macro2utf8 "llcorner" "\226\140\158"
+let _ = Hashtbl.add macro2utf8 "boxH" "\226\149\144"
+let _ = Hashtbl.add macro2utf8 "ecir" "\226\137\150"
+let _ = Hashtbl.add macro2utf8 "varnothing" "\226\136\133"
+let _ = Hashtbl.add macro2utf8 "iuml" "\195\175"
+let _ = Hashtbl.add macro2utf8 "mlcp" "\226\171\155"
+let _ = Hashtbl.add macro2utf8 "leftrightharpoons" "\226\135\139"
+let _ = Hashtbl.add macro2utf8 "ncong" "\226\137\135"
+let _ = Hashtbl.add macro2utf8 "Vert" "\226\128\150"
+let _ = Hashtbl.add macro2utf8 "Vert" "\226\128\150"
+let _ = Hashtbl.add macro2utf8 "vee" "\226\136\168"
+let _ = Hashtbl.add macro2utf8 "star" "\226\139\134"
+let _ = Hashtbl.add macro2utf8 "vee" "\226\136\168"
+let _ = Hashtbl.add macro2utf8 "star" "\226\139\134"
+let _ = Hashtbl.add macro2utf8 "boxV" "\226\149\145"
+let _ = Hashtbl.add macro2utf8 "leftrightarrow" "\226\134\148"
+let _ = Hashtbl.add macro2utf8 "LeftRightArrow" "\226\134\148"
+let _ = Hashtbl.add macro2utf8 "leftrightarrow" "\226\134\148"
+let _ = Hashtbl.add macro2utf8 "ell" "\226\132\147"
+let _ = Hashtbl.add macro2utf8 "lstrok" "\197\130"
+let _ = Hashtbl.add macro2utf8 "ell" "\226\132\147"
+let _ = Hashtbl.add macro2utf8 "VerticalSeparator" "\226\157\152"
+let _ = Hashtbl.add macro2utf8 "Ubrcy" "\208\142"
+let _ = Hashtbl.add macro2utf8 "NotGreater" "\226\137\175"
+let _ = Hashtbl.add macro2utf8 "Abreve" "\196\130"
+let _ = Hashtbl.add macro2utf8 "TildeTilde" "\226\137\136"
+let _ = Hashtbl.add macro2utf8 "CircleTimes" "\226\138\151"
+let _ = Hashtbl.add macro2utf8 "subsetneq" "\226\138\138"
+let _ = Hashtbl.add macro2utf8 "ltcc" "\226\170\166"
+let _ = Hashtbl.add macro2utf8 "els" "\226\139\156"
+let _ = Hashtbl.add macro2utf8 "succneqq" "\226\170\182"
+let _ = Hashtbl.add macro2utf8 "kcy" "\208\186"
+let _ = Hashtbl.add macro2utf8 "nshortmid" "\226\136\164\239\184\128"
+let _ = Hashtbl.add macro2utf8 "mldr" "\226\128\166"
+let _ = Hashtbl.add macro2utf8 "harr" "\226\134\148"
+let _ = Hashtbl.add macro2utf8 "gimel" "\226\132\183"
+let _ = Hashtbl.add macro2utf8 "Otimes" "\226\168\183"
+let _ = Hashtbl.add macro2utf8 "vsubnE" "\226\138\138\239\184\128"
+let _ = Hashtbl.add macro2utf8 "ltdot" "\226\139\150"
+let _ = Hashtbl.add macro2utf8 "boxh" "\226\148\128"
+let _ = Hashtbl.add macro2utf8 "notin" "\226\136\137"
+let _ = Hashtbl.add macro2utf8 "notin" "\226\136\137"
+let _ = Hashtbl.add macro2utf8 "RuleDelayed" "\226\167\180"
+let _ = Hashtbl.add macro2utf8 "sqsube" "\226\138\145"
+let _ = Hashtbl.add macro2utf8 "macr" "\194\175"
+let _ = Hashtbl.add macro2utf8 "Icirc" "\195\142"
let _ = Hashtbl.add macro2utf8 "comma" ","
-let _ = Hashtbl.add macro2utf8 "Cayleys" "â\132"
-let _ = Hashtbl.add macro2utf8 "rightleftharpoons" "â\135\140"
-let _ = Hashtbl.add macro2utf8 "Rarrtl" "â¤\150"
-let _ = Hashtbl.add macro2utf8 "SquareSubsetEqual" "â\138\145"
-let _ = Hashtbl.add macro2utf8 "NotGreaterEqual" "â\137±â\131¥"
-let _ = Hashtbl.add macro2utf8 "vfr" "ð\157\148³"
-let _ = Hashtbl.add macro2utf8 "utri" "â\150µ"
-let _ = Hashtbl.add macro2utf8 "simne" "â\137\134"
-let _ = Hashtbl.add macro2utf8 "LeftUpVectorBar" "â¥\152"
-let _ = Hashtbl.add macro2utf8 "hksearow" "⤥"
-let _ = Hashtbl.add macro2utf8 "boxv" "â\148\130"
-let _ = Hashtbl.add macro2utf8 "curvearrowleft" "â\134¶"
-let _ = Hashtbl.add macro2utf8 "eng" "Å\139"
-let _ = Hashtbl.add macro2utf8 "gtrarr" "⥸"
-let _ = Hashtbl.add macro2utf8 "iecy" "е"
-let _ = Hashtbl.add macro2utf8 "varr" "â\134\149"
-let _ = Hashtbl.add macro2utf8 "lBarr" "â¤\142"
+let _ = Hashtbl.add macro2utf8 "Cayleys" "\226\132\173"
+let _ = Hashtbl.add macro2utf8 "rightleftharpoons" "\226\135\140"
+let _ = Hashtbl.add macro2utf8 "Rarrtl" "\226\164\150"
+let _ = Hashtbl.add macro2utf8 "SquareSubsetEqual" "\226\138\145"
+let _ = Hashtbl.add macro2utf8 "NotGreaterEqual" "\226\137\177\226\131\165"
+let _ = Hashtbl.add macro2utf8 "vfr" "\240\157\148\179"
+let _ = Hashtbl.add macro2utf8 "utri" "\226\150\181"
+let _ = Hashtbl.add macro2utf8 "simne" "\226\137\134"
+let _ = Hashtbl.add macro2utf8 "LeftUpVectorBar" "\226\165\152"
+let _ = Hashtbl.add macro2utf8 "hksearow" "\226\164\165"
+let _ = Hashtbl.add macro2utf8 "boxv" "\226\148\130"
+let _ = Hashtbl.add macro2utf8 "curvearrowleft" "\226\134\182"
+let _ = Hashtbl.add macro2utf8 "eng" "\197\139"
+let _ = Hashtbl.add macro2utf8 "gtrarr" "\226\165\184"
+let _ = Hashtbl.add macro2utf8 "iecy" "\208\181"
+let _ = Hashtbl.add macro2utf8 "varr" "\226\134\149"
+let _ = Hashtbl.add macro2utf8 "lBarr" "\226\164\142"
let _ = Hashtbl.add macro2utf8 "ker" "ker"
-let _ = Hashtbl.add macro2utf8 "imath" "ı"
-let _ = Hashtbl.add macro2utf8 "imath" "ı"
-let _ = Hashtbl.add macro2utf8 "Dstrok" "Ä\144"
-let _ = Hashtbl.add macro2utf8 "rlarr" "â\135\132"
-let _ = Hashtbl.add macro2utf8 "leftleftarrows" "â\135\135"
-let _ = Hashtbl.add macro2utf8 "DifferentialD" "â\133\134"
-let _ = Hashtbl.add macro2utf8 "because" "â\136µ"
-let _ = Hashtbl.add macro2utf8 "ulcrop" "â\140\143"
-let _ = Hashtbl.add macro2utf8 "prE" "⪯"
-let _ = Hashtbl.add macro2utf8 "oast" "â\138\155"
-let _ = Hashtbl.add macro2utf8 "DotEqual" "â\137\144"
-let _ = Hashtbl.add macro2utf8 "vsubne" "â\138\138ï¸\128"
-let _ = Hashtbl.add macro2utf8 "hbar" "â\132\143ï¸\128"
-let _ = Hashtbl.add macro2utf8 "hbar" "â\132\143ï¸\128"
-let _ = Hashtbl.add macro2utf8 "subset" "â\138\130"
-let _ = Hashtbl.add macro2utf8 "subset" "â\138\130"
-let _ = Hashtbl.add macro2utf8 "UpTeeArrow" "â\134¥"
-let _ = Hashtbl.add macro2utf8 "LeftFloor" "â\140\138"
-let _ = Hashtbl.add macro2utf8 "kfr" "ð\157\148¨"
-let _ = Hashtbl.add macro2utf8 "nisd" "â\139º"
-let _ = Hashtbl.add macro2utf8 "scnE" "⪶"
-let _ = Hashtbl.add macro2utf8 "Ucy" "У"
-let _ = Hashtbl.add macro2utf8 "nprec" "â\138\128"
-let _ = Hashtbl.add macro2utf8 "ltrPar" "â¦\150"
-let _ = Hashtbl.add macro2utf8 "Scaron" "Š"
-let _ = Hashtbl.add macro2utf8 "InvisibleComma" "â\128\139"
-let _ = Hashtbl.add macro2utf8 "SquareUnion" "â\138\148"
-let _ = Hashtbl.add macro2utf8 "ffllig" "ï¬\132"
-let _ = Hashtbl.add macro2utf8 "approxeq" "â\137\138"
-let _ = Hashtbl.add macro2utf8 "yacute" "ý"
-let _ = Hashtbl.add macro2utf8 "pre" "⪯"
-let _ = Hashtbl.add macro2utf8 "nsqsupe" "â\139£"
-let _ = Hashtbl.add macro2utf8 "supset" "â\138\131"
-let _ = Hashtbl.add macro2utf8 "supset" "â\138\131"
-let _ = Hashtbl.add macro2utf8 "bsolhsub" "\\â\138\130"
-let _ = Hashtbl.add macro2utf8 "nshortparallel" "â\136¦ï¸\128"
-let _ = Hashtbl.add macro2utf8 "lozenge" "â\151\138"
-let _ = Hashtbl.add macro2utf8 "lnot" "¬"
-let _ = Hashtbl.add macro2utf8 "Dopf" "ð\157\148»"
-let _ = Hashtbl.add macro2utf8 "leftharpoonup" "â\134¼"
-let _ = Hashtbl.add macro2utf8 "Jcy" "Ð\153"
-let _ = Hashtbl.add macro2utf8 "rightarrow" "â\134\146"
-let _ = Hashtbl.add macro2utf8 "rightarrow" "â\134\146"
-let _ = Hashtbl.add macro2utf8 "ntriangleright" "â\139«"
-let _ = Hashtbl.add macro2utf8 "Ccirc" "Ä\136"
-let _ = Hashtbl.add macro2utf8 "eacute" "é"
-let _ = Hashtbl.add macro2utf8 "acute" "´"
-let _ = Hashtbl.add macro2utf8 "Precedes" "â\137º"
-let _ = Hashtbl.add macro2utf8 "middot" "·"
-let _ = Hashtbl.add macro2utf8 "lHar" "⥢"
-let _ = Hashtbl.add macro2utf8 "eparsl" "⧣"
-let _ = Hashtbl.add macro2utf8 "psi" "Ï\136"
-let _ = Hashtbl.add macro2utf8 "psi" "Ï\136"
-let _ = Hashtbl.add macro2utf8 "parsl" "â\136¥ï¸\128"
-let _ = Hashtbl.add macro2utf8 "UpperLeftArrow" "â\134\150"
-let _ = Hashtbl.add macro2utf8 "oror" "â©\150"
-let _ = Hashtbl.add macro2utf8 "Kopf" "ð\157\149\130"
-let _ = Hashtbl.add macro2utf8 "apacir" "⩯"
-let _ = Hashtbl.add macro2utf8 "dharl" "â\135\131"
-let _ = Hashtbl.add macro2utf8 "nequiv" "â\137¢"
-let _ = Hashtbl.add macro2utf8 "rightleftarrows" "â\135\132"
-let _ = Hashtbl.add macro2utf8 "dagger" "â\128 "
-let _ = Hashtbl.add macro2utf8 "UnderParenthesis" "︶"
-let _ = Hashtbl.add macro2utf8 "notni" "â\136\140"
-let _ = Hashtbl.add macro2utf8 "dagger" "â\128 "
-let _ = Hashtbl.add macro2utf8 "dagger" "â\128 "
-let _ = Hashtbl.add macro2utf8 "dharr" "â\135\130"
-let _ = Hashtbl.add macro2utf8 "twoheadleftarrow" "â\134\158"
-let _ = Hashtbl.add macro2utf8 "frac12" "½"
-let _ = Hashtbl.add macro2utf8 "varsubsetneqq" "â\138\138ï¸\128"
-let _ = Hashtbl.add macro2utf8 "frac13" "â\133\147"
-let _ = Hashtbl.add macro2utf8 "Ufr" "ð\157\148\152"
-let _ = Hashtbl.add macro2utf8 "NestedLessLess" "â\137ª"
-let _ = Hashtbl.add macro2utf8 "llarr" "â\135\135"
-let _ = Hashtbl.add macro2utf8 "frac14" "¼"
-let _ = Hashtbl.add macro2utf8 "frac15" "â\133\149"
-let _ = Hashtbl.add macro2utf8 "Ropf" "â\132\157"
-let _ = Hashtbl.add macro2utf8 "frac16" "â\133\153"
-let _ = Hashtbl.add macro2utf8 "lrtri" "â\138¿"
-let _ = Hashtbl.add macro2utf8 "frac18" "â\133\155"
-let _ = Hashtbl.add macro2utf8 "cedil" "¸"
-let _ = Hashtbl.add macro2utf8 "subsim" "â«\135"
-let _ = Hashtbl.add macro2utf8 "PrecedesTilde" "â\137¾"
-let _ = Hashtbl.add macro2utf8 "igrave" "ì"
-let _ = Hashtbl.add macro2utf8 "gjcy" "Ñ\147"
-let _ = Hashtbl.add macro2utf8 "LeftVector" "â\134¼"
-let _ = Hashtbl.add macro2utf8 "notniva" "â\136\140"
-let _ = Hashtbl.add macro2utf8 "notnivb" "â\139¾"
-let _ = Hashtbl.add macro2utf8 "ogon" "Ë\155"
-let _ = Hashtbl.add macro2utf8 "notnivc" "â\139½"
-let _ = Hashtbl.add macro2utf8 "Yopf" "ð\157\149\144"
-let _ = Hashtbl.add macro2utf8 "there4" "â\136´"
-let _ = Hashtbl.add macro2utf8 "udarr" "â\135\133"
-let _ = Hashtbl.add macro2utf8 "bkarow" "â¤\141"
-let _ = Hashtbl.add macro2utf8 "frac23" "â\133\148"
-let _ = Hashtbl.add macro2utf8 "frac25" "â\133\150"
-let _ = Hashtbl.add macro2utf8 "njcy" "Ñ\154"
-let _ = Hashtbl.add macro2utf8 "Dashv" "⫤"
-let _ = Hashtbl.add macro2utf8 "eta" "η"
-let _ = Hashtbl.add macro2utf8 "eta" "η"
-let _ = Hashtbl.add macro2utf8 "bcong" "â\137\140"
-let _ = Hashtbl.add macro2utf8 "Ugrave" "Ã\153"
-let _ = Hashtbl.add macro2utf8 "csube" "â«\145"
-let _ = Hashtbl.add macro2utf8 "clubs" "â\153£"
-let _ = Hashtbl.add macro2utf8 "supmult" "â«\130"
-let _ = Hashtbl.add macro2utf8 "MinusPlus" "â\136\147"
-let _ = Hashtbl.add macro2utf8 "Jfr" "ð\157\148\141"
-let _ = Hashtbl.add macro2utf8 "ensp" "â\128\130"
-let _ = Hashtbl.add macro2utf8 "ucirc" "û"
-let _ = Hashtbl.add macro2utf8 "supsim" "â«\136"
-let _ = Hashtbl.add macro2utf8 "eth" "ð"
-let _ = Hashtbl.add macro2utf8 "OverBrace" "︷"
-let _ = Hashtbl.add macro2utf8 "Dot" "¨"
-let _ = Hashtbl.add macro2utf8 "xcap" "â\139\130"
-let _ = Hashtbl.add macro2utf8 "vangrt" "â\138¾"
-let _ = Hashtbl.add macro2utf8 "NotSubsetEqual" "â\138\136"
-let _ = Hashtbl.add macro2utf8 "frac34" "¾"
-let _ = Hashtbl.add macro2utf8 "frac35" "â\133\151"
-let _ = Hashtbl.add macro2utf8 "planck" "â\132\143ï¸\128"
-let _ = Hashtbl.add macro2utf8 "lnsim" "â\139¦"
-let _ = Hashtbl.add macro2utf8 "gopf" "ð\157\149\152"
-let _ = Hashtbl.add macro2utf8 "frac38" "â\133\156"
-let _ = Hashtbl.add macro2utf8 "DotDot" "â\131\156"
-let _ = Hashtbl.add macro2utf8 "mapstoup" "â\134¥"
-let _ = Hashtbl.add macro2utf8 "Escr" "â\132°"
-let _ = Hashtbl.add macro2utf8 "Integral" "â\136«"
-let _ = Hashtbl.add macro2utf8 "Agrave" "Ã\128"
+let _ = Hashtbl.add macro2utf8 "imath" "\196\177"
+let _ = Hashtbl.add macro2utf8 "imath" "\196\177"
+let _ = Hashtbl.add macro2utf8 "Dstrok" "\196\144"
+let _ = Hashtbl.add macro2utf8 "rlarr" "\226\135\132"
+let _ = Hashtbl.add macro2utf8 "leftleftarrows" "\226\135\135"
+let _ = Hashtbl.add macro2utf8 "DifferentialD" "\226\133\134"
+let _ = Hashtbl.add macro2utf8 "because" "\226\136\181"
+let _ = Hashtbl.add macro2utf8 "ulcrop" "\226\140\143"
+let _ = Hashtbl.add macro2utf8 "prE" "\226\170\175"
+let _ = Hashtbl.add macro2utf8 "oast" "\226\138\155"
+let _ = Hashtbl.add macro2utf8 "DotEqual" "\226\137\144"
+let _ = Hashtbl.add macro2utf8 "vsubne" "\226\138\138\239\184\128"
+let _ = Hashtbl.add macro2utf8 "hbar" "\226\132\143\239\184\128"
+let _ = Hashtbl.add macro2utf8 "hbar" "\226\132\143\239\184\128"
+let _ = Hashtbl.add macro2utf8 "subset" "\226\138\130"
+let _ = Hashtbl.add macro2utf8 "subset" "\226\138\130"
+let _ = Hashtbl.add macro2utf8 "UpTeeArrow" "\226\134\165"
+let _ = Hashtbl.add macro2utf8 "LeftFloor" "\226\140\138"
+let _ = Hashtbl.add macro2utf8 "kfr" "\240\157\148\168"
+let _ = Hashtbl.add macro2utf8 "nisd" "\226\139\186"
+let _ = Hashtbl.add macro2utf8 "scnE" "\226\170\182"
+let _ = Hashtbl.add macro2utf8 "Ucy" "\208\163"
+let _ = Hashtbl.add macro2utf8 "nprec" "\226\138\128"
+let _ = Hashtbl.add macro2utf8 "ltrPar" "\226\166\150"
+let _ = Hashtbl.add macro2utf8 "Scaron" "\197\160"
+let _ = Hashtbl.add macro2utf8 "InvisibleComma" "\226\128\139"
+let _ = Hashtbl.add macro2utf8 "SquareUnion" "\226\138\148"
+let _ = Hashtbl.add macro2utf8 "ffllig" "\239\172\132"
+let _ = Hashtbl.add macro2utf8 "approxeq" "\226\137\138"
+let _ = Hashtbl.add macro2utf8 "yacute" "\195\189"
+let _ = Hashtbl.add macro2utf8 "pre" "\226\170\175"
+let _ = Hashtbl.add macro2utf8 "nsqsupe" "\226\139\163"
+let _ = Hashtbl.add macro2utf8 "supset" "\226\138\131"
+let _ = Hashtbl.add macro2utf8 "supset" "\226\138\131"
+let _ = Hashtbl.add macro2utf8 "bsolhsub" "\\\226\138\130"
+let _ = Hashtbl.add macro2utf8 "nshortparallel" "\226\136\166\239\184\128"
+let _ = Hashtbl.add macro2utf8 "lozenge" "\226\151\138"
+let _ = Hashtbl.add macro2utf8 "lnot" "\194\172"
+let _ = Hashtbl.add macro2utf8 "Dopf" "\240\157\148\187"
+let _ = Hashtbl.add macro2utf8 "leftharpoonup" "\226\134\188"
+let _ = Hashtbl.add macro2utf8 "Jcy" "\208\153"
+let _ = Hashtbl.add macro2utf8 "rightarrow" "\226\134\146"
+let _ = Hashtbl.add macro2utf8 "rightarrow" "\226\134\146"
+let _ = Hashtbl.add macro2utf8 "ntriangleright" "\226\139\171"
+let _ = Hashtbl.add macro2utf8 "Ccirc" "\196\136"
+let _ = Hashtbl.add macro2utf8 "eacute" "\195\169"
+let _ = Hashtbl.add macro2utf8 "acute" "\194\180"
+let _ = Hashtbl.add macro2utf8 "Precedes" "\226\137\186"
+let _ = Hashtbl.add macro2utf8 "middot" "\194\183"
+let _ = Hashtbl.add macro2utf8 "lHar" "\226\165\162"
+let _ = Hashtbl.add macro2utf8 "eparsl" "\226\167\163"
+let _ = Hashtbl.add macro2utf8 "psi" "\207\136"
+let _ = Hashtbl.add macro2utf8 "psi" "\207\136"
+let _ = Hashtbl.add macro2utf8 "parsl" "\226\136\165\239\184\128"
+let _ = Hashtbl.add macro2utf8 "UpperLeftArrow" "\226\134\150"
+let _ = Hashtbl.add macro2utf8 "oror" "\226\169\150"
+let _ = Hashtbl.add macro2utf8 "Kopf" "\240\157\149\130"
+let _ = Hashtbl.add macro2utf8 "apacir" "\226\169\175"
+let _ = Hashtbl.add macro2utf8 "dharl" "\226\135\131"
+let _ = Hashtbl.add macro2utf8 "nequiv" "\226\137\162"
+let _ = Hashtbl.add macro2utf8 "rightleftarrows" "\226\135\132"
+let _ = Hashtbl.add macro2utf8 "dagger" "\226\128\160"
+let _ = Hashtbl.add macro2utf8 "UnderParenthesis" "\239\184\182"
+let _ = Hashtbl.add macro2utf8 "notni" "\226\136\140"
+let _ = Hashtbl.add macro2utf8 "dagger" "\226\128\160"
+let _ = Hashtbl.add macro2utf8 "dagger" "\226\128\160"
+let _ = Hashtbl.add macro2utf8 "dharr" "\226\135\130"
+let _ = Hashtbl.add macro2utf8 "twoheadleftarrow" "\226\134\158"
+let _ = Hashtbl.add macro2utf8 "frac12" "\194\189"
+let _ = Hashtbl.add macro2utf8 "varsubsetneqq" "\226\138\138\239\184\128"
+let _ = Hashtbl.add macro2utf8 "frac13" "\226\133\147"
+let _ = Hashtbl.add macro2utf8 "Ufr" "\240\157\148\152"
+let _ = Hashtbl.add macro2utf8 "NestedLessLess" "\226\137\170"
+let _ = Hashtbl.add macro2utf8 "llarr" "\226\135\135"
+let _ = Hashtbl.add macro2utf8 "frac14" "\194\188"
+let _ = Hashtbl.add macro2utf8 "frac15" "\226\133\149"
+let _ = Hashtbl.add macro2utf8 "Ropf" "\226\132\157"
+let _ = Hashtbl.add macro2utf8 "frac16" "\226\133\153"
+let _ = Hashtbl.add macro2utf8 "lrtri" "\226\138\191"
+let _ = Hashtbl.add macro2utf8 "frac18" "\226\133\155"
+let _ = Hashtbl.add macro2utf8 "cedil" "\194\184"
+let _ = Hashtbl.add macro2utf8 "subsim" "\226\171\135"
+let _ = Hashtbl.add macro2utf8 "PrecedesTilde" "\226\137\190"
+let _ = Hashtbl.add macro2utf8 "igrave" "\195\172"
+let _ = Hashtbl.add macro2utf8 "gjcy" "\209\147"
+let _ = Hashtbl.add macro2utf8 "LeftVector" "\226\134\188"
+let _ = Hashtbl.add macro2utf8 "notniva" "\226\136\140"
+let _ = Hashtbl.add macro2utf8 "notnivb" "\226\139\190"
+let _ = Hashtbl.add macro2utf8 "ogon" "\203\155"
+let _ = Hashtbl.add macro2utf8 "notnivc" "\226\139\189"
+let _ = Hashtbl.add macro2utf8 "Yopf" "\240\157\149\144"
+let _ = Hashtbl.add macro2utf8 "there4" "\226\136\180"
+let _ = Hashtbl.add macro2utf8 "udarr" "\226\135\133"
+let _ = Hashtbl.add macro2utf8 "bkarow" "\226\164\141"
+let _ = Hashtbl.add macro2utf8 "frac23" "\226\133\148"
+let _ = Hashtbl.add macro2utf8 "frac25" "\226\133\150"
+let _ = Hashtbl.add macro2utf8 "njcy" "\209\154"
+let _ = Hashtbl.add macro2utf8 "Dashv" "\226\171\164"
+let _ = Hashtbl.add macro2utf8 "eta" "\206\183"
+let _ = Hashtbl.add macro2utf8 "eta" "\206\183"
+let _ = Hashtbl.add macro2utf8 "bcong" "\226\137\140"
+let _ = Hashtbl.add macro2utf8 "Ugrave" "\195\153"
+let _ = Hashtbl.add macro2utf8 "csube" "\226\171\145"
+let _ = Hashtbl.add macro2utf8 "clubs" "\226\153\163"
+let _ = Hashtbl.add macro2utf8 "supmult" "\226\171\130"
+let _ = Hashtbl.add macro2utf8 "MinusPlus" "\226\136\147"
+let _ = Hashtbl.add macro2utf8 "Jfr" "\240\157\148\141"
+let _ = Hashtbl.add macro2utf8 "ensp" "\226\128\130"
+let _ = Hashtbl.add macro2utf8 "ucirc" "\195\187"
+let _ = Hashtbl.add macro2utf8 "supsim" "\226\171\136"
+let _ = Hashtbl.add macro2utf8 "eth" "\195\176"
+let _ = Hashtbl.add macro2utf8 "OverBrace" "\239\184\183"
+let _ = Hashtbl.add macro2utf8 "Dot" "\194\168"
+let _ = Hashtbl.add macro2utf8 "xcap" "\226\139\130"
+let _ = Hashtbl.add macro2utf8 "vangrt" "\226\138\190"
+let _ = Hashtbl.add macro2utf8 "NotSubsetEqual" "\226\138\136"
+let _ = Hashtbl.add macro2utf8 "frac34" "\194\190"
+let _ = Hashtbl.add macro2utf8 "frac35" "\226\133\151"
+let _ = Hashtbl.add macro2utf8 "planck" "\226\132\143\239\184\128"
+let _ = Hashtbl.add macro2utf8 "lnsim" "\226\139\166"
+let _ = Hashtbl.add macro2utf8 "gopf" "\240\157\149\152"
+let _ = Hashtbl.add macro2utf8 "frac38" "\226\133\156"
+let _ = Hashtbl.add macro2utf8 "DotDot" "\226\131\156"
+let _ = Hashtbl.add macro2utf8 "mapstoup" "\226\134\165"
+let _ = Hashtbl.add macro2utf8 "Escr" "\226\132\176"
+let _ = Hashtbl.add macro2utf8 "Integral" "\226\136\171"
+let _ = Hashtbl.add macro2utf8 "Agrave" "\195\128"
let _ = Hashtbl.add macro2utf8 "longleftarrow" "????;"
-let _ = Hashtbl.add macro2utf8 "longleftarrow" "ï\149¶"
-let _ = Hashtbl.add macro2utf8 "Tcaron" "Ť"
-let _ = Hashtbl.add macro2utf8 "nopf" "ð\157\149\159"
-let _ = Hashtbl.add macro2utf8 "LongLeftRightArrow" "ï\149¸"
-let _ = Hashtbl.add macro2utf8 "Emacr" "Ä\146"
-let _ = Hashtbl.add macro2utf8 "omid" "⦶"
-let _ = Hashtbl.add macro2utf8 "spades" "â\153 "
-let _ = Hashtbl.add macro2utf8 "naturals" "â\132\149"
-let _ = Hashtbl.add macro2utf8 "Lscr" "â\132\146"
-let _ = Hashtbl.add macro2utf8 "clubsuit" "â\153£"
-let _ = Hashtbl.add macro2utf8 "udblac" "ű"
-let _ = Hashtbl.add macro2utf8 "SucceedsTilde" "â\137¿"
-let _ = Hashtbl.add macro2utf8 "frac45" "â\133\152"
-let _ = Hashtbl.add macro2utf8 "clubsuit" "â\153£"
-let _ = Hashtbl.add macro2utf8 "mumap" "â\138¸"
-let _ = Hashtbl.add macro2utf8 "vltri" "â\138²"
-let _ = Hashtbl.add macro2utf8 "LeftArrowBar" "â\135¤"
-let _ = Hashtbl.add macro2utf8 "zacute" "ź"
-let _ = Hashtbl.add macro2utf8 "szlig" "Ã\159"
-let _ = Hashtbl.add macro2utf8 "suplarr" "⥻"
-let _ = Hashtbl.add macro2utf8 "RightDownVector" "â\135\130"
-let _ = Hashtbl.add macro2utf8 "male" "â\153\130"
-let _ = Hashtbl.add macro2utf8 "RightDownVectorBar" "â¥\149"
-let _ = Hashtbl.add macro2utf8 "gdot" "ġ"
-let _ = Hashtbl.add macro2utf8 "nleqq" "â\137°"
-let _ = Hashtbl.add macro2utf8 "uopf" "ð\157\149¦"
-let _ = Hashtbl.add macro2utf8 "YIcy" "Ð\135"
-let _ = Hashtbl.add macro2utf8 "Sscr" "ð\157\146®"
-let _ = Hashtbl.add macro2utf8 "empty" "â\136\133ï¸\128"
-let _ = Hashtbl.add macro2utf8 "Vdash" "â\138©"
-let _ = Hashtbl.add macro2utf8 "sqsubset" "â\138\143"
-let _ = Hashtbl.add macro2utf8 "efDot" "â\137\146"
-let _ = Hashtbl.add macro2utf8 "times" "Ã\151"
-let _ = Hashtbl.add macro2utf8 "times" "Ã\151"
-let _ = Hashtbl.add macro2utf8 "Oslash" "Ã\152"
-let _ = Hashtbl.add macro2utf8 "itilde" "ĩ"
-let _ = Hashtbl.add macro2utf8 "frac56" "â\133\154"
-let _ = Hashtbl.add macro2utf8 "numero" "â\132\150"
-let _ = Hashtbl.add macro2utf8 "malt" "â\156 "
-let _ = Hashtbl.add macro2utf8 "npart" "â\136\130̸"
-let _ = Hashtbl.add macro2utf8 "frac58" "â\133\157"
-let _ = Hashtbl.add macro2utf8 "Zscr" "ð\157\146µ"
-let _ = Hashtbl.add macro2utf8 "integers" "â\132¤"
-let _ = Hashtbl.add macro2utf8 "CloseCurlyQuote" "â\128\153"
+let _ = Hashtbl.add macro2utf8 "longleftarrow" "\239\149\182"
+let _ = Hashtbl.add macro2utf8 "Tcaron" "\197\164"
+let _ = Hashtbl.add macro2utf8 "nopf" "\240\157\149\159"
+let _ = Hashtbl.add macro2utf8 "LongLeftRightArrow" "\239\149\184"
+let _ = Hashtbl.add macro2utf8 "Emacr" "\196\146"
+let _ = Hashtbl.add macro2utf8 "omid" "\226\166\182"
+let _ = Hashtbl.add macro2utf8 "spades" "\226\153\160"
+let _ = Hashtbl.add macro2utf8 "naturals" "\226\132\149"
+let _ = Hashtbl.add macro2utf8 "Lscr" "\226\132\146"
+let _ = Hashtbl.add macro2utf8 "clubsuit" "\226\153\163"
+let _ = Hashtbl.add macro2utf8 "udblac" "\197\177"
+let _ = Hashtbl.add macro2utf8 "SucceedsTilde" "\226\137\191"
+let _ = Hashtbl.add macro2utf8 "frac45" "\226\133\152"
+let _ = Hashtbl.add macro2utf8 "clubsuit" "\226\153\163"
+let _ = Hashtbl.add macro2utf8 "mumap" "\226\138\184"
+let _ = Hashtbl.add macro2utf8 "vltri" "\226\138\178"
+let _ = Hashtbl.add macro2utf8 "LeftArrowBar" "\226\135\164"
+let _ = Hashtbl.add macro2utf8 "zacute" "\197\186"
+let _ = Hashtbl.add macro2utf8 "szlig" "\195\159"
+let _ = Hashtbl.add macro2utf8 "suplarr" "\226\165\187"
+let _ = Hashtbl.add macro2utf8 "RightDownVector" "\226\135\130"
+let _ = Hashtbl.add macro2utf8 "male" "\226\153\130"
+let _ = Hashtbl.add macro2utf8 "RightDownVectorBar" "\226\165\149"
+let _ = Hashtbl.add macro2utf8 "gdot" "\196\161"
+let _ = Hashtbl.add macro2utf8 "nleqq" "\226\137\176"
+let _ = Hashtbl.add macro2utf8 "uopf" "\240\157\149\166"
+let _ = Hashtbl.add macro2utf8 "YIcy" "\208\135"
+let _ = Hashtbl.add macro2utf8 "Sscr" "\240\157\146\174"
+let _ = Hashtbl.add macro2utf8 "empty" "\226\136\133\239\184\128"
+let _ = Hashtbl.add macro2utf8 "Vdash" "\226\138\169"
+let _ = Hashtbl.add macro2utf8 "sqsubset" "\226\138\143"
+let _ = Hashtbl.add macro2utf8 "efDot" "\226\137\146"
+let _ = Hashtbl.add macro2utf8 "times" "\195\151"
+let _ = Hashtbl.add macro2utf8 "times" "\195\151"
+let _ = Hashtbl.add macro2utf8 "Oslash" "\195\152"
+let _ = Hashtbl.add macro2utf8 "itilde" "\196\169"
+let _ = Hashtbl.add macro2utf8 "frac56" "\226\133\154"
+let _ = Hashtbl.add macro2utf8 "numero" "\226\132\150"
+let _ = Hashtbl.add macro2utf8 "malt" "\226\156\160"
+let _ = Hashtbl.add macro2utf8 "npart" "\226\136\130\204\184"
+let _ = Hashtbl.add macro2utf8 "frac58" "\226\133\157"
+let _ = Hashtbl.add macro2utf8 "Zscr" "\240\157\146\181"
+let _ = Hashtbl.add macro2utf8 "integers" "\226\132\164"
+let _ = Hashtbl.add macro2utf8 "CloseCurlyQuote" "\226\128\153"
let _ = Hashtbl.add macro2utf8 "NewLine" "\n"
-let _ = Hashtbl.add macro2utf8 "fcy" "Ñ\132"
-let _ = Hashtbl.add macro2utf8 "nwarr" "â\134\150"
-let _ = Hashtbl.add macro2utf8 "thicksim" "â\136¼ï¸\128"
-let _ = Hashtbl.add macro2utf8 "nprcue" "â\139 "
-let _ = Hashtbl.add macro2utf8 "forall" "â\136\128"
+let _ = Hashtbl.add macro2utf8 "fcy" "\209\132"
+let _ = Hashtbl.add macro2utf8 "nwarr" "\226\134\150"
+let _ = Hashtbl.add macro2utf8 "thicksim" "\226\136\188\239\184\128"
+let _ = Hashtbl.add macro2utf8 "nprcue" "\226\139\160"
+let _ = Hashtbl.add macro2utf8 "forall" "\226\136\128"
let _ = Hashtbl.add macro2utf8 "lcub" "{"
-let _ = Hashtbl.add macro2utf8 "forall" "â\136\128"
-let _ = Hashtbl.add macro2utf8 "plusacir" "⨣"
-let _ = Hashtbl.add macro2utf8 "ascr" "ð\157\146¶"
-let _ = Hashtbl.add macro2utf8 "plustwo" "⨧"
-let _ = Hashtbl.add macro2utf8 "lambda" "λ"
-let _ = Hashtbl.add macro2utf8 "Utilde" "Ũ"
-let _ = Hashtbl.add macro2utf8 "lambda" "λ"
-let _ = Hashtbl.add macro2utf8 "odash" "â\138\157"
-let _ = Hashtbl.add macro2utf8 "iukcy" "Ñ\150"
+let _ = Hashtbl.add macro2utf8 "forall" "\226\136\128"
+let _ = Hashtbl.add macro2utf8 "plusacir" "\226\168\163"
+let _ = Hashtbl.add macro2utf8 "ascr" "\240\157\146\182"
+let _ = Hashtbl.add macro2utf8 "plustwo" "\226\168\167"
+let _ = Hashtbl.add macro2utf8 "lambda" "\206\187"
+let _ = Hashtbl.add macro2utf8 "Utilde" "\197\168"
+let _ = Hashtbl.add macro2utf8 "lambda" "\206\187"
+let _ = Hashtbl.add macro2utf8 "odash" "\226\138\157"
+let _ = Hashtbl.add macro2utf8 "iukcy" "\209\150"
let _ = Hashtbl.add macro2utf8 "Longleftarrow" "????"
-let _ = Hashtbl.add macro2utf8 "sqsupset" "â\138\144"
-let _ = Hashtbl.add macro2utf8 "Racute" "Å\148"
-let _ = Hashtbl.add macro2utf8 "Longleftarrow" "ï\149¹"
-let _ = Hashtbl.add macro2utf8 "capcap" "â©\139"
-let _ = Hashtbl.add macro2utf8 "ocirc" "ô"
-let _ = Hashtbl.add macro2utf8 "nless" "â\137®"
-let _ = Hashtbl.add macro2utf8 "Wedge" "â\139\128"
-let _ = Hashtbl.add macro2utf8 "qfr" "ð\157\148®"
-let _ = Hashtbl.add macro2utf8 "natur" "â\153®"
-let _ = Hashtbl.add macro2utf8 "hscr" "ð\157\146½"
-let _ = Hashtbl.add macro2utf8 "ldca" "⤶"
-let _ = Hashtbl.add macro2utf8 "ClockwiseContourIntegral" "â\136²"
+let _ = Hashtbl.add macro2utf8 "sqsupset" "\226\138\144"
+let _ = Hashtbl.add macro2utf8 "Racute" "\197\148"
+let _ = Hashtbl.add macro2utf8 "Longleftarrow" "\239\149\185"
+let _ = Hashtbl.add macro2utf8 "capcap" "\226\169\139"
+let _ = Hashtbl.add macro2utf8 "ocirc" "\195\180"
+let _ = Hashtbl.add macro2utf8 "nless" "\226\137\174"
+let _ = Hashtbl.add macro2utf8 "Wedge" "\226\139\128"
+let _ = Hashtbl.add macro2utf8 "qfr" "\240\157\148\174"
+let _ = Hashtbl.add macro2utf8 "natur" "\226\153\174"
+let _ = Hashtbl.add macro2utf8 "hscr" "\240\157\146\189"
+let _ = Hashtbl.add macro2utf8 "ldca" "\226\164\182"
+let _ = Hashtbl.add macro2utf8 "ClockwiseContourIntegral" "\226\136\178"
let _ = Hashtbl.add macro2utf8 "exp" "exp"
-let _ = Hashtbl.add macro2utf8 "RightTeeArrow" "â\134¦"
-let _ = Hashtbl.add macro2utf8 "orarr" "â\134»"
+let _ = Hashtbl.add macro2utf8 "RightTeeArrow" "\226\134\166"
+let _ = Hashtbl.add macro2utf8 "orarr" "\226\134\187"
let _ = Hashtbl.add macro2utf8 "tanh" "tanh"
-let _ = Hashtbl.add macro2utf8 "frac78" "â\133\158"
-let _ = Hashtbl.add macro2utf8 "Atilde" "Ã\131"
+let _ = Hashtbl.add macro2utf8 "frac78" "\226\133\158"
+let _ = Hashtbl.add macro2utf8 "Atilde" "\195\131"
let _ = Hashtbl.add macro2utf8 "arcsin" "arcsin"
-let _ = Hashtbl.add macro2utf8 "Rcedil" "Å\150"
-let _ = Hashtbl.add macro2utf8 "oscr" "â\132´"
-let _ = Hashtbl.add macro2utf8 "InvisibleTimes" "â\129¢"
-let _ = Hashtbl.add macro2utf8 "sime" "â\137\131"
-let _ = Hashtbl.add macro2utf8 "simg" "âª\158"
-let _ = Hashtbl.add macro2utf8 "Conint" "â\136¯"
-let _ = Hashtbl.add macro2utf8 "Yuml" "Ÿ"
-let _ = Hashtbl.add macro2utf8 "rlhar" "â\135\140"
-let _ = Hashtbl.add macro2utf8 "rarrbfs" "⤠"
-let _ = Hashtbl.add macro2utf8 "siml" "âª\157"
-let _ = Hashtbl.add macro2utf8 "DownRightVectorBar" "â¥\151"
-let _ = Hashtbl.add macro2utf8 "vscr" "ð\157\147\139"
-let _ = Hashtbl.add macro2utf8 "divide" "÷"
-let _ = Hashtbl.add macro2utf8 "PlusMinus" "±"
-let _ = Hashtbl.add macro2utf8 "ffr" "ð\157\148£"
-let _ = Hashtbl.add macro2utf8 "DownLeftTeeVector" "â¥\158"
-let _ = Hashtbl.add macro2utf8 "EmptySmallSquare" "â\151½"
-let _ = Hashtbl.add macro2utf8 "SHCHcy" "Щ"
-let _ = Hashtbl.add macro2utf8 "cirmid" "⫯"
-let _ = Hashtbl.add macro2utf8 "sigmav" "Ï\130"
-let _ = Hashtbl.add macro2utf8 "csub" "â«\143"
-let _ = Hashtbl.add macro2utf8 "npar" "â\136¦"
-let _ = Hashtbl.add macro2utf8 "bsemi" "â\129\143"
-let _ = Hashtbl.add macro2utf8 "swArr" "â\135\153"
-let _ = Hashtbl.add macro2utf8 "Pcy" "Ð\159"
+let _ = Hashtbl.add macro2utf8 "Rcedil" "\197\150"
+let _ = Hashtbl.add macro2utf8 "oscr" "\226\132\180"
+let _ = Hashtbl.add macro2utf8 "InvisibleTimes" "\226\129\162"
+let _ = Hashtbl.add macro2utf8 "sime" "\226\137\131"
+let _ = Hashtbl.add macro2utf8 "simg" "\226\170\158"
+let _ = Hashtbl.add macro2utf8 "Conint" "\226\136\175"
+let _ = Hashtbl.add macro2utf8 "Yuml" "\197\184"
+let _ = Hashtbl.add macro2utf8 "rlhar" "\226\135\140"
+let _ = Hashtbl.add macro2utf8 "rarrbfs" "\226\164\160"
+let _ = Hashtbl.add macro2utf8 "siml" "\226\170\157"
+let _ = Hashtbl.add macro2utf8 "DownRightVectorBar" "\226\165\151"
+let _ = Hashtbl.add macro2utf8 "vscr" "\240\157\147\139"
+let _ = Hashtbl.add macro2utf8 "divide" "\195\183"
+let _ = Hashtbl.add macro2utf8 "PlusMinus" "\194\177"
+let _ = Hashtbl.add macro2utf8 "ffr" "\240\157\148\163"
+let _ = Hashtbl.add macro2utf8 "DownLeftTeeVector" "\226\165\158"
+let _ = Hashtbl.add macro2utf8 "EmptySmallSquare" "\226\151\189"
+let _ = Hashtbl.add macro2utf8 "SHCHcy" "\208\169"
+let _ = Hashtbl.add macro2utf8 "cirmid" "\226\171\175"
+let _ = Hashtbl.add macro2utf8 "sigmav" "\207\130"
+let _ = Hashtbl.add macro2utf8 "csub" "\226\171\143"
+let _ = Hashtbl.add macro2utf8 "npar" "\226\136\166"
+let _ = Hashtbl.add macro2utf8 "bsemi" "\226\129\143"
+let _ = Hashtbl.add macro2utf8 "swArr" "\226\135\153"
+let _ = Hashtbl.add macro2utf8 "Pcy" "\208\159"
let _ = Hashtbl.add macro2utf8 "sinh" "sinh"
-let _ = Hashtbl.add macro2utf8 "lharul" "⥪"
-let _ = Hashtbl.add macro2utf8 "Jukcy" "Ð\132"
-let _ = Hashtbl.add macro2utf8 "permil" "â\128°"
-let _ = Hashtbl.add macro2utf8 "Aring" "Ã\133"
+let _ = Hashtbl.add macro2utf8 "lharul" "\226\165\170"
+let _ = Hashtbl.add macro2utf8 "Jukcy" "\208\132"
+let _ = Hashtbl.add macro2utf8 "permil" "\226\128\176"
+let _ = Hashtbl.add macro2utf8 "Aring" "\195\133"
let _ = Hashtbl.add macro2utf8 "longmapsto" "????"
-let _ = Hashtbl.add macro2utf8 "longmapsto" "ï\149½"
-let _ = Hashtbl.add macro2utf8 "Esim" "⩳"
-let _ = Hashtbl.add macro2utf8 "csup" "â«\144"
-let _ = Hashtbl.add macro2utf8 "trie" "â\137\156"
-let _ = Hashtbl.add macro2utf8 "ubrcy" "Ñ\158"
-let _ = Hashtbl.add macro2utf8 "NotEqualTilde" "â\137\130̸"
-let _ = Hashtbl.add macro2utf8 "dotminus" "â\136¸"
-let _ = Hashtbl.add macro2utf8 "diamondsuit" "â\153¢"
-let _ = Hashtbl.add macro2utf8 "diamondsuit" "â\153¦"
-let _ = Hashtbl.add macro2utf8 "xnis" "â\139»"
-let _ = Hashtbl.add macro2utf8 "Eogon" "Ä\152"
-let _ = Hashtbl.add macro2utf8 "cuvee" "â\139\142"
-let _ = Hashtbl.add macro2utf8 "DZcy" "Ð\143"
-let _ = Hashtbl.add macro2utf8 "nRightarrow" "â\135\143"
-let _ = Hashtbl.add macro2utf8 "sqsupe" "â\138\146"
-let _ = Hashtbl.add macro2utf8 "nsccue" "â\139¡"
-let _ = Hashtbl.add macro2utf8 "drcrop" "â\140\140"
-let _ = Hashtbl.add macro2utf8 "DownBreve" "Ì\145"
-let _ = Hashtbl.add macro2utf8 "Ecy" "Э"
-let _ = Hashtbl.add macro2utf8 "rdquor" "â\128\157"
-let _ = Hashtbl.add macro2utf8 "rAtail" "â¤\156"
-let _ = Hashtbl.add macro2utf8 "icirc" "î"
-let _ = Hashtbl.add macro2utf8 "gacute" "ǵ"
-let _ = Hashtbl.add macro2utf8 "hyphen" "â\128\144"
-let _ = Hashtbl.add macro2utf8 "uuml" "ü"
-let _ = Hashtbl.add macro2utf8 "thorn" "þ"
-let _ = Hashtbl.add macro2utf8 "ltri" "â\151\131"
-let _ = Hashtbl.add macro2utf8 "eqslantgtr" "â\139\157"
-let _ = Hashtbl.add macro2utf8 "DoubleContourIntegral" "â\136¯"
-let _ = Hashtbl.add macro2utf8 "lescc" "⪨"
+let _ = Hashtbl.add macro2utf8 "longmapsto" "\239\149\189"
+let _ = Hashtbl.add macro2utf8 "Esim" "\226\169\179"
+let _ = Hashtbl.add macro2utf8 "csup" "\226\171\144"
+let _ = Hashtbl.add macro2utf8 "trie" "\226\137\156"
+let _ = Hashtbl.add macro2utf8 "ubrcy" "\209\158"
+let _ = Hashtbl.add macro2utf8 "NotEqualTilde" "\226\137\130\204\184"
+let _ = Hashtbl.add macro2utf8 "dotminus" "\226\136\184"
+let _ = Hashtbl.add macro2utf8 "diamondsuit" "\226\153\162"
+let _ = Hashtbl.add macro2utf8 "diamondsuit" "\226\153\166"
+let _ = Hashtbl.add macro2utf8 "xnis" "\226\139\187"
+let _ = Hashtbl.add macro2utf8 "Eogon" "\196\152"
+let _ = Hashtbl.add macro2utf8 "cuvee" "\226\139\142"
+let _ = Hashtbl.add macro2utf8 "DZcy" "\208\143"
+let _ = Hashtbl.add macro2utf8 "nRightarrow" "\226\135\143"
+let _ = Hashtbl.add macro2utf8 "sqsupe" "\226\138\146"
+let _ = Hashtbl.add macro2utf8 "nsccue" "\226\139\161"
+let _ = Hashtbl.add macro2utf8 "drcrop" "\226\140\140"
+let _ = Hashtbl.add macro2utf8 "DownBreve" "\204\145"
+let _ = Hashtbl.add macro2utf8 "Ecy" "\208\173"
+let _ = Hashtbl.add macro2utf8 "rdquor" "\226\128\157"
+let _ = Hashtbl.add macro2utf8 "rAtail" "\226\164\156"
+let _ = Hashtbl.add macro2utf8 "icirc" "\195\174"
+let _ = Hashtbl.add macro2utf8 "gacute" "\199\181"
+let _ = Hashtbl.add macro2utf8 "hyphen" "\226\128\144"
+let _ = Hashtbl.add macro2utf8 "uuml" "\195\188"
+let _ = Hashtbl.add macro2utf8 "thorn" "\195\190"
+let _ = Hashtbl.add macro2utf8 "ltri" "\226\151\131"
+let _ = Hashtbl.add macro2utf8 "eqslantgtr" "\226\139\157"
+let _ = Hashtbl.add macro2utf8 "DoubleContourIntegral" "\226\136\175"
+let _ = Hashtbl.add macro2utf8 "lescc" "\226\170\168"
let _ = Hashtbl.add macro2utf8 "DiacriticalGrave" "`"
-let _ = Hashtbl.add macro2utf8 "NotPrecedesEqual" "⪯̸"
-let _ = Hashtbl.add macro2utf8 "RightArrow" "â\134\146"
-let _ = Hashtbl.add macro2utf8 "race" "â§\154"
-let _ = Hashtbl.add macro2utf8 "topbot" "â\140¶"
-let _ = Hashtbl.add macro2utf8 "Pfr" "ð\157\148\147"
-let _ = Hashtbl.add macro2utf8 "napprox" "â\137\137"
-let _ = Hashtbl.add macro2utf8 "Sacute" "Å\154"
-let _ = Hashtbl.add macro2utf8 "cupor" "â©\133"
-let _ = Hashtbl.add macro2utf8 "OverBar" "¯"
-let _ = Hashtbl.add macro2utf8 "bepsi" "϶"
-let _ = Hashtbl.add macro2utf8 "plankv" "â\132\143"
-let _ = Hashtbl.add macro2utf8 "lap" "â\137²"
-let _ = Hashtbl.add macro2utf8 "beta" "β"
-let _ = Hashtbl.add macro2utf8 "orslope" "â©\151"
-let _ = Hashtbl.add macro2utf8 "beta" "β"
-let _ = Hashtbl.add macro2utf8 "perp" "â\138¥"
-let _ = Hashtbl.add macro2utf8 "ShortDownArrow" "â\140\132ï¸\128"
-let _ = Hashtbl.add macro2utf8 "perp" "â\138¥"
-let _ = Hashtbl.add macro2utf8 "lat" "⪫"
-let _ = Hashtbl.add macro2utf8 "CenterDot" "·"
-let _ = Hashtbl.add macro2utf8 "models" "â\138§"
-let _ = Hashtbl.add macro2utf8 "urcorner" "â\140\157"
-let _ = Hashtbl.add macro2utf8 "models" "â\138§"
-let _ = Hashtbl.add macro2utf8 "beth" "â\132¶"
-let _ = Hashtbl.add macro2utf8 "subE" "â\138\134"
-let _ = Hashtbl.add macro2utf8 "subnE" "â\138\138"
-let _ = Hashtbl.add macro2utf8 "ldots" "â\128¦"
-let _ = Hashtbl.add macro2utf8 "yacy" "Ñ\143"
-let _ = Hashtbl.add macro2utf8 "udhar" "⥮"
-let _ = Hashtbl.add macro2utf8 "Scedil" "Å\158"
-let _ = Hashtbl.add macro2utf8 "subsub" "â«\149"
-let _ = Hashtbl.add macro2utf8 "nvrtrie" "â\139̸"
-let _ = Hashtbl.add macro2utf8 "Phi" "Φ"
-let _ = Hashtbl.add macro2utf8 "Phi" "Φ"
-let _ = Hashtbl.add macro2utf8 "Efr" "ð\157\148\136"
-let _ = Hashtbl.add macro2utf8 "larrfs" "â¤\157"
-let _ = Hashtbl.add macro2utf8 "angle" "â\136 "
-let _ = Hashtbl.add macro2utf8 "angle" "â\136 "
-let _ = Hashtbl.add macro2utf8 "TildeFullEqual" "â\137\133"
-let _ = Hashtbl.add macro2utf8 "Jcirc" "Ĵ"
-let _ = Hashtbl.add macro2utf8 "THORN" "Ã\158"
-let _ = Hashtbl.add macro2utf8 "acE" "â§\155"
+let _ = Hashtbl.add macro2utf8 "NotPrecedesEqual" "\226\170\175\204\184"
+let _ = Hashtbl.add macro2utf8 "RightArrow" "\226\134\146"
+let _ = Hashtbl.add macro2utf8 "race" "\226\167\154"
+let _ = Hashtbl.add macro2utf8 "topbot" "\226\140\182"
+let _ = Hashtbl.add macro2utf8 "Pfr" "\240\157\148\147"
+let _ = Hashtbl.add macro2utf8 "napprox" "\226\137\137"
+let _ = Hashtbl.add macro2utf8 "Sacute" "\197\154"
+let _ = Hashtbl.add macro2utf8 "cupor" "\226\169\133"
+let _ = Hashtbl.add macro2utf8 "OverBar" "\194\175"
+let _ = Hashtbl.add macro2utf8 "bepsi" "\207\182"
+let _ = Hashtbl.add macro2utf8 "plankv" "\226\132\143"
+let _ = Hashtbl.add macro2utf8 "lap" "\226\137\178"
+let _ = Hashtbl.add macro2utf8 "beta" "\206\178"
+let _ = Hashtbl.add macro2utf8 "orslope" "\226\169\151"
+let _ = Hashtbl.add macro2utf8 "beta" "\206\178"
+let _ = Hashtbl.add macro2utf8 "perp" "\226\138\165"
+let _ = Hashtbl.add macro2utf8 "ShortDownArrow" "\226\140\132\239\184\128"
+let _ = Hashtbl.add macro2utf8 "perp" "\226\138\165"
+let _ = Hashtbl.add macro2utf8 "lat" "\226\170\171"
+let _ = Hashtbl.add macro2utf8 "CenterDot" "\194\183"
+let _ = Hashtbl.add macro2utf8 "models" "\226\138\167"
+let _ = Hashtbl.add macro2utf8 "urcorner" "\226\140\157"
+let _ = Hashtbl.add macro2utf8 "models" "\226\138\167"
+let _ = Hashtbl.add macro2utf8 "beth" "\226\132\182"
+let _ = Hashtbl.add macro2utf8 "subE" "\226\138\134"
+let _ = Hashtbl.add macro2utf8 "subnE" "\226\138\138"
+let _ = Hashtbl.add macro2utf8 "ldots" "\226\128\166"
+let _ = Hashtbl.add macro2utf8 "yacy" "\209\143"
+let _ = Hashtbl.add macro2utf8 "udhar" "\226\165\174"
+let _ = Hashtbl.add macro2utf8 "Scedil" "\197\158"
+let _ = Hashtbl.add macro2utf8 "subsub" "\226\171\149"
+let _ = Hashtbl.add macro2utf8 "nvrtrie" "\226\139\173\204\184"
+let _ = Hashtbl.add macro2utf8 "Phi" "\206\166"
+let _ = Hashtbl.add macro2utf8 "Phi" "\206\166"
+let _ = Hashtbl.add macro2utf8 "Efr" "\240\157\148\136"
+let _ = Hashtbl.add macro2utf8 "larrfs" "\226\164\157"
+let _ = Hashtbl.add macro2utf8 "angle" "\226\136\160"
+let _ = Hashtbl.add macro2utf8 "angle" "\226\136\160"
+let _ = Hashtbl.add macro2utf8 "TildeFullEqual" "\226\137\133"
+let _ = Hashtbl.add macro2utf8 "Jcirc" "\196\180"
+let _ = Hashtbl.add macro2utf8 "THORN" "\195\158"
+let _ = Hashtbl.add macro2utf8 "acE" "\226\167\155"
let _ = Hashtbl.add macro2utf8 "Longleftrightarrow" "????"
-let _ = Hashtbl.add macro2utf8 "Longleftrightarrow" "ï\149»"
-let _ = Hashtbl.add macro2utf8 "xuplus" "â\138\142"
-let _ = Hashtbl.add macro2utf8 "searr" "â\134\152"
-let _ = Hashtbl.add macro2utf8 "gvertneqq" "â\137©ï¸\128"
-let _ = Hashtbl.add macro2utf8 "subsup" "â«\147"
-let _ = Hashtbl.add macro2utf8 "NotSucceedsEqual" "⪰̸"
-let _ = Hashtbl.add macro2utf8 "gtrsim" "â\137³"
-let _ = Hashtbl.add macro2utf8 "nrArr" "â\135\143"
-let _ = Hashtbl.add macro2utf8 "NotSquareSupersetEqual" "â\139£"
-let _ = Hashtbl.add macro2utf8 "notindot" "â\139¶ï¸\128"
-let _ = Hashtbl.add macro2utf8 "HARDcy" "Ъ"
-let _ = Hashtbl.add macro2utf8 "jmath" "jï¸\128"
-let _ = Hashtbl.add macro2utf8 "jmath" "jï¸\128"
-let _ = Hashtbl.add macro2utf8 "aelig" "æ"
-let _ = Hashtbl.add macro2utf8 "slarr" "â\134\144ï¸\128"
-let _ = Hashtbl.add macro2utf8 "dlcrop" "â\140\141"
-let _ = Hashtbl.add macro2utf8 "sube" "â\138\134"
-let _ = Hashtbl.add macro2utf8 "cuepr" "â\139\158"
-let _ = Hashtbl.add macro2utf8 "supsub" "â«\148"
-let _ = Hashtbl.add macro2utf8 "trianglelefteq" "â\138´"
-let _ = Hashtbl.add macro2utf8 "subne" "â\138\138"
-let _ = Hashtbl.add macro2utf8 "between" "â\137¬"
-let _ = Hashtbl.add macro2utf8 "measuredangle" "â\136¡"
-let _ = Hashtbl.add macro2utf8 "swnwar" "⤪"
-let _ = Hashtbl.add macro2utf8 "lcy" "л"
-let _ = Hashtbl.add macro2utf8 "ccirc" "Ä\137"
-let _ = Hashtbl.add macro2utf8 "larrhk" "â\134©"
-let _ = Hashtbl.add macro2utf8 "DiacriticalTilde" "Ë\156"
-let _ = Hashtbl.add macro2utf8 "brvbar" "¦"
-let _ = Hashtbl.add macro2utf8 "triangledown" "â\150¿"
-let _ = Hashtbl.add macro2utf8 "dtrif" "â\150¾"
-let _ = Hashtbl.add macro2utf8 "Bopf" "ð\157\148¹"
-let _ = Hashtbl.add macro2utf8 "xwedge" "â\139\128"
-let _ = Hashtbl.add macro2utf8 "rightsquigarrow" "â\134\157"
-let _ = Hashtbl.add macro2utf8 "acd" "â\136¿"
-let _ = Hashtbl.add macro2utf8 "supsup" "â«\150"
-let _ = Hashtbl.add macro2utf8 "UpEquilibrium" "⥮"
-let _ = Hashtbl.add macro2utf8 "succ" "â\137»"
-let _ = Hashtbl.add macro2utf8 "succ" "â\137»"
-let _ = Hashtbl.add macro2utf8 "coprod" "â\136\144"
-let _ = Hashtbl.add macro2utf8 "eqslantless" "â\139\156"
-let _ = Hashtbl.add macro2utf8 "coprod" "â\136\144"
-let _ = Hashtbl.add macro2utf8 "OpenCurlyDoubleQuote" "â\128\156"
-let _ = Hashtbl.add macro2utf8 "NotGreaterSlantEqual" "â\137±"
-let _ = Hashtbl.add macro2utf8 "solb" "â§\132"
-let _ = Hashtbl.add macro2utf8 "HumpDownHump" "â\137\142"
-let _ = Hashtbl.add macro2utf8 "gtrapprox" "â\137³"
-let _ = Hashtbl.add macro2utf8 "Iopf" "ð\157\149\128"
-let _ = Hashtbl.add macro2utf8 "leg" "â\139\154"
-let _ = Hashtbl.add macro2utf8 "wfr" "ð\157\148´"
-let _ = Hashtbl.add macro2utf8 "mapstoleft" "â\134¤"
-let _ = Hashtbl.add macro2utf8 "gnapprox" "âª\138"
-let _ = Hashtbl.add macro2utf8 "lgE" "âª\145"
-let _ = Hashtbl.add macro2utf8 "CloseCurlyDoubleQuote" "â\128\157"
-let _ = Hashtbl.add macro2utf8 "NotNestedLessLess" "â\146¡Ì¸"
-let _ = Hashtbl.add macro2utf8 "acy" "а"
-let _ = Hashtbl.add macro2utf8 "leq" "â\137¤"
-let _ = Hashtbl.add macro2utf8 "leq" "â\137¤"
-let _ = Hashtbl.add macro2utf8 "Popf" "â\132\153"
-let _ = Hashtbl.add macro2utf8 "les" "⩽"
-let _ = Hashtbl.add macro2utf8 "heartsuit" "â\153¡"
-let _ = Hashtbl.add macro2utf8 "succcurlyeq" "â\137½"
-let _ = Hashtbl.add macro2utf8 "heartsuit" "â\153¡"
-let _ = Hashtbl.add macro2utf8 "angmsd" "â\136¡"
-let _ = Hashtbl.add macro2utf8 "cuesc" "â\139\159"
-let _ = Hashtbl.add macro2utf8 "lesseqgtr" "â\139\154"
-let _ = Hashtbl.add macro2utf8 "vartriangleright" "â\138³"
-let _ = Hashtbl.add macro2utf8 "csupe" "â«\146"
-let _ = Hashtbl.add macro2utf8 "dashv" "â\138£"
-let _ = Hashtbl.add macro2utf8 "rthree" "â\139\140"
-let _ = Hashtbl.add macro2utf8 "Idot" "İ"
-let _ = Hashtbl.add macro2utf8 "gtdot" "â\139\151"
-let _ = Hashtbl.add macro2utf8 "dashv" "â\138£"
-let _ = Hashtbl.add macro2utf8 "Odblac" "Å\144"
-let _ = Hashtbl.add macro2utf8 "Lmidot" "Ŀ"
-let _ = Hashtbl.add macro2utf8 "andd" "â©\156"
-let _ = Hashtbl.add macro2utf8 "Wopf" "ð\157\149\142"
-let _ = Hashtbl.add macro2utf8 "nvltrie" "â\139¬Ì¸"
-let _ = Hashtbl.add macro2utf8 "nhpar" "⫲"
-let _ = Hashtbl.add macro2utf8 "geqslant" "⩾"
-let _ = Hashtbl.add macro2utf8 "xlArr" "ï\149¹"
-let _ = Hashtbl.add macro2utf8 "SquareSubset" "â\138\143"
-let _ = Hashtbl.add macro2utf8 "intcal" "â\138º"
-let _ = Hashtbl.add macro2utf8 "ljcy" "Ñ\153"
-let _ = Hashtbl.add macro2utf8 "lfr" "ð\157\148©"
-let _ = Hashtbl.add macro2utf8 "gtlPar" "â¦\149"
-let _ = Hashtbl.add macro2utf8 "zigrarr" "â\135\157"
-let _ = Hashtbl.add macro2utf8 "nvap" "â\137\137̸"
-let _ = Hashtbl.add macro2utf8 "boxtimes" "â\138 "
-let _ = Hashtbl.add macro2utf8 "raquo" "»"
-let _ = Hashtbl.add macro2utf8 "CircleMinus" "â\138\150"
-let _ = Hashtbl.add macro2utf8 "centerdot" "·"
-let _ = Hashtbl.add macro2utf8 "xoplus" "â\138\149"
-let _ = Hashtbl.add macro2utf8 "simdot" "⩪"
-let _ = Hashtbl.add macro2utf8 "Vcy" "Ð\146"
-let _ = Hashtbl.add macro2utf8 "profline" "â\140\146"
-let _ = Hashtbl.add macro2utf8 "ltquest" "⩻"
-let _ = Hashtbl.add macro2utf8 "andv" "â©\154"
-let _ = Hashtbl.add macro2utf8 "lessgtr" "â\137¶"
-let _ = Hashtbl.add macro2utf8 "lesdoto" "âª\129"
-let _ = Hashtbl.add macro2utf8 "bullet" "â\128¢"
-let _ = Hashtbl.add macro2utf8 "NotSquareSubset" "â\138\143̸"
-let _ = Hashtbl.add macro2utf8 "bullet" "â\128¢"
-let _ = Hashtbl.add macro2utf8 "rarrsim" "⥴"
-let _ = Hashtbl.add macro2utf8 "Tcedil" "Ţ"
-let _ = Hashtbl.add macro2utf8 "Hstrok" "Ħ"
-let _ = Hashtbl.add macro2utf8 "eopf" "ð\157\149\150"
-let _ = Hashtbl.add macro2utf8 "Theta" "Î\152"
-let _ = Hashtbl.add macro2utf8 "Theta" "Î\152"
-let _ = Hashtbl.add macro2utf8 "Cscr" "ð\157\146\158"
-let _ = Hashtbl.add macro2utf8 "emacr" "Ä\147"
-let _ = Hashtbl.add macro2utf8 "UnionPlus" "â\138\142"
-let _ = Hashtbl.add macro2utf8 "Vee" "â\139\129"
+let _ = Hashtbl.add macro2utf8 "Longleftrightarrow" "\239\149\187"
+let _ = Hashtbl.add macro2utf8 "xuplus" "\226\138\142"
+let _ = Hashtbl.add macro2utf8 "searr" "\226\134\152"
+let _ = Hashtbl.add macro2utf8 "gvertneqq" "\226\137\169\239\184\128"
+let _ = Hashtbl.add macro2utf8 "subsup" "\226\171\147"
+let _ = Hashtbl.add macro2utf8 "NotSucceedsEqual" "\226\170\176\204\184"
+let _ = Hashtbl.add macro2utf8 "gtrsim" "\226\137\179"
+let _ = Hashtbl.add macro2utf8 "nrArr" "\226\135\143"
+let _ = Hashtbl.add macro2utf8 "NotSquareSupersetEqual" "\226\139\163"
+let _ = Hashtbl.add macro2utf8 "notindot" "\226\139\182\239\184\128"
+let _ = Hashtbl.add macro2utf8 "HARDcy" "\208\170"
+let _ = Hashtbl.add macro2utf8 "jmath" "j\239\184\128"
+let _ = Hashtbl.add macro2utf8 "jmath" "j\239\184\128"
+let _ = Hashtbl.add macro2utf8 "aelig" "\195\166"
+let _ = Hashtbl.add macro2utf8 "slarr" "\226\134\144\239\184\128"
+let _ = Hashtbl.add macro2utf8 "dlcrop" "\226\140\141"
+let _ = Hashtbl.add macro2utf8 "sube" "\226\138\134"
+let _ = Hashtbl.add macro2utf8 "cuepr" "\226\139\158"
+let _ = Hashtbl.add macro2utf8 "supsub" "\226\171\148"
+let _ = Hashtbl.add macro2utf8 "trianglelefteq" "\226\138\180"
+let _ = Hashtbl.add macro2utf8 "subne" "\226\138\138"
+let _ = Hashtbl.add macro2utf8 "between" "\226\137\172"
+let _ = Hashtbl.add macro2utf8 "measuredangle" "\226\136\161"
+let _ = Hashtbl.add macro2utf8 "swnwar" "\226\164\170"
+let _ = Hashtbl.add macro2utf8 "lcy" "\208\187"
+let _ = Hashtbl.add macro2utf8 "ccirc" "\196\137"
+let _ = Hashtbl.add macro2utf8 "larrhk" "\226\134\169"
+let _ = Hashtbl.add macro2utf8 "DiacriticalTilde" "\203\156"
+let _ = Hashtbl.add macro2utf8 "brvbar" "\194\166"
+let _ = Hashtbl.add macro2utf8 "triangledown" "\226\150\191"
+let _ = Hashtbl.add macro2utf8 "dtrif" "\226\150\190"
+let _ = Hashtbl.add macro2utf8 "Bopf" "\240\157\148\185"
+let _ = Hashtbl.add macro2utf8 "xwedge" "\226\139\128"
+let _ = Hashtbl.add macro2utf8 "rightsquigarrow" "\226\134\157"
+let _ = Hashtbl.add macro2utf8 "acd" "\226\136\191"
+let _ = Hashtbl.add macro2utf8 "supsup" "\226\171\150"
+let _ = Hashtbl.add macro2utf8 "UpEquilibrium" "\226\165\174"
+let _ = Hashtbl.add macro2utf8 "succ" "\226\137\187"
+let _ = Hashtbl.add macro2utf8 "succ" "\226\137\187"
+let _ = Hashtbl.add macro2utf8 "coprod" "\226\136\144"
+let _ = Hashtbl.add macro2utf8 "eqslantless" "\226\139\156"
+let _ = Hashtbl.add macro2utf8 "coprod" "\226\136\144"
+let _ = Hashtbl.add macro2utf8 "OpenCurlyDoubleQuote" "\226\128\156"
+let _ = Hashtbl.add macro2utf8 "NotGreaterSlantEqual" "\226\137\177"
+let _ = Hashtbl.add macro2utf8 "solb" "\226\167\132"
+let _ = Hashtbl.add macro2utf8 "HumpDownHump" "\226\137\142"
+let _ = Hashtbl.add macro2utf8 "gtrapprox" "\226\137\179"
+let _ = Hashtbl.add macro2utf8 "Iopf" "\240\157\149\128"
+let _ = Hashtbl.add macro2utf8 "leg" "\226\139\154"
+let _ = Hashtbl.add macro2utf8 "wfr" "\240\157\148\180"
+let _ = Hashtbl.add macro2utf8 "mapstoleft" "\226\134\164"
+let _ = Hashtbl.add macro2utf8 "gnapprox" "\226\170\138"
+let _ = Hashtbl.add macro2utf8 "lgE" "\226\170\145"
+let _ = Hashtbl.add macro2utf8 "CloseCurlyDoubleQuote" "\226\128\157"
+let _ = Hashtbl.add macro2utf8 "NotNestedLessLess" "\226\146\161\204\184"
+let _ = Hashtbl.add macro2utf8 "acy" "\208\176"
+let _ = Hashtbl.add macro2utf8 "leq" "\226\137\164"
+let _ = Hashtbl.add macro2utf8 "leq" "\226\137\164"
+let _ = Hashtbl.add macro2utf8 "Popf" "\226\132\153"
+let _ = Hashtbl.add macro2utf8 "les" "\226\169\189"
+let _ = Hashtbl.add macro2utf8 "heartsuit" "\226\153\161"
+let _ = Hashtbl.add macro2utf8 "succcurlyeq" "\226\137\189"
+let _ = Hashtbl.add macro2utf8 "heartsuit" "\226\153\161"
+let _ = Hashtbl.add macro2utf8 "angmsd" "\226\136\161"
+let _ = Hashtbl.add macro2utf8 "cuesc" "\226\139\159"
+let _ = Hashtbl.add macro2utf8 "lesseqgtr" "\226\139\154"
+let _ = Hashtbl.add macro2utf8 "vartriangleright" "\226\138\179"
+let _ = Hashtbl.add macro2utf8 "csupe" "\226\171\146"
+let _ = Hashtbl.add macro2utf8 "dashv" "\226\138\163"
+let _ = Hashtbl.add macro2utf8 "rthree" "\226\139\140"
+let _ = Hashtbl.add macro2utf8 "Idot" "\196\176"
+let _ = Hashtbl.add macro2utf8 "gtdot" "\226\139\151"
+let _ = Hashtbl.add macro2utf8 "dashv" "\226\138\163"
+let _ = Hashtbl.add macro2utf8 "Odblac" "\197\144"
+let _ = Hashtbl.add macro2utf8 "Lmidot" "\196\191"
+let _ = Hashtbl.add macro2utf8 "andd" "\226\169\156"
+let _ = Hashtbl.add macro2utf8 "Wopf" "\240\157\149\142"
+let _ = Hashtbl.add macro2utf8 "nvltrie" "\226\139\172\204\184"
+let _ = Hashtbl.add macro2utf8 "nhpar" "\226\171\178"
+let _ = Hashtbl.add macro2utf8 "geqslant" "\226\169\190"
+let _ = Hashtbl.add macro2utf8 "xlArr" "\239\149\185"
+let _ = Hashtbl.add macro2utf8 "SquareSubset" "\226\138\143"
+let _ = Hashtbl.add macro2utf8 "intcal" "\226\138\186"
+let _ = Hashtbl.add macro2utf8 "ljcy" "\209\153"
+let _ = Hashtbl.add macro2utf8 "lfr" "\240\157\148\169"
+let _ = Hashtbl.add macro2utf8 "gtlPar" "\226\166\149"
+let _ = Hashtbl.add macro2utf8 "zigrarr" "\226\135\157"
+let _ = Hashtbl.add macro2utf8 "nvap" "\226\137\137\204\184"
+let _ = Hashtbl.add macro2utf8 "boxtimes" "\226\138\160"
+let _ = Hashtbl.add macro2utf8 "raquo" "\194\187"
+let _ = Hashtbl.add macro2utf8 "CircleMinus" "\226\138\150"
+let _ = Hashtbl.add macro2utf8 "centerdot" "\194\183"
+let _ = Hashtbl.add macro2utf8 "xoplus" "\226\138\149"
+let _ = Hashtbl.add macro2utf8 "simdot" "\226\169\170"
+let _ = Hashtbl.add macro2utf8 "Vcy" "\208\146"
+let _ = Hashtbl.add macro2utf8 "profline" "\226\140\146"
+let _ = Hashtbl.add macro2utf8 "ltquest" "\226\169\187"
+let _ = Hashtbl.add macro2utf8 "andv" "\226\169\154"
+let _ = Hashtbl.add macro2utf8 "lessgtr" "\226\137\182"
+let _ = Hashtbl.add macro2utf8 "lesdoto" "\226\170\129"
+let _ = Hashtbl.add macro2utf8 "bullet" "\226\128\162"
+let _ = Hashtbl.add macro2utf8 "NotSquareSubset" "\226\138\143\204\184"
+let _ = Hashtbl.add macro2utf8 "bullet" "\226\128\162"
+let _ = Hashtbl.add macro2utf8 "rarrsim" "\226\165\180"
+let _ = Hashtbl.add macro2utf8 "Tcedil" "\197\162"
+let _ = Hashtbl.add macro2utf8 "Hstrok" "\196\166"
+let _ = Hashtbl.add macro2utf8 "eopf" "\240\157\149\150"
+let _ = Hashtbl.add macro2utf8 "Theta" "\206\152"
+let _ = Hashtbl.add macro2utf8 "Theta" "\206\152"
+let _ = Hashtbl.add macro2utf8 "Cscr" "\240\157\146\158"
+let _ = Hashtbl.add macro2utf8 "emacr" "\196\147"
+let _ = Hashtbl.add macro2utf8 "UnionPlus" "\226\138\142"
+let _ = Hashtbl.add macro2utf8 "Vee" "\226\139\129"
let _ = Hashtbl.add macro2utf8 "arctan" "arctan"
-let _ = Hashtbl.add macro2utf8 "afr" "ð\157\148\158"
-let _ = Hashtbl.add macro2utf8 "thinsp" "â\128\137"
-let _ = Hashtbl.add macro2utf8 "bottom" "â\138¥"
-let _ = Hashtbl.add macro2utf8 "lopf" "ð\157\149\157"
-let _ = Hashtbl.add macro2utf8 "larrlp" "â\134«"
+let _ = Hashtbl.add macro2utf8 "afr" "\240\157\148\158"
+let _ = Hashtbl.add macro2utf8 "thinsp" "\226\128\137"
+let _ = Hashtbl.add macro2utf8 "bottom" "\226\138\165"
+let _ = Hashtbl.add macro2utf8 "lopf" "\240\157\149\157"
+let _ = Hashtbl.add macro2utf8 "larrlp" "\226\134\171"
let _ = Hashtbl.add macro2utf8 "lbrace" "{"
let _ = Hashtbl.add macro2utf8 "lbrace" "{"
-let _ = Hashtbl.add macro2utf8 "Jscr" "ð\157\146¥"
-let _ = Hashtbl.add macro2utf8 "Kcy" "Ð\154"
-let _ = Hashtbl.add macro2utf8 "shortparallel" "â\136¥ï¸\128"
-let _ = Hashtbl.add macro2utf8 "hairsp" "â\128\138"
+let _ = Hashtbl.add macro2utf8 "Jscr" "\240\157\146\165"
+let _ = Hashtbl.add macro2utf8 "Kcy" "\208\154"
+let _ = Hashtbl.add macro2utf8 "shortparallel" "\226\136\165\239\184\128"
+let _ = Hashtbl.add macro2utf8 "hairsp" "\226\128\138"
let _ = Hashtbl.add macro2utf8 "lbrack" "["
-let _ = Hashtbl.add macro2utf8 "osol" "â\138\152"
+let _ = Hashtbl.add macro2utf8 "osol" "\226\138\152"
let _ = Hashtbl.add macro2utf8 "lbrack" "["
-let _ = Hashtbl.add macro2utf8 "hArr" "â\135\148"
-let _ = Hashtbl.add macro2utf8 "vdash" "â\138¢"
-let _ = Hashtbl.add macro2utf8 "vdash" "â\138¢"
-let _ = Hashtbl.add macro2utf8 "UpDownArrow" "â\134\149"
-let _ = Hashtbl.add macro2utf8 "edot" "Ä\151"
-let _ = Hashtbl.add macro2utf8 "vzigzag" "â¦\154"
-let _ = Hashtbl.add macro2utf8 "sopf" "ð\157\149¤"
-let _ = Hashtbl.add macro2utf8 "NotLessGreater" "â\137¸"
-let _ = Hashtbl.add macro2utf8 "Qscr" "ð\157\146¬"
-let _ = Hashtbl.add macro2utf8 "Gammad" "Ï\156"
-let _ = Hashtbl.add macro2utf8 "SubsetEqual" "â\138\134"
-let _ = Hashtbl.add macro2utf8 "uplus" "â\138\142"
-let _ = Hashtbl.add macro2utf8 "uplus" "â\138\142"
-let _ = Hashtbl.add macro2utf8 "LeftTriangle" "â\138²"
-let _ = Hashtbl.add macro2utf8 "ange" "⦤"
+let _ = Hashtbl.add macro2utf8 "hArr" "\226\135\148"
+let _ = Hashtbl.add macro2utf8 "vdash" "\226\138\162"
+let _ = Hashtbl.add macro2utf8 "vdash" "\226\138\162"
+let _ = Hashtbl.add macro2utf8 "UpDownArrow" "\226\134\149"
+let _ = Hashtbl.add macro2utf8 "edot" "\196\151"
+let _ = Hashtbl.add macro2utf8 "vzigzag" "\226\166\154"
+let _ = Hashtbl.add macro2utf8 "sopf" "\240\157\149\164"
+let _ = Hashtbl.add macro2utf8 "NotLessGreater" "\226\137\184"
+let _ = Hashtbl.add macro2utf8 "Qscr" "\240\157\146\172"
+let _ = Hashtbl.add macro2utf8 "Gammad" "\207\156"
+let _ = Hashtbl.add macro2utf8 "SubsetEqual" "\226\138\134"
+let _ = Hashtbl.add macro2utf8 "uplus" "\226\138\142"
+let _ = Hashtbl.add macro2utf8 "uplus" "\226\138\142"
+let _ = Hashtbl.add macro2utf8 "LeftTriangle" "\226\138\178"
+let _ = Hashtbl.add macro2utf8 "ange" "\226\166\164"
let _ = Hashtbl.add macro2utf8 "lim" "lim"
-let _ = Hashtbl.add macro2utf8 "triangleright" "â\150¹"
-let _ = Hashtbl.add macro2utf8 "triangleright" "â\150¹"
-let _ = Hashtbl.add macro2utf8 "angrt" "â\136\159"
-let _ = Hashtbl.add macro2utf8 "rfloor" "â\140\139"
-let _ = Hashtbl.add macro2utf8 "bigtriangledown" "â\150½"
-let _ = Hashtbl.add macro2utf8 "rfloor" "â\140\139"
-let _ = Hashtbl.add macro2utf8 "bigtriangledown" "â\150½"
-let _ = Hashtbl.add macro2utf8 "ofcir" "⦿"
-let _ = Hashtbl.add macro2utf8 "Vfr" "ð\157\148\153"
-let _ = Hashtbl.add macro2utf8 "zopf" "ð\157\149«"
-let _ = Hashtbl.add macro2utf8 "UpArrowDownArrow" "â\135\133"
-let _ = Hashtbl.add macro2utf8 "Xscr" "ð\157\146³"
-let _ = Hashtbl.add macro2utf8 "digamma" "Ï\156"
-let _ = Hashtbl.add macro2utf8 "SmallCircle" "â\136\152"
-let _ = Hashtbl.add macro2utf8 "vArr" "â\135\149"
-let _ = Hashtbl.add macro2utf8 "eqsim" "â\137\130"
-let _ = Hashtbl.add macro2utf8 "downharpoonright" "â\135\130"
-let _ = Hashtbl.add macro2utf8 "Ccaron" "Ä\140"
-let _ = Hashtbl.add macro2utf8 "frown" "â\140¢"
-let _ = Hashtbl.add macro2utf8 "sdot" "â\139\133"
-let _ = Hashtbl.add macro2utf8 "frown" "â\140¢"
-let _ = Hashtbl.add macro2utf8 "angst" "â\132«"
-let _ = Hashtbl.add macro2utf8 "lesges" "âª\147"
-let _ = Hashtbl.add macro2utf8 "iacute" "í"
-let _ = Hashtbl.add macro2utf8 "wedge" "â\136§"
-let _ = Hashtbl.add macro2utf8 "wedge" "â\136§"
-let _ = Hashtbl.add macro2utf8 "ssetmn" "â\136\150ï¸\128"
-let _ = Hashtbl.add macro2utf8 "rotimes" "⨵"
-let _ = Hashtbl.add macro2utf8 "laquo" "«"
-let _ = Hashtbl.add macro2utf8 "bigstar" "â\152\133"
-let _ = Hashtbl.add macro2utf8 "Rrightarrow" "â\135\155"
-let _ = Hashtbl.add macro2utf8 "erDot" "â\137\147"
-let _ = Hashtbl.add macro2utf8 "subseteq" "â\138\134"
-let _ = Hashtbl.add macro2utf8 "subseteq" "â\138\134"
-let _ = Hashtbl.add macro2utf8 "leftharpoondown" "â\134½"
-let _ = Hashtbl.add macro2utf8 "infin" "â\136\158"
-let _ = Hashtbl.add macro2utf8 "zdot" "ż"
-let _ = Hashtbl.add macro2utf8 "solbar" "â\140¿"
-let _ = Hashtbl.add macro2utf8 "Iuml" "Ã\143"
-let _ = Hashtbl.add macro2utf8 "Kfr" "ð\157\148\142"
-let _ = Hashtbl.add macro2utf8 "fscr" "ð\157\146»"
-let _ = Hashtbl.add macro2utf8 "DJcy" "Ð\130"
-let _ = Hashtbl.add macro2utf8 "veeeq" "â\137\154"
-let _ = Hashtbl.add macro2utf8 "Star" "â\139\134"
-let _ = Hashtbl.add macro2utf8 "lsquor" "â\128\154"
-let _ = Hashtbl.add macro2utf8 "Uacute" "Ã\154"
-let _ = Hashtbl.add macro2utf8 "weierp" "â\132\152"
-let _ = Hashtbl.add macro2utf8 "rang" "â\140ª"
-let _ = Hashtbl.add macro2utf8 "hamilt" "â\132\139"
-let _ = Hashtbl.add macro2utf8 "angsph" "â\136¢"
-let _ = Hashtbl.add macro2utf8 "YUcy" "Ю"
-let _ = Hashtbl.add macro2utf8 "Wcirc" "Ŵ"
-let _ = Hashtbl.add macro2utf8 "supsetneq" "â\138\139"
-let _ = Hashtbl.add macro2utf8 "gap" "â\137³"
-let _ = Hashtbl.add macro2utf8 "mscr" "ð\157\147\130"
-let _ = Hashtbl.add macro2utf8 "KJcy" "Ð\140"
-let _ = Hashtbl.add macro2utf8 "qprime" "â\129\151"
-let _ = Hashtbl.add macro2utf8 "EqualTilde" "â\137\130"
-let _ = Hashtbl.add macro2utf8 "vBar" "⫨"
-let _ = Hashtbl.add macro2utf8 "larrpl" "⤹"
-let _ = Hashtbl.add macro2utf8 "approx" "â\137\136"
-let _ = Hashtbl.add macro2utf8 "nvge" "â\137±"
-let _ = Hashtbl.add macro2utf8 "approx" "â\137\136"
-let _ = Hashtbl.add macro2utf8 "lnE" "â\137¨"
-let _ = Hashtbl.add macro2utf8 "NotGreaterLess" "â\137¹"
-let _ = Hashtbl.add macro2utf8 "epar" "â\139\149"
-let _ = Hashtbl.add macro2utf8 "bigotimes" "â\138\151"
-let _ = Hashtbl.add macro2utf8 "bigotimes" "â\138\151"
-let _ = Hashtbl.add macro2utf8 "xharr" "ï\149¸"
-let _ = Hashtbl.add macro2utf8 "roang" "ï\149\153"
-let _ = Hashtbl.add macro2utf8 "xcup" "â\139\131"
-let _ = Hashtbl.add macro2utf8 "tscr" "ð\157\147\137"
-let _ = Hashtbl.add macro2utf8 "thkap" "â\137\136ï¸\128"
-let _ = Hashtbl.add macro2utf8 "Aacute" "Ã\129"
-let _ = Hashtbl.add macro2utf8 "rcy" "Ñ\128"
-let _ = Hashtbl.add macro2utf8 "jukcy" "Ñ\148"
-let _ = Hashtbl.add macro2utf8 "hookleftarrow" "â\134©"
-let _ = Hashtbl.add macro2utf8 "hookleftarrow" "â\134©"
-let _ = Hashtbl.add macro2utf8 "napid" "â\137\139̸"
-let _ = Hashtbl.add macro2utf8 "tscy" "Ñ\134"
-let _ = Hashtbl.add macro2utf8 "nvgt" "â\137¯"
+let _ = Hashtbl.add macro2utf8 "triangleright" "\226\150\185"
+let _ = Hashtbl.add macro2utf8 "triangleright" "\226\150\185"
+let _ = Hashtbl.add macro2utf8 "angrt" "\226\136\159"
+let _ = Hashtbl.add macro2utf8 "rfloor" "\226\140\139"
+let _ = Hashtbl.add macro2utf8 "bigtriangledown" "\226\150\189"
+let _ = Hashtbl.add macro2utf8 "rfloor" "\226\140\139"
+let _ = Hashtbl.add macro2utf8 "bigtriangledown" "\226\150\189"
+let _ = Hashtbl.add macro2utf8 "ofcir" "\226\166\191"
+let _ = Hashtbl.add macro2utf8 "Vfr" "\240\157\148\153"
+let _ = Hashtbl.add macro2utf8 "zopf" "\240\157\149\171"
+let _ = Hashtbl.add macro2utf8 "UpArrowDownArrow" "\226\135\133"
+let _ = Hashtbl.add macro2utf8 "Xscr" "\240\157\146\179"
+let _ = Hashtbl.add macro2utf8 "digamma" "\207\156"
+let _ = Hashtbl.add macro2utf8 "SmallCircle" "\226\136\152"
+let _ = Hashtbl.add macro2utf8 "vArr" "\226\135\149"
+let _ = Hashtbl.add macro2utf8 "eqsim" "\226\137\130"
+let _ = Hashtbl.add macro2utf8 "downharpoonright" "\226\135\130"
+let _ = Hashtbl.add macro2utf8 "Ccaron" "\196\140"
+let _ = Hashtbl.add macro2utf8 "frown" "\226\140\162"
+let _ = Hashtbl.add macro2utf8 "sdot" "\226\139\133"
+let _ = Hashtbl.add macro2utf8 "frown" "\226\140\162"
+let _ = Hashtbl.add macro2utf8 "angst" "\226\132\171"
+let _ = Hashtbl.add macro2utf8 "lesges" "\226\170\147"
+let _ = Hashtbl.add macro2utf8 "iacute" "\195\173"
+let _ = Hashtbl.add macro2utf8 "wedge" "\226\136\167"
+let _ = Hashtbl.add macro2utf8 "wedge" "\226\136\167"
+let _ = Hashtbl.add macro2utf8 "ssetmn" "\226\136\150\239\184\128"
+let _ = Hashtbl.add macro2utf8 "rotimes" "\226\168\181"
+let _ = Hashtbl.add macro2utf8 "laquo" "\194\171"
+let _ = Hashtbl.add macro2utf8 "bigstar" "\226\152\133"
+let _ = Hashtbl.add macro2utf8 "Rrightarrow" "\226\135\155"
+let _ = Hashtbl.add macro2utf8 "erDot" "\226\137\147"
+let _ = Hashtbl.add macro2utf8 "subseteq" "\226\138\134"
+let _ = Hashtbl.add macro2utf8 "subseteq" "\226\138\134"
+let _ = Hashtbl.add macro2utf8 "leftharpoondown" "\226\134\189"
+let _ = Hashtbl.add macro2utf8 "infin" "\226\136\158"
+let _ = Hashtbl.add macro2utf8 "zdot" "\197\188"
+let _ = Hashtbl.add macro2utf8 "solbar" "\226\140\191"
+let _ = Hashtbl.add macro2utf8 "Iuml" "\195\143"
+let _ = Hashtbl.add macro2utf8 "Kfr" "\240\157\148\142"
+let _ = Hashtbl.add macro2utf8 "fscr" "\240\157\146\187"
+let _ = Hashtbl.add macro2utf8 "DJcy" "\208\130"
+let _ = Hashtbl.add macro2utf8 "veeeq" "\226\137\154"
+let _ = Hashtbl.add macro2utf8 "Star" "\226\139\134"
+let _ = Hashtbl.add macro2utf8 "lsquor" "\226\128\154"
+let _ = Hashtbl.add macro2utf8 "Uacute" "\195\154"
+let _ = Hashtbl.add macro2utf8 "weierp" "\226\132\152"
+let _ = Hashtbl.add macro2utf8 "rang" "\226\140\170"
+let _ = Hashtbl.add macro2utf8 "hamilt" "\226\132\139"
+let _ = Hashtbl.add macro2utf8 "angsph" "\226\136\162"
+let _ = Hashtbl.add macro2utf8 "YUcy" "\208\174"
+let _ = Hashtbl.add macro2utf8 "Wcirc" "\197\180"
+let _ = Hashtbl.add macro2utf8 "supsetneq" "\226\138\139"
+let _ = Hashtbl.add macro2utf8 "gap" "\226\137\179"
+let _ = Hashtbl.add macro2utf8 "mscr" "\240\157\147\130"
+let _ = Hashtbl.add macro2utf8 "KJcy" "\208\140"
+let _ = Hashtbl.add macro2utf8 "qprime" "\226\129\151"
+let _ = Hashtbl.add macro2utf8 "EqualTilde" "\226\137\130"
+let _ = Hashtbl.add macro2utf8 "vBar" "\226\171\168"
+let _ = Hashtbl.add macro2utf8 "larrpl" "\226\164\185"
+let _ = Hashtbl.add macro2utf8 "approx" "\226\137\136"
+let _ = Hashtbl.add macro2utf8 "nvge" "\226\137\177"
+let _ = Hashtbl.add macro2utf8 "approx" "\226\137\136"
+let _ = Hashtbl.add macro2utf8 "lnE" "\226\137\168"
+let _ = Hashtbl.add macro2utf8 "NotGreaterLess" "\226\137\185"
+let _ = Hashtbl.add macro2utf8 "epar" "\226\139\149"
+let _ = Hashtbl.add macro2utf8 "bigotimes" "\226\138\151"
+let _ = Hashtbl.add macro2utf8 "bigotimes" "\226\138\151"
+let _ = Hashtbl.add macro2utf8 "xharr" "\239\149\184"
+let _ = Hashtbl.add macro2utf8 "roang" "\239\149\153"
+let _ = Hashtbl.add macro2utf8 "xcup" "\226\139\131"
+let _ = Hashtbl.add macro2utf8 "tscr" "\240\157\147\137"
+let _ = Hashtbl.add macro2utf8 "thkap" "\226\137\136\239\184\128"
+let _ = Hashtbl.add macro2utf8 "Aacute" "\195\129"
+let _ = Hashtbl.add macro2utf8 "rcy" "\209\128"
+let _ = Hashtbl.add macro2utf8 "jukcy" "\209\148"
+let _ = Hashtbl.add macro2utf8 "hookleftarrow" "\226\134\169"
+let _ = Hashtbl.add macro2utf8 "hookleftarrow" "\226\134\169"
+let _ = Hashtbl.add macro2utf8 "napid" "\226\137\139\204\184"
+let _ = Hashtbl.add macro2utf8 "tscy" "\209\134"
+let _ = Hashtbl.add macro2utf8 "nvgt" "\226\137\175"
let _ = Hashtbl.add macro2utf8 "lpar" "("
-let _ = Hashtbl.add macro2utf8 "ldsh" "â\134²"
-let _ = Hashtbl.add macro2utf8 "aring" "å"
-let _ = Hashtbl.add macro2utf8 "nGg" "â\139\153̸"
-let _ = Hashtbl.add macro2utf8 "LessEqualGreater" "â\139\154"
+let _ = Hashtbl.add macro2utf8 "ldsh" "\226\134\178"
+let _ = Hashtbl.add macro2utf8 "aring" "\195\165"
+let _ = Hashtbl.add macro2utf8 "nGg" "\226\139\153\204\184"
+let _ = Hashtbl.add macro2utf8 "LessEqualGreater" "\226\139\154"
let _ = Hashtbl.add macro2utf8 "gcd" "gcd"
-let _ = Hashtbl.add macro2utf8 "oplus" "â\138\149"
-let _ = Hashtbl.add macro2utf8 "oplus" "â\138\149"
-let _ = Hashtbl.add macro2utf8 "lcaron" "ľ"
-let _ = Hashtbl.add macro2utf8 "DownArrow" "â\134\147"
-let _ = Hashtbl.add macro2utf8 "Psi" "Ψ"
-let _ = Hashtbl.add macro2utf8 "xutri" "â\150³"
-let _ = Hashtbl.add macro2utf8 "Psi" "Ψ"
-let _ = Hashtbl.add macro2utf8 "lesssim" "â\137²"
-let _ = Hashtbl.add macro2utf8 "topcir" "⫱"
-let _ = Hashtbl.add macro2utf8 "puncsp" "â\128\136"
-let _ = Hashtbl.add macro2utf8 "origof" "â\138¶"
-let _ = Hashtbl.add macro2utf8 "gnsim" "â\139§"
-let _ = Hashtbl.add macro2utf8 "eogon" "Ä\153"
-let _ = Hashtbl.add macro2utf8 "spar" "â\136¥ï¸\128"
-let _ = Hashtbl.add macro2utf8 "LowerRightArrow" "â\134\152"
-let _ = Hashtbl.add macro2utf8 "Lleftarrow" "â\135\154"
-let _ = Hashtbl.add macro2utf8 "nGt" "â\137«Ì¸"
-let _ = Hashtbl.add macro2utf8 "euml" "ë"
-let _ = Hashtbl.add macro2utf8 "reg" "®"
-let _ = Hashtbl.add macro2utf8 "exponentiale" "â\133\135"
-let _ = Hashtbl.add macro2utf8 "qint" "â¨\140"
-let _ = Hashtbl.add macro2utf8 "sqcups" "â\138\148ï¸\128"
-let _ = Hashtbl.add macro2utf8 "lne" "â\137¨"
-let _ = Hashtbl.add macro2utf8 "LessSlantEqual" "⩽"
-let _ = Hashtbl.add macro2utf8 "Egrave" "Ã\136"
-let _ = Hashtbl.add macro2utf8 "orderof" "â\132´"
-let _ = Hashtbl.add macro2utf8 "cirE" "â§\131"
-let _ = Hashtbl.add macro2utf8 "nleqslant" "â\137°"
-let _ = Hashtbl.add macro2utf8 "gcy" "г"
-let _ = Hashtbl.add macro2utf8 "curvearrowright" "â\134·"
-let _ = Hashtbl.add macro2utf8 "ratail" "â\134£"
-let _ = Hashtbl.add macro2utf8 "emsp13" "â\128\132"
-let _ = Hashtbl.add macro2utf8 "sdotb" "â\138¡"
-let _ = Hashtbl.add macro2utf8 "horbar" "â\128\149"
-let _ = Hashtbl.add macro2utf8 "emsp14" "â\128\133"
-let _ = Hashtbl.add macro2utf8 "npre" "⪯̸"
-let _ = Hashtbl.add macro2utf8 "rbrksld" "â¦\142"
-let _ = Hashtbl.add macro2utf8 "sdote" "⩦"
-let _ = Hashtbl.add macro2utf8 "varsupsetneqq" "â\138\139ï¸\128"
-let _ = Hashtbl.add macro2utf8 "VeryThinSpace" "â\128\138"
-let _ = Hashtbl.add macro2utf8 "DownArrowBar" "â¤\147"
-let _ = Hashtbl.add macro2utf8 "Rightarrow" "â\135\146"
-let _ = Hashtbl.add macro2utf8 "Rightarrow" "â\135\146"
-let _ = Hashtbl.add macro2utf8 "ocir" "â\138\154"
-let _ = Hashtbl.add macro2utf8 "NotHumpDownHump" "â\137\142̸"
-let _ = Hashtbl.add macro2utf8 "darr" "â\134\147"
-let _ = Hashtbl.add macro2utf8 "geqq" "â\137§"
-let _ = Hashtbl.add macro2utf8 "sup1" "¹"
+let _ = Hashtbl.add macro2utf8 "oplus" "\226\138\149"
+let _ = Hashtbl.add macro2utf8 "oplus" "\226\138\149"
+let _ = Hashtbl.add macro2utf8 "lcaron" "\196\190"
+let _ = Hashtbl.add macro2utf8 "DownArrow" "\226\134\147"
+let _ = Hashtbl.add macro2utf8 "Psi" "\206\168"
+let _ = Hashtbl.add macro2utf8 "xutri" "\226\150\179"
+let _ = Hashtbl.add macro2utf8 "Psi" "\206\168"
+let _ = Hashtbl.add macro2utf8 "lesssim" "\226\137\178"
+let _ = Hashtbl.add macro2utf8 "topcir" "\226\171\177"
+let _ = Hashtbl.add macro2utf8 "puncsp" "\226\128\136"
+let _ = Hashtbl.add macro2utf8 "origof" "\226\138\182"
+let _ = Hashtbl.add macro2utf8 "gnsim" "\226\139\167"
+let _ = Hashtbl.add macro2utf8 "eogon" "\196\153"
+let _ = Hashtbl.add macro2utf8 "spar" "\226\136\165\239\184\128"
+let _ = Hashtbl.add macro2utf8 "LowerRightArrow" "\226\134\152"
+let _ = Hashtbl.add macro2utf8 "Lleftarrow" "\226\135\154"
+let _ = Hashtbl.add macro2utf8 "nGt" "\226\137\171\204\184"
+let _ = Hashtbl.add macro2utf8 "euml" "\195\171"
+let _ = Hashtbl.add macro2utf8 "reg" "\194\174"
+let _ = Hashtbl.add macro2utf8 "exponentiale" "\226\133\135"
+let _ = Hashtbl.add macro2utf8 "qint" "\226\168\140"
+let _ = Hashtbl.add macro2utf8 "sqcups" "\226\138\148\239\184\128"
+let _ = Hashtbl.add macro2utf8 "lne" "\226\137\168"
+let _ = Hashtbl.add macro2utf8 "LessSlantEqual" "\226\169\189"
+let _ = Hashtbl.add macro2utf8 "Egrave" "\195\136"
+let _ = Hashtbl.add macro2utf8 "orderof" "\226\132\180"
+let _ = Hashtbl.add macro2utf8 "cirE" "\226\167\131"
+let _ = Hashtbl.add macro2utf8 "nleqslant" "\226\137\176"
+let _ = Hashtbl.add macro2utf8 "gcy" "\208\179"
+let _ = Hashtbl.add macro2utf8 "curvearrowright" "\226\134\183"
+let _ = Hashtbl.add macro2utf8 "ratail" "\226\134\163"
+let _ = Hashtbl.add macro2utf8 "emsp13" "\226\128\132"
+let _ = Hashtbl.add macro2utf8 "sdotb" "\226\138\161"
+let _ = Hashtbl.add macro2utf8 "horbar" "\226\128\149"
+let _ = Hashtbl.add macro2utf8 "emsp14" "\226\128\133"
+let _ = Hashtbl.add macro2utf8 "npre" "\226\170\175\204\184"
+let _ = Hashtbl.add macro2utf8 "rbrksld" "\226\166\142"
+let _ = Hashtbl.add macro2utf8 "sdote" "\226\169\166"
+let _ = Hashtbl.add macro2utf8 "varsupsetneqq" "\226\138\139\239\184\128"
+let _ = Hashtbl.add macro2utf8 "VeryThinSpace" "\226\128\138"
+let _ = Hashtbl.add macro2utf8 "DownArrowBar" "\226\164\147"
+let _ = Hashtbl.add macro2utf8 "Rightarrow" "\226\135\146"
+let _ = Hashtbl.add macro2utf8 "Rightarrow" "\226\135\146"
+let _ = Hashtbl.add macro2utf8 "ocir" "\226\138\154"
+let _ = Hashtbl.add macro2utf8 "NotHumpDownHump" "\226\137\142\204\184"
+let _ = Hashtbl.add macro2utf8 "darr" "\226\134\147"
+let _ = Hashtbl.add macro2utf8 "geqq" "\226\137\167"
+let _ = Hashtbl.add macro2utf8 "sup1" "\194\185"
let _ = Hashtbl.add macro2utf8 "log" "log"
-let _ = Hashtbl.add macro2utf8 "sup2" "²"
-let _ = Hashtbl.add macro2utf8 "micro" "µ"
+let _ = Hashtbl.add macro2utf8 "sup2" "\194\178"
+let _ = Hashtbl.add macro2utf8 "micro" "\194\181"
let _ = Hashtbl.add macro2utf8 "amp" "&"
let _ = Hashtbl.add macro2utf8 "arccos" "arccos"
-let _ = Hashtbl.add macro2utf8 "sup3" "³"
-let _ = Hashtbl.add macro2utf8 "GreaterTilde" "â\137³"
-let _ = Hashtbl.add macro2utf8 "circeq" "â\137\151"
-let _ = Hashtbl.add macro2utf8 "rfr" "ð\157\148¯"
-let _ = Hashtbl.add macro2utf8 "dash" "â\128\144"
-let _ = Hashtbl.add macro2utf8 "rbrkslu" "â¦\144"
-let _ = Hashtbl.add macro2utf8 "Dcaron" "Ä\142"
-let _ = Hashtbl.add macro2utf8 "and" "â\136§"
-let _ = Hashtbl.add macro2utf8 "Vbar" "⫫"
-let _ = Hashtbl.add macro2utf8 "angzarr" "â\141¼"
-let _ = Hashtbl.add macro2utf8 "gel" "â\139\155"
-let _ = Hashtbl.add macro2utf8 "ang" "â\136 "
-let _ = Hashtbl.add macro2utf8 "lor" "â\136¨"
+let _ = Hashtbl.add macro2utf8 "sup3" "\194\179"
+let _ = Hashtbl.add macro2utf8 "GreaterTilde" "\226\137\179"
+let _ = Hashtbl.add macro2utf8 "circeq" "\226\137\151"
+let _ = Hashtbl.add macro2utf8 "rfr" "\240\157\148\175"
+let _ = Hashtbl.add macro2utf8 "dash" "\226\128\144"
+let _ = Hashtbl.add macro2utf8 "rbrkslu" "\226\166\144"
+let _ = Hashtbl.add macro2utf8 "Dcaron" "\196\142"
+let _ = Hashtbl.add macro2utf8 "and" "\226\136\167"
+let _ = Hashtbl.add macro2utf8 "Vbar" "\226\171\171"
+let _ = Hashtbl.add macro2utf8 "angzarr" "\226\141\188"
+let _ = Hashtbl.add macro2utf8 "gel" "\226\139\155"
+let _ = Hashtbl.add macro2utf8 "ang" "\226\136\160"
+let _ = Hashtbl.add macro2utf8 "lor" "\226\136\168"
let _ = Hashtbl.add macro2utf8 "circ" "^"
let _ = Hashtbl.add macro2utf8 "circ" "^"
-let _ = Hashtbl.add macro2utf8 "upharpoonright" "â\134¾"
-let _ = Hashtbl.add macro2utf8 "dblac" "Ë\157"
-let _ = Hashtbl.add macro2utf8 "subsetneqq" "â\138\138"
-let _ = Hashtbl.add macro2utf8 "rhard" "â\135\129"
-let _ = Hashtbl.add macro2utf8 "Intersection" "â\139\130"
-let _ = Hashtbl.add macro2utf8 "cire" "â\137\151"
-let _ = Hashtbl.add macro2utf8 "apE" "â\137\138"
-let _ = Hashtbl.add macro2utf8 "geq" "â\137¥"
-let _ = Hashtbl.add macro2utf8 "sung" "â\153ª"
-let _ = Hashtbl.add macro2utf8 "geq" "â\137¥"
-let _ = Hashtbl.add macro2utf8 "succsim" "â\137¿"
-let _ = Hashtbl.add macro2utf8 "ges" "⩾"
-let _ = Hashtbl.add macro2utf8 "Gbreve" "Ä\158"
-let _ = Hashtbl.add macro2utf8 "intercal" "â\138º"
-let _ = Hashtbl.add macro2utf8 "supE" "â\138\135"
-let _ = Hashtbl.add macro2utf8 "NotCupCap" "â\137"
-let _ = Hashtbl.add macro2utf8 "loz" "â\151\138"
-let _ = Hashtbl.add macro2utf8 "capcup" "â©\135"
-let _ = Hashtbl.add macro2utf8 "larrtl" "â\134¢"
-let _ = Hashtbl.add macro2utf8 "AElig" "Ã\134"
-let _ = Hashtbl.add macro2utf8 "rarr" "â\134\146"
-let _ = Hashtbl.add macro2utf8 "varkappa" "ϰ"
-let _ = Hashtbl.add macro2utf8 "upsi" "Ï\133"
-let _ = Hashtbl.add macro2utf8 "loang" "ï\149\152"
-let _ = Hashtbl.add macro2utf8 "looparrowleft" "â\134«"
-let _ = Hashtbl.add macro2utf8 "IOcy" "Ð\129"
-let _ = Hashtbl.add macro2utf8 "backprime" "â\128µ"
-let _ = Hashtbl.add macro2utf8 "sstarf" "â\139\134"
-let _ = Hashtbl.add macro2utf8 "rharu" "â\135\128"
-let _ = Hashtbl.add macro2utf8 "gesl" "â\139\155ï¸\128"
-let _ = Hashtbl.add macro2utf8 "xotime" "â\138\151"
-let _ = Hashtbl.add macro2utf8 "minus" "â\136\146"
-let _ = Hashtbl.add macro2utf8 "gvnE" "â\137©ï¸\128"
-let _ = Hashtbl.add macro2utf8 "gfr" "ð\157\148¤"
-let _ = Hashtbl.add macro2utf8 "lfisht" "⥼"
-let _ = Hashtbl.add macro2utf8 "jcirc" "ĵ"
-let _ = Hashtbl.add macro2utf8 "roarr" "â\135¾"
-let _ = Hashtbl.add macro2utf8 "rho" "Ï\129"
-let _ = Hashtbl.add macro2utf8 "rho" "Ï\129"
-let _ = Hashtbl.add macro2utf8 "nvle" "â\137°"
-let _ = Hashtbl.add macro2utf8 "sect" "§"
-let _ = Hashtbl.add macro2utf8 "ggg" "â\139\153"
-let _ = Hashtbl.add macro2utf8 "plusb" "â\138\158"
-let _ = Hashtbl.add macro2utf8 "NotTildeFullEqual" "â\137\135"
-let _ = Hashtbl.add macro2utf8 "NegativeVeryThinSpace" "â\128\138ï¸\128"
-let _ = Hashtbl.add macro2utf8 "ape" "â\137\138"
-let _ = Hashtbl.add macro2utf8 "pluse" "⩲"
+let _ = Hashtbl.add macro2utf8 "upharpoonright" "\226\134\190"
+let _ = Hashtbl.add macro2utf8 "dblac" "\203\157"
+let _ = Hashtbl.add macro2utf8 "subsetneqq" "\226\138\138"
+let _ = Hashtbl.add macro2utf8 "rhard" "\226\135\129"
+let _ = Hashtbl.add macro2utf8 "Intersection" "\226\139\130"
+let _ = Hashtbl.add macro2utf8 "cire" "\226\137\151"
+let _ = Hashtbl.add macro2utf8 "apE" "\226\137\138"
+let _ = Hashtbl.add macro2utf8 "geq" "\226\137\165"
+let _ = Hashtbl.add macro2utf8 "sung" "\226\153\170"
+let _ = Hashtbl.add macro2utf8 "geq" "\226\137\165"
+let _ = Hashtbl.add macro2utf8 "succsim" "\226\137\191"
+let _ = Hashtbl.add macro2utf8 "ges" "\226\169\190"
+let _ = Hashtbl.add macro2utf8 "Gbreve" "\196\158"
+let _ = Hashtbl.add macro2utf8 "intercal" "\226\138\186"
+let _ = Hashtbl.add macro2utf8 "supE" "\226\138\135"
+let _ = Hashtbl.add macro2utf8 "NotCupCap" "\226\137\173"
+let _ = Hashtbl.add macro2utf8 "loz" "\226\151\138"
+let _ = Hashtbl.add macro2utf8 "capcup" "\226\169\135"
+let _ = Hashtbl.add macro2utf8 "larrtl" "\226\134\162"
+let _ = Hashtbl.add macro2utf8 "AElig" "\195\134"
+let _ = Hashtbl.add macro2utf8 "rarr" "\226\134\146"
+let _ = Hashtbl.add macro2utf8 "varkappa" "\207\176"
+let _ = Hashtbl.add macro2utf8 "upsi" "\207\133"
+let _ = Hashtbl.add macro2utf8 "loang" "\239\149\152"
+let _ = Hashtbl.add macro2utf8 "looparrowleft" "\226\134\171"
+let _ = Hashtbl.add macro2utf8 "IOcy" "\208\129"
+let _ = Hashtbl.add macro2utf8 "backprime" "\226\128\181"
+let _ = Hashtbl.add macro2utf8 "sstarf" "\226\139\134"
+let _ = Hashtbl.add macro2utf8 "rharu" "\226\135\128"
+let _ = Hashtbl.add macro2utf8 "gesl" "\226\139\155\239\184\128"
+let _ = Hashtbl.add macro2utf8 "xotime" "\226\138\151"
+let _ = Hashtbl.add macro2utf8 "minus" "\226\136\146"
+let _ = Hashtbl.add macro2utf8 "gvnE" "\226\137\169\239\184\128"
+let _ = Hashtbl.add macro2utf8 "gfr" "\240\157\148\164"
+let _ = Hashtbl.add macro2utf8 "lfisht" "\226\165\188"
+let _ = Hashtbl.add macro2utf8 "jcirc" "\196\181"
+let _ = Hashtbl.add macro2utf8 "roarr" "\226\135\190"
+let _ = Hashtbl.add macro2utf8 "rho" "\207\129"
+let _ = Hashtbl.add macro2utf8 "rho" "\207\129"
+let _ = Hashtbl.add macro2utf8 "nvle" "\226\137\176"
+let _ = Hashtbl.add macro2utf8 "sect" "\194\167"
+let _ = Hashtbl.add macro2utf8 "ggg" "\226\139\153"
+let _ = Hashtbl.add macro2utf8 "plusb" "\226\138\158"
+let _ = Hashtbl.add macro2utf8 "NotTildeFullEqual" "\226\137\135"
+let _ = Hashtbl.add macro2utf8 "NegativeVeryThinSpace" "\226\128\138\239\184\128"
+let _ = Hashtbl.add macro2utf8 "ape" "\226\137\138"
+let _ = Hashtbl.add macro2utf8 "pluse" "\226\169\178"
let _ = Hashtbl.add macro2utf8 "dollar" "$"
-let _ = Hashtbl.add macro2utf8 "divonx" "â\139\135"
-let _ = Hashtbl.add macro2utf8 "partial" "â\136\130"
-let _ = Hashtbl.add macro2utf8 "DoubleLeftRightArrow" "â\135\148"
-let _ = Hashtbl.add macro2utf8 "varepsilon" "ε"
-let _ = Hashtbl.add macro2utf8 "varepsilon" "É\155"
-let _ = Hashtbl.add macro2utf8 "supe" "â\138\135"
-let _ = Hashtbl.add macro2utf8 "nvlt" "â\137®"
-let _ = Hashtbl.add macro2utf8 "angrtvb" "â¦\157ï¸\128"
-let _ = Hashtbl.add macro2utf8 "gets" "â\134\144"
-let _ = Hashtbl.add macro2utf8 "nparallel" "â\136¦"
-let _ = Hashtbl.add macro2utf8 "varphi" "Ï\134"
-let _ = Hashtbl.add macro2utf8 "varphi" "Ï\149"
-let _ = Hashtbl.add macro2utf8 "nsupseteq" "â\138\137"
-let _ = Hashtbl.add macro2utf8 "circledR" "®"
-let _ = Hashtbl.add macro2utf8 "circledS" "â\147\136"
-let _ = Hashtbl.add macro2utf8 "primes" "â\132\153"
-let _ = Hashtbl.add macro2utf8 "cuwed" "â\139\143"
-let _ = Hashtbl.add macro2utf8 "cupcap" "â©\134"
-let _ = Hashtbl.add macro2utf8 "nLl" "â\139\152̸"
-let _ = Hashtbl.add macro2utf8 "lozf" "⧫"
-let _ = Hashtbl.add macro2utf8 "ShortLeftArrow" "â\134\144ï¸\128"
-let _ = Hashtbl.add macro2utf8 "nLt" "â\137ªÌ¸"
-let _ = Hashtbl.add macro2utf8 "lesdotor" "âª\131"
-let _ = Hashtbl.add macro2utf8 "Fcy" "Ф"
-let _ = Hashtbl.add macro2utf8 "scnsim" "â\139©"
+let _ = Hashtbl.add macro2utf8 "divonx" "\226\139\135"
+let _ = Hashtbl.add macro2utf8 "partial" "\226\136\130"
+let _ = Hashtbl.add macro2utf8 "DoubleLeftRightArrow" "\226\135\148"
+let _ = Hashtbl.add macro2utf8 "varepsilon" "\206\181"
+let _ = Hashtbl.add macro2utf8 "varepsilon" "\201\155"
+let _ = Hashtbl.add macro2utf8 "supe" "\226\138\135"
+let _ = Hashtbl.add macro2utf8 "nvlt" "\226\137\174"
+let _ = Hashtbl.add macro2utf8 "angrtvb" "\226\166\157\239\184\128"
+let _ = Hashtbl.add macro2utf8 "gets" "\226\134\144"
+let _ = Hashtbl.add macro2utf8 "nparallel" "\226\136\166"
+let _ = Hashtbl.add macro2utf8 "varphi" "\207\134"
+let _ = Hashtbl.add macro2utf8 "varphi" "\207\149"
+let _ = Hashtbl.add macro2utf8 "nsupseteq" "\226\138\137"
+let _ = Hashtbl.add macro2utf8 "circledR" "\194\174"
+let _ = Hashtbl.add macro2utf8 "circledS" "\226\147\136"
+let _ = Hashtbl.add macro2utf8 "primes" "\226\132\153"
+let _ = Hashtbl.add macro2utf8 "cuwed" "\226\139\143"
+let _ = Hashtbl.add macro2utf8 "cupcap" "\226\169\134"
+let _ = Hashtbl.add macro2utf8 "nLl" "\226\139\152\204\184"
+let _ = Hashtbl.add macro2utf8 "lozf" "\226\167\171"
+let _ = Hashtbl.add macro2utf8 "ShortLeftArrow" "\226\134\144\239\184\128"
+let _ = Hashtbl.add macro2utf8 "nLt" "\226\137\170\204\184"
+let _ = Hashtbl.add macro2utf8 "lesdotor" "\226\170\131"
+let _ = Hashtbl.add macro2utf8 "Fcy" "\208\164"
+let _ = Hashtbl.add macro2utf8 "scnsim" "\226\139\169"
let _ = Hashtbl.add macro2utf8 "VerticalLine" "|"
-let _ = Hashtbl.add macro2utf8 "nwArr" "â\135\150"
-let _ = Hashtbl.add macro2utf8 "LeftTeeArrow" "â\134¤"
-let _ = Hashtbl.add macro2utf8 "iprod" "⨼"
-let _ = Hashtbl.add macro2utf8 "lsh" "â\134°"
-let _ = Hashtbl.add macro2utf8 "Congruent" "â\137¡"
-let _ = Hashtbl.add macro2utf8 "NotLeftTriangle" "â\139ª"
-let _ = Hashtbl.add macro2utf8 "rdldhar" "⥩"
-let _ = Hashtbl.add macro2utf8 "varpropto" "â\136\157"
-let _ = Hashtbl.add macro2utf8 "nvlArr" "â\135\141"
+let _ = Hashtbl.add macro2utf8 "nwArr" "\226\135\150"
+let _ = Hashtbl.add macro2utf8 "LeftTeeArrow" "\226\134\164"
+let _ = Hashtbl.add macro2utf8 "iprod" "\226\168\188"
+let _ = Hashtbl.add macro2utf8 "lsh" "\226\134\176"
+let _ = Hashtbl.add macro2utf8 "Congruent" "\226\137\161"
+let _ = Hashtbl.add macro2utf8 "NotLeftTriangle" "\226\139\170"
+let _ = Hashtbl.add macro2utf8 "rdldhar" "\226\165\169"
+let _ = Hashtbl.add macro2utf8 "varpropto" "\226\136\157"
+let _ = Hashtbl.add macro2utf8 "nvlArr" "\226\135\141"
let _ = Hashtbl.add macro2utf8 "arg" "arg"
-let _ = Hashtbl.add macro2utf8 "lhard" "â\134½"
+let _ = Hashtbl.add macro2utf8 "lhard" "\226\134\189"
let _ = Hashtbl.add macro2utf8 "surd" "????"
-let _ = Hashtbl.add macro2utf8 "napos" "Å\137"
-let _ = Hashtbl.add macro2utf8 "lparlt" "â¦\147"
-let _ = Hashtbl.add macro2utf8 "hslash" "â\132\143"
-let _ = Hashtbl.add macro2utf8 "Gopf" "ð\157\148¾"
-let _ = Hashtbl.add macro2utf8 "SHcy" "Ш"
-let _ = Hashtbl.add macro2utf8 "triangle" "â\150µ"
-let _ = Hashtbl.add macro2utf8 "triangle" "â\150µ"
-let _ = Hashtbl.add macro2utf8 "Qfr" "ð\157\148\148"
-let _ = Hashtbl.add macro2utf8 "DiacriticalAcute" "´"
-let _ = Hashtbl.add macro2utf8 "tbrk" "â\142´"
-let _ = Hashtbl.add macro2utf8 "Implies" "â\135\146"
-let _ = Hashtbl.add macro2utf8 "comp" "â\136\129"
-let _ = Hashtbl.add macro2utf8 "ddarr" "â\135\138"
-let _ = Hashtbl.add macro2utf8 "Colone" "⩴"
-let _ = Hashtbl.add macro2utf8 "smashp" "⨳"
-let _ = Hashtbl.add macro2utf8 "ccups" "â©\140"
-let _ = Hashtbl.add macro2utf8 "triangleq" "â\137\156"
-let _ = Hashtbl.add macro2utf8 "NotSquareSubsetEqual" "â\139¢"
-let _ = Hashtbl.add macro2utf8 "Nopf" "â\132\149"
-let _ = Hashtbl.add macro2utf8 "ZHcy" "Ð\150"
-let _ = Hashtbl.add macro2utf8 "map" "â\134¦"
-let _ = Hashtbl.add macro2utf8 "lharu" "â\134¼"
-let _ = Hashtbl.add macro2utf8 "glE" "âª\146"
-let _ = Hashtbl.add macro2utf8 "cong" "â\137\133"
-let _ = Hashtbl.add macro2utf8 "cong" "â\137\133"
-let _ = Hashtbl.add macro2utf8 "Ecaron" "Ä\154"
-let _ = Hashtbl.add macro2utf8 "Uring" "Ů"
-let _ = Hashtbl.add macro2utf8 "blacktriangleright" "â\150¸"
-let _ = Hashtbl.add macro2utf8 "ntilde" "ñ"
+let _ = Hashtbl.add macro2utf8 "napos" "\197\137"
+let _ = Hashtbl.add macro2utf8 "lparlt" "\226\166\147"
+let _ = Hashtbl.add macro2utf8 "hslash" "\226\132\143"
+let _ = Hashtbl.add macro2utf8 "Gopf" "\240\157\148\190"
+let _ = Hashtbl.add macro2utf8 "SHcy" "\208\168"
+let _ = Hashtbl.add macro2utf8 "triangle" "\226\150\181"
+let _ = Hashtbl.add macro2utf8 "triangle" "\226\150\181"
+let _ = Hashtbl.add macro2utf8 "Qfr" "\240\157\148\148"
+let _ = Hashtbl.add macro2utf8 "DiacriticalAcute" "\194\180"
+let _ = Hashtbl.add macro2utf8 "tbrk" "\226\142\180"
+let _ = Hashtbl.add macro2utf8 "Implies" "\226\135\146"
+let _ = Hashtbl.add macro2utf8 "comp" "\226\136\129"
+let _ = Hashtbl.add macro2utf8 "ddarr" "\226\135\138"
+let _ = Hashtbl.add macro2utf8 "Colone" "\226\169\180"
+let _ = Hashtbl.add macro2utf8 "smashp" "\226\168\179"
+let _ = Hashtbl.add macro2utf8 "ccups" "\226\169\140"
+let _ = Hashtbl.add macro2utf8 "triangleq" "\226\137\156"
+let _ = Hashtbl.add macro2utf8 "NotSquareSubsetEqual" "\226\139\162"
+let _ = Hashtbl.add macro2utf8 "Nopf" "\226\132\149"
+let _ = Hashtbl.add macro2utf8 "ZHcy" "\208\150"
+let _ = Hashtbl.add macro2utf8 "map" "\226\134\166"
+let _ = Hashtbl.add macro2utf8 "lharu" "\226\134\188"
+let _ = Hashtbl.add macro2utf8 "glE" "\226\170\146"
+let _ = Hashtbl.add macro2utf8 "cong" "\226\137\133"
+let _ = Hashtbl.add macro2utf8 "cong" "\226\137\133"
+let _ = Hashtbl.add macro2utf8 "Ecaron" "\196\154"
+let _ = Hashtbl.add macro2utf8 "Uring" "\197\174"
+let _ = Hashtbl.add macro2utf8 "blacktriangleright" "\226\150\184"
+let _ = Hashtbl.add macro2utf8 "ntilde" "\195\177"
let _ = Hashtbl.add macro2utf8 "max" "max"
-let _ = Hashtbl.add macro2utf8 "loarr" "â\135½"
-let _ = Hashtbl.add macro2utf8 "LeftArrow" "â\134\144"
-let _ = Hashtbl.add macro2utf8 "Gdot" "Ġ"
-let _ = Hashtbl.add macro2utf8 "bigsqcup" "â\138\148"
-let _ = Hashtbl.add macro2utf8 "Uopf" "ð\157\149\140"
-let _ = Hashtbl.add macro2utf8 "bigsqcup" "â\138\148"
-let _ = Hashtbl.add macro2utf8 "wedgeq" "â\137\153"
-let _ = Hashtbl.add macro2utf8 "RoundImplies" "⥰"
-let _ = Hashtbl.add macro2utf8 "prap" "â\137¾"
-let _ = Hashtbl.add macro2utf8 "gescc" "⪩"
+let _ = Hashtbl.add macro2utf8 "loarr" "\226\135\189"
+let _ = Hashtbl.add macro2utf8 "LeftArrow" "\226\134\144"
+let _ = Hashtbl.add macro2utf8 "Gdot" "\196\160"
+let _ = Hashtbl.add macro2utf8 "bigsqcup" "\226\138\148"
+let _ = Hashtbl.add macro2utf8 "Uopf" "\240\157\149\140"
+let _ = Hashtbl.add macro2utf8 "bigsqcup" "\226\138\148"
+let _ = Hashtbl.add macro2utf8 "wedgeq" "\226\137\153"
+let _ = Hashtbl.add macro2utf8 "RoundImplies" "\226\165\176"
+let _ = Hashtbl.add macro2utf8 "prap" "\226\137\190"
+let _ = Hashtbl.add macro2utf8 "gescc" "\226\170\169"
let _ = Hashtbl.add macro2utf8 "ast" "*"
-let _ = Hashtbl.add macro2utf8 "realine" "â\132\155"
+let _ = Hashtbl.add macro2utf8 "realine" "\226\132\155"
let _ = Hashtbl.add macro2utf8 "ast" "*"
-let _ = Hashtbl.add macro2utf8 "subedot" "â«\131"
-let _ = Hashtbl.add macro2utf8 "LeftTeeVector" "â¥\154"
-let _ = Hashtbl.add macro2utf8 "female" "â\153\128"
-let _ = Hashtbl.add macro2utf8 "circlearrowleft" "â\134º"
-let _ = Hashtbl.add macro2utf8 "Ffr" "ð\157\148\137"
-let _ = Hashtbl.add macro2utf8 "VDash" "â\138«"
-let _ = Hashtbl.add macro2utf8 "jsercy" "Ñ\152"
-let _ = Hashtbl.add macro2utf8 "Proportional" "â\136\157"
-let _ = Hashtbl.add macro2utf8 "OverBracket" "â\142´"
-let _ = Hashtbl.add macro2utf8 "gla" "⪥"
-let _ = Hashtbl.add macro2utf8 "NotElement" "â\136\137"
-let _ = Hashtbl.add macro2utf8 "theta" "θ"
-let _ = Hashtbl.add macro2utf8 "theta" "θ"
-let _ = Hashtbl.add macro2utf8 "kcedil" "ķ"
-let _ = Hashtbl.add macro2utf8 "smeparsl" "⧤"
-let _ = Hashtbl.add macro2utf8 "rarrb" "â\135¥"
-let _ = Hashtbl.add macro2utf8 "rarrc" "⤳"
-let _ = Hashtbl.add macro2utf8 "ograve" "ò"
-let _ = Hashtbl.add macro2utf8 "glj" "⪤"
-let _ = Hashtbl.add macro2utf8 "infty" "â\136\158"
-let _ = Hashtbl.add macro2utf8 "gnE" "â\137©"
-let _ = Hashtbl.add macro2utf8 "copf" "ð\157\149\148"
-let _ = Hashtbl.add macro2utf8 "LeftArrowRightArrow" "â\135\134"
-let _ = Hashtbl.add macro2utf8 "cwconint" "â\136²"
-let _ = Hashtbl.add macro2utf8 "Ascr" "ð\157\146\156"
-let _ = Hashtbl.add macro2utf8 "NegativeThinSpace" "â\128\137ï¸\128"
-let _ = Hashtbl.add macro2utf8 "varsubsetneq" "â\138\138ï¸\128"
-let _ = Hashtbl.add macro2utf8 "trisb" "â§\141"
-let _ = Hashtbl.add macro2utf8 "rightharpoonup" "â\135\128"
-let _ = Hashtbl.add macro2utf8 "imagline" "â\132\144"
-let _ = Hashtbl.add macro2utf8 "mcy" "м"
-let _ = Hashtbl.add macro2utf8 "Cacute" "Ä\134"
-let _ = Hashtbl.add macro2utf8 "bumpeq" "â\137\143"
-let _ = Hashtbl.add macro2utf8 "jopf" "ð\157\149\155"
-let _ = Hashtbl.add macro2utf8 "shchcy" "Ñ\137"
-let _ = Hashtbl.add macro2utf8 "rarrw" "â\134\157"
-let _ = Hashtbl.add macro2utf8 "doteq" "â\137\144"
-let _ = Hashtbl.add macro2utf8 "uuarr" "â\135\136"
-let _ = Hashtbl.add macro2utf8 "doteq" "â\137\144"
-let _ = Hashtbl.add macro2utf8 "cudarrl" "⤸"
-let _ = Hashtbl.add macro2utf8 "varsigma" "Ï\130"
-let _ = Hashtbl.add macro2utf8 "varsigma" "Ï\130"
-let _ = Hashtbl.add macro2utf8 "Hscr" "â\132\139"
-let _ = Hashtbl.add macro2utf8 "DownArrowUpArrow" "â\135µ"
-let _ = Hashtbl.add macro2utf8 "Ecirc" "Ã\138"
-let _ = Hashtbl.add macro2utf8 "DD" "â\133\133"
-let _ = Hashtbl.add macro2utf8 "copy" "©"
-let _ = Hashtbl.add macro2utf8 "SquareIntersection" "â\138\147"
-let _ = Hashtbl.add macro2utf8 "RightUpVector" "â\134¾"
-let _ = Hashtbl.add macro2utf8 "NotSucceedsSlantEqual" "â\139¡"
-let _ = Hashtbl.add macro2utf8 "cudarrr" "⤵"
+let _ = Hashtbl.add macro2utf8 "subedot" "\226\171\131"
+let _ = Hashtbl.add macro2utf8 "LeftTeeVector" "\226\165\154"
+let _ = Hashtbl.add macro2utf8 "female" "\226\153\128"
+let _ = Hashtbl.add macro2utf8 "circlearrowleft" "\226\134\186"
+let _ = Hashtbl.add macro2utf8 "Ffr" "\240\157\148\137"
+let _ = Hashtbl.add macro2utf8 "VDash" "\226\138\171"
+let _ = Hashtbl.add macro2utf8 "jsercy" "\209\152"
+let _ = Hashtbl.add macro2utf8 "Proportional" "\226\136\157"
+let _ = Hashtbl.add macro2utf8 "OverBracket" "\226\142\180"
+let _ = Hashtbl.add macro2utf8 "gla" "\226\170\165"
+let _ = Hashtbl.add macro2utf8 "NotElement" "\226\136\137"
+let _ = Hashtbl.add macro2utf8 "theta" "\206\184"
+let _ = Hashtbl.add macro2utf8 "theta" "\206\184"
+let _ = Hashtbl.add macro2utf8 "kcedil" "\196\183"
+let _ = Hashtbl.add macro2utf8 "smeparsl" "\226\167\164"
+let _ = Hashtbl.add macro2utf8 "rarrb" "\226\135\165"
+let _ = Hashtbl.add macro2utf8 "rarrc" "\226\164\179"
+let _ = Hashtbl.add macro2utf8 "ograve" "\195\178"
+let _ = Hashtbl.add macro2utf8 "glj" "\226\170\164"
+let _ = Hashtbl.add macro2utf8 "infty" "\226\136\158"
+let _ = Hashtbl.add macro2utf8 "gnE" "\226\137\169"
+let _ = Hashtbl.add macro2utf8 "copf" "\240\157\149\148"
+let _ = Hashtbl.add macro2utf8 "LeftArrowRightArrow" "\226\135\134"
+let _ = Hashtbl.add macro2utf8 "cwconint" "\226\136\178"
+let _ = Hashtbl.add macro2utf8 "Ascr" "\240\157\146\156"
+let _ = Hashtbl.add macro2utf8 "NegativeThinSpace" "\226\128\137\239\184\128"
+let _ = Hashtbl.add macro2utf8 "varsubsetneq" "\226\138\138\239\184\128"
+let _ = Hashtbl.add macro2utf8 "trisb" "\226\167\141"
+let _ = Hashtbl.add macro2utf8 "rightharpoonup" "\226\135\128"
+let _ = Hashtbl.add macro2utf8 "imagline" "\226\132\144"
+let _ = Hashtbl.add macro2utf8 "mcy" "\208\188"
+let _ = Hashtbl.add macro2utf8 "Cacute" "\196\134"
+let _ = Hashtbl.add macro2utf8 "bumpeq" "\226\137\143"
+let _ = Hashtbl.add macro2utf8 "jopf" "\240\157\149\155"
+let _ = Hashtbl.add macro2utf8 "shchcy" "\209\137"
+let _ = Hashtbl.add macro2utf8 "rarrw" "\226\134\157"
+let _ = Hashtbl.add macro2utf8 "doteq" "\226\137\144"
+let _ = Hashtbl.add macro2utf8 "uuarr" "\226\135\136"
+let _ = Hashtbl.add macro2utf8 "doteq" "\226\137\144"
+let _ = Hashtbl.add macro2utf8 "cudarrl" "\226\164\184"
+let _ = Hashtbl.add macro2utf8 "varsigma" "\207\130"
+let _ = Hashtbl.add macro2utf8 "varsigma" "\207\130"
+let _ = Hashtbl.add macro2utf8 "Hscr" "\226\132\139"
+let _ = Hashtbl.add macro2utf8 "DownArrowUpArrow" "\226\135\181"
+let _ = Hashtbl.add macro2utf8 "Ecirc" "\195\138"
+let _ = Hashtbl.add macro2utf8 "DD" "\226\133\133"
+let _ = Hashtbl.add macro2utf8 "copy" "\194\169"
+let _ = Hashtbl.add macro2utf8 "SquareIntersection" "\226\138\147"
+let _ = Hashtbl.add macro2utf8 "RightUpVector" "\226\134\190"
+let _ = Hashtbl.add macro2utf8 "NotSucceedsSlantEqual" "\226\139\161"
+let _ = Hashtbl.add macro2utf8 "cudarrr" "\226\164\181"
let _ = Hashtbl.add macro2utf8 "verbar" "|"
-let _ = Hashtbl.add macro2utf8 "ncaron" "Å\136"
-let _ = Hashtbl.add macro2utf8 "cdot" "Ä\139"
-let _ = Hashtbl.add macro2utf8 "prurel" "â\138°"
-let _ = Hashtbl.add macro2utf8 "nearr" "â\134\151"
-let _ = Hashtbl.add macro2utf8 "cdot" "Ä\139"
-let _ = Hashtbl.add macro2utf8 "qopf" "ð\157\149¢"
-let _ = Hashtbl.add macro2utf8 "SucceedsSlantEqual" "â\137½"
-let _ = Hashtbl.add macro2utf8 "Oscr" "ð\157\146ª"
-let _ = Hashtbl.add macro2utf8 "xfr" "ð\157\148µ"
-let _ = Hashtbl.add macro2utf8 "gne" "â\137©"
-let _ = Hashtbl.add macro2utf8 "Ccedil" "Ã\135"
-let _ = Hashtbl.add macro2utf8 "nlarr" "â\134\154"
-let _ = Hashtbl.add macro2utf8 "inodot" "ı"
-let _ = Hashtbl.add macro2utf8 "prec" "â\137º"
-let _ = Hashtbl.add macro2utf8 "prec" "â\137º"
+let _ = Hashtbl.add macro2utf8 "ncaron" "\197\136"
+let _ = Hashtbl.add macro2utf8 "cdot" "\196\139"
+let _ = Hashtbl.add macro2utf8 "prurel" "\226\138\176"
+let _ = Hashtbl.add macro2utf8 "nearr" "\226\134\151"
+let _ = Hashtbl.add macro2utf8 "cdot" "\196\139"
+let _ = Hashtbl.add macro2utf8 "qopf" "\240\157\149\162"
+let _ = Hashtbl.add macro2utf8 "SucceedsSlantEqual" "\226\137\189"
+let _ = Hashtbl.add macro2utf8 "Oscr" "\240\157\146\170"
+let _ = Hashtbl.add macro2utf8 "xfr" "\240\157\148\181"
+let _ = Hashtbl.add macro2utf8 "gne" "\226\137\169"
+let _ = Hashtbl.add macro2utf8 "Ccedil" "\195\135"
+let _ = Hashtbl.add macro2utf8 "nlarr" "\226\134\154"
+let _ = Hashtbl.add macro2utf8 "inodot" "\196\177"
+let _ = Hashtbl.add macro2utf8 "prec" "\226\137\186"
+let _ = Hashtbl.add macro2utf8 "prec" "\226\137\186"
let _ = Hashtbl.add macro2utf8 "percnt" "%"
-let _ = Hashtbl.add macro2utf8 "Exists" "â\136\131"
-let _ = Hashtbl.add macro2utf8 "bcy" "б"
-let _ = Hashtbl.add macro2utf8 "xopf" "ð\157\149©"
-let _ = Hashtbl.add macro2utf8 "nsimeq" "â\137\132"
-let _ = Hashtbl.add macro2utf8 "nrtri" "â\139«"
-let _ = Hashtbl.add macro2utf8 "barvee" "â\138½"
-let _ = Hashtbl.add macro2utf8 "Vscr" "ð\157\146±"
-let _ = Hashtbl.add macro2utf8 "Zcaron" "Ž"
-let _ = Hashtbl.add macro2utf8 "ReverseElement" "â\136\139"
-let _ = Hashtbl.add macro2utf8 "npolint" "â¨\148"
-let _ = Hashtbl.add macro2utf8 "NotGreaterTilde" "â\137µ"
-let _ = Hashtbl.add macro2utf8 "lmoustache" "â\142°"
-let _ = Hashtbl.add macro2utf8 "forkv" "â«\153"
-let _ = Hashtbl.add macro2utf8 "rmoustache" "â\142±"
-let _ = Hashtbl.add macro2utf8 "DownLeftVectorBar" "â¥\150"
+let _ = Hashtbl.add macro2utf8 "Exists" "\226\136\131"
+let _ = Hashtbl.add macro2utf8 "bcy" "\208\177"
+let _ = Hashtbl.add macro2utf8 "xopf" "\240\157\149\169"
+let _ = Hashtbl.add macro2utf8 "nsimeq" "\226\137\132"
+let _ = Hashtbl.add macro2utf8 "nrtri" "\226\139\171"
+let _ = Hashtbl.add macro2utf8 "barvee" "\226\138\189"
+let _ = Hashtbl.add macro2utf8 "Vscr" "\240\157\146\177"
+let _ = Hashtbl.add macro2utf8 "Zcaron" "\197\189"
+let _ = Hashtbl.add macro2utf8 "ReverseElement" "\226\136\139"
+let _ = Hashtbl.add macro2utf8 "npolint" "\226\168\148"
+let _ = Hashtbl.add macro2utf8 "NotGreaterTilde" "\226\137\181"
+let _ = Hashtbl.add macro2utf8 "lmoustache" "\226\142\176"
+let _ = Hashtbl.add macro2utf8 "forkv" "\226\171\153"
+let _ = Hashtbl.add macro2utf8 "rmoustache" "\226\142\177"
+let _ = Hashtbl.add macro2utf8 "DownLeftVectorBar" "\226\165\150"
let _ = Hashtbl.add macro2utf8 "cosh" "cosh"
-let _ = Hashtbl.add macro2utf8 "mfr" "ð\157\148ª"
-let _ = Hashtbl.add macro2utf8 "LessGreater" "â\137¶"
-let _ = Hashtbl.add macro2utf8 "zeetrf" "â\132¨"
-let _ = Hashtbl.add macro2utf8 "DiacriticalDot" "Ë\153"
-let _ = Hashtbl.add macro2utf8 "Poincareplane" "â\132\140"
-let _ = Hashtbl.add macro2utf8 "curlyeqsucc" "â\139\159"
-let _ = Hashtbl.add macro2utf8 "Equal" "⩵"
-let _ = Hashtbl.add macro2utf8 "scpolint" "â¨\147"
-let _ = Hashtbl.add macro2utf8 "ngsim" "â\137µ"
-let _ = Hashtbl.add macro2utf8 "larrbfs" "â¤\159"
-let _ = Hashtbl.add macro2utf8 "HilbertSpace" "â\132\139"
-let _ = Hashtbl.add macro2utf8 "otilde" "õ"
-let _ = Hashtbl.add macro2utf8 "larrb" "â\135¤"
-let _ = Hashtbl.add macro2utf8 "wcirc" "ŵ"
-let _ = Hashtbl.add macro2utf8 "dscr" "ð\157\146¹"
-let _ = Hashtbl.add macro2utf8 "phmmat" "â\132³"
-let _ = Hashtbl.add macro2utf8 "lacute" "ĺ"
-let _ = Hashtbl.add macro2utf8 "tstrok" "ŧ"
-let _ = Hashtbl.add macro2utf8 "NotDoubleVerticalBar" "â\136¦"
-let _ = Hashtbl.add macro2utf8 "lagran" "â\132\146"
-let _ = Hashtbl.add macro2utf8 "NotRightTriangle" "â\139«"
-let _ = Hashtbl.add macro2utf8 "dscy" "Ñ\149"
-let _ = Hashtbl.add macro2utf8 "rightrightarrows" "â\135\137"
-let _ = Hashtbl.add macro2utf8 "seArr" "â\135\152"
-let _ = Hashtbl.add macro2utf8 "RightTriangleBar" "â§\144"
+let _ = Hashtbl.add macro2utf8 "mfr" "\240\157\148\170"
+let _ = Hashtbl.add macro2utf8 "LessGreater" "\226\137\182"
+let _ = Hashtbl.add macro2utf8 "zeetrf" "\226\132\168"
+let _ = Hashtbl.add macro2utf8 "DiacriticalDot" "\203\153"
+let _ = Hashtbl.add macro2utf8 "Poincareplane" "\226\132\140"
+let _ = Hashtbl.add macro2utf8 "curlyeqsucc" "\226\139\159"
+let _ = Hashtbl.add macro2utf8 "Equal" "\226\169\181"
+let _ = Hashtbl.add macro2utf8 "scpolint" "\226\168\147"
+let _ = Hashtbl.add macro2utf8 "ngsim" "\226\137\181"
+let _ = Hashtbl.add macro2utf8 "larrbfs" "\226\164\159"
+let _ = Hashtbl.add macro2utf8 "HilbertSpace" "\226\132\139"
+let _ = Hashtbl.add macro2utf8 "otilde" "\195\181"
+let _ = Hashtbl.add macro2utf8 "larrb" "\226\135\164"
+let _ = Hashtbl.add macro2utf8 "wcirc" "\197\181"
+let _ = Hashtbl.add macro2utf8 "dscr" "\240\157\146\185"
+let _ = Hashtbl.add macro2utf8 "phmmat" "\226\132\179"
+let _ = Hashtbl.add macro2utf8 "lacute" "\196\186"
+let _ = Hashtbl.add macro2utf8 "tstrok" "\197\167"
+let _ = Hashtbl.add macro2utf8 "NotDoubleVerticalBar" "\226\136\166"
+let _ = Hashtbl.add macro2utf8 "lagran" "\226\132\146"
+let _ = Hashtbl.add macro2utf8 "NotRightTriangle" "\226\139\171"
+let _ = Hashtbl.add macro2utf8 "dscy" "\209\149"
+let _ = Hashtbl.add macro2utf8 "rightrightarrows" "\226\135\137"
+let _ = Hashtbl.add macro2utf8 "seArr" "\226\135\152"
+let _ = Hashtbl.add macro2utf8 "RightTriangleBar" "\226\167\144"
let _ = Hashtbl.add macro2utf8 "coth" "coth"
-let _ = Hashtbl.add macro2utf8 "swarrow" "â\134\153"
-let _ = Hashtbl.add macro2utf8 "swarrow" "â\134\153"
+let _ = Hashtbl.add macro2utf8 "swarrow" "\226\134\153"
+let _ = Hashtbl.add macro2utf8 "swarrow" "\226\134\153"
let _ = Hashtbl.add macro2utf8 "semi" ";"
-let _ = Hashtbl.add macro2utf8 "kscr" "ð\157\147\128"
-let _ = Hashtbl.add macro2utf8 "NotLessEqual" "â\137°â\131¥"
-let _ = Hashtbl.add macro2utf8 "cularr" "â\134¶"
-let _ = Hashtbl.add macro2utf8 "blacklozenge" "⧫"
-let _ = Hashtbl.add macro2utf8 "realpart" "â\132\156"
-let _ = Hashtbl.add macro2utf8 "LeftTriangleEqual" "â\138´"
-let _ = Hashtbl.add macro2utf8 "bfr" "ð\157\148\159"
-let _ = Hashtbl.add macro2utf8 "Uuml" "Ã\156"
+let _ = Hashtbl.add macro2utf8 "kscr" "\240\157\147\128"
+let _ = Hashtbl.add macro2utf8 "NotLessEqual" "\226\137\176\226\131\165"
+let _ = Hashtbl.add macro2utf8 "cularr" "\226\134\182"
+let _ = Hashtbl.add macro2utf8 "blacklozenge" "\226\167\171"
+let _ = Hashtbl.add macro2utf8 "realpart" "\226\132\156"
+let _ = Hashtbl.add macro2utf8 "LeftTriangleEqual" "\226\138\180"
+let _ = Hashtbl.add macro2utf8 "bfr" "\240\157\148\159"
+let _ = Hashtbl.add macro2utf8 "Uuml" "\195\156"
let _ = Hashtbl.add macro2utf8 "longleftrightarrow" "????"
-let _ = Hashtbl.add macro2utf8 "longleftrightarrow" "ï\149¸"
-let _ = Hashtbl.add macro2utf8 "lcedil" "ļ"
-let _ = Hashtbl.add macro2utf8 "complement" "â\136\129"
-let _ = Hashtbl.add macro2utf8 "rscr" "ð\157\147\135"
-let _ = Hashtbl.add macro2utf8 "mho" "â\132§"
-let _ = Hashtbl.add macro2utf8 "mcomma" "⨩"
-let _ = Hashtbl.add macro2utf8 "wedbar" "â©\159"
-let _ = Hashtbl.add macro2utf8 "NotVerticalBar" "â\136¤"
-let _ = Hashtbl.add macro2utf8 "Lcy" "Ð\155"
-let _ = Hashtbl.add macro2utf8 "Downarrow" "â\135\147"
-let _ = Hashtbl.add macro2utf8 "tprime" "â\128´"
-let _ = Hashtbl.add macro2utf8 "precneqq" "⪵"
-let _ = Hashtbl.add macro2utf8 "Downarrow" "â\135\147"
-let _ = Hashtbl.add macro2utf8 "rsh" "â\134±"
-let _ = Hashtbl.add macro2utf8 "mid" "â\136£"
-let _ = Hashtbl.add macro2utf8 "mid" "â\136£"
-let _ = Hashtbl.add macro2utf8 "blank" "â\144£"
-let _ = Hashtbl.add macro2utf8 "square" "â\150¡"
-let _ = Hashtbl.add macro2utf8 "squarf" "â\150ª"
-let _ = Hashtbl.add macro2utf8 "fflig" "ï¬\128"
-let _ = Hashtbl.add macro2utf8 "downdownarrows" "â\135\138"
-let _ = Hashtbl.add macro2utf8 "yscr" "ð\157\147\142"
-let _ = Hashtbl.add macro2utf8 "subdot" "⪽"
-let _ = Hashtbl.add macro2utf8 "ShortRightArrow" "â\134\146ï¸\128"
-let _ = Hashtbl.add macro2utf8 "NotCongruent" "â\137¢"
-let _ = Hashtbl.add macro2utf8 "Gg" "â\139\153"
-let _ = Hashtbl.add macro2utf8 "Lstrok" "Å\129"
+let _ = Hashtbl.add macro2utf8 "longleftrightarrow" "\239\149\184"
+let _ = Hashtbl.add macro2utf8 "lcedil" "\196\188"
+let _ = Hashtbl.add macro2utf8 "complement" "\226\136\129"
+let _ = Hashtbl.add macro2utf8 "rscr" "\240\157\147\135"
+let _ = Hashtbl.add macro2utf8 "mho" "\226\132\167"
+let _ = Hashtbl.add macro2utf8 "mcomma" "\226\168\169"
+let _ = Hashtbl.add macro2utf8 "wedbar" "\226\169\159"
+let _ = Hashtbl.add macro2utf8 "NotVerticalBar" "\226\136\164"
+let _ = Hashtbl.add macro2utf8 "Lcy" "\208\155"
+let _ = Hashtbl.add macro2utf8 "Downarrow" "\226\135\147"
+let _ = Hashtbl.add macro2utf8 "tprime" "\226\128\180"
+let _ = Hashtbl.add macro2utf8 "precneqq" "\226\170\181"
+let _ = Hashtbl.add macro2utf8 "Downarrow" "\226\135\147"
+let _ = Hashtbl.add macro2utf8 "rsh" "\226\134\177"
+let _ = Hashtbl.add macro2utf8 "mid" "\226\136\163"
+let _ = Hashtbl.add macro2utf8 "mid" "\226\136\163"
+let _ = Hashtbl.add macro2utf8 "blank" "\226\144\163"
+let _ = Hashtbl.add macro2utf8 "square" "\226\150\161"
+let _ = Hashtbl.add macro2utf8 "squarf" "\226\150\170"
+let _ = Hashtbl.add macro2utf8 "fflig" "\239\172\128"
+let _ = Hashtbl.add macro2utf8 "downdownarrows" "\226\135\138"
+let _ = Hashtbl.add macro2utf8 "yscr" "\240\157\147\142"
+let _ = Hashtbl.add macro2utf8 "subdot" "\226\170\189"
+let _ = Hashtbl.add macro2utf8 "ShortRightArrow" "\226\134\146\239\184\128"
+let _ = Hashtbl.add macro2utf8 "NotCongruent" "\226\137\162"
+let _ = Hashtbl.add macro2utf8 "Gg" "\226\139\153"
+let _ = Hashtbl.add macro2utf8 "Lstrok" "\197\129"
let _ = Hashtbl.add macro2utf8 "min" "max"
-let _ = Hashtbl.add macro2utf8 "Laplacetrf" "â\132\146"
-let _ = Hashtbl.add macro2utf8 "rarrap" "⥵"
-let _ = Hashtbl.add macro2utf8 "NotLessSlantEqual" "â\137°"
-let _ = Hashtbl.add macro2utf8 "DoubleRightArrow" "â\135\146"
-let _ = Hashtbl.add macro2utf8 "Wfr" "ð\157\148\154"
-let _ = Hashtbl.add macro2utf8 "subrarr" "⥹"
-let _ = Hashtbl.add macro2utf8 "numsp" "â\128\135"
-let _ = Hashtbl.add macro2utf8 "khcy" "Ñ\133"
-let _ = Hashtbl.add macro2utf8 "oint" "â\136®"
-let _ = Hashtbl.add macro2utf8 "oint" "â\136®"
-let _ = Hashtbl.add macro2utf8 "vprop" "â\136\157"
-let _ = Hashtbl.add macro2utf8 "hardcy" "Ñ\138"
-let _ = Hashtbl.add macro2utf8 "boxminus" "â\138\159"
-let _ = Hashtbl.add macro2utf8 "GreaterLess" "â\137·"
-let _ = Hashtbl.add macro2utf8 "thetav" "Ï\145"
-let _ = Hashtbl.add macro2utf8 "scE" "â\137¾"
-let _ = Hashtbl.add macro2utf8 "Gt" "â\137«"
-let _ = Hashtbl.add macro2utf8 "Acy" "Ð\144"
-let _ = Hashtbl.add macro2utf8 "backcong" "â\137\140"
-let _ = Hashtbl.add macro2utf8 "gtquest" "⩼"
-let _ = Hashtbl.add macro2utf8 "awint" "â¨\145"
-let _ = Hashtbl.add macro2utf8 "profsurf" "â\140\147"
-let _ = Hashtbl.add macro2utf8 "capdot" "â©\128"
-let _ = Hashtbl.add macro2utf8 "supdot" "⪾"
-let _ = Hashtbl.add macro2utf8 "oelig" "Å\147"
-let _ = Hashtbl.add macro2utf8 "doteqdot" "â\137\145"
-let _ = Hashtbl.add macro2utf8 "rharul" "⥬"
-let _ = Hashtbl.add macro2utf8 "cylcty" "â\140"
-let _ = Hashtbl.add macro2utf8 "epsi" "ε"
-let _ = Hashtbl.add macro2utf8 "eqcirc" "â\137\150"
-let _ = Hashtbl.add macro2utf8 "nLeftarrow" "â\135\141"
-let _ = Hashtbl.add macro2utf8 "rtrie" "â\138µ"
-let _ = Hashtbl.add macro2utf8 "para" "¶"
-let _ = Hashtbl.add macro2utf8 "Lfr" "ð\157\148\143"
-let _ = Hashtbl.add macro2utf8 "rtrif" "â\150¸"
-let _ = Hashtbl.add macro2utf8 "NotReverseElement" "â\136\140"
-let _ = Hashtbl.add macro2utf8 "emptyv" "â\136\133"
-let _ = Hashtbl.add macro2utf8 "nldr" "â\128¥"
-let _ = Hashtbl.add macro2utf8 "leqq" "â\137¦"
-let _ = Hashtbl.add macro2utf8 "CapitalDifferentialD" "â\133\133"
-let _ = Hashtbl.add macro2utf8 "supsetneqq" "â\138\139"
-let _ = Hashtbl.add macro2utf8 "boxDL" "â\149\151"
-let _ = Hashtbl.add macro2utf8 "Im" "â\132\145"
-let _ = Hashtbl.add macro2utf8 "Im" "â\132\145"
-let _ = Hashtbl.add macro2utf8 "sce" "â\137½"
-let _ = Hashtbl.add macro2utf8 "prsim" "â\137¾"
-let _ = Hashtbl.add macro2utf8 "diams" "â\153¦"
-let _ = Hashtbl.add macro2utf8 "gtreqqless" "â\139\155"
-let _ = Hashtbl.add macro2utf8 "boxDR" "â\149\148"
-let _ = Hashtbl.add macro2utf8 "vartriangleleft" "â\138²"
-let _ = Hashtbl.add macro2utf8 "Omega" "Ω"
-let _ = Hashtbl.add macro2utf8 "SupersetEqual" "â\138\135"
-let _ = Hashtbl.add macro2utf8 "Omega" "Ω"
-let _ = Hashtbl.add macro2utf8 "nsubseteqq" "â\138\136"
-let _ = Hashtbl.add macro2utf8 "Subset" "â\139\144"
-let _ = Hashtbl.add macro2utf8 "ncongdot" "⩭̸"
-let _ = Hashtbl.add macro2utf8 "minusb" "â\138\159"
-let _ = Hashtbl.add macro2utf8 "ltimes" "â\139\137"
-let _ = Hashtbl.add macro2utf8 "seswar" "⤩"
-let _ = Hashtbl.add macro2utf8 "part" "â\136\130"
-let _ = Hashtbl.add macro2utf8 "bumpE" "⪮"
-let _ = Hashtbl.add macro2utf8 "minusd" "â\136¸"
-let _ = Hashtbl.add macro2utf8 "Amacr" "Ä\128"
-let _ = Hashtbl.add macro2utf8 "nleq" "â\137°â\131¥"
-let _ = Hashtbl.add macro2utf8 "nles" "â\137°"
-let _ = Hashtbl.add macro2utf8 "NotLess" "â\137®"
-let _ = Hashtbl.add macro2utf8 "scy" "Ñ\129"
-let _ = Hashtbl.add macro2utf8 "iinfin" "â§\156"
-let _ = Hashtbl.add macro2utf8 "Afr" "ð\157\148\132"
-let _ = Hashtbl.add macro2utf8 "isinsv" "â\139³"
-let _ = Hashtbl.add macro2utf8 "prnE" "⪵"
-let _ = Hashtbl.add macro2utf8 "lesg" "â\139\154ï¸\128"
-let _ = Hashtbl.add macro2utf8 "cups" "â\136ªï¸\128"
-let _ = Hashtbl.add macro2utf8 "thickapprox" "â\137\136ï¸\128"
-let _ = Hashtbl.add macro2utf8 "RightTeeVector" "â¥\155"
-let _ = Hashtbl.add macro2utf8 "LowerLeftArrow" "â\134\153"
-let _ = Hashtbl.add macro2utf8 "bowtie" "â\139\136"
-let _ = Hashtbl.add macro2utf8 "utdot" "â\139°"
-let _ = Hashtbl.add macro2utf8 "homtht" "â\136»"
-let _ = Hashtbl.add macro2utf8 "ddotseq" "⩷"
-let _ = Hashtbl.add macro2utf8 "bowtie" "â\139\136"
-let _ = Hashtbl.add macro2utf8 "succnsim" "â\139©"
-let _ = Hashtbl.add macro2utf8 "boxDl" "â\149\150"
+let _ = Hashtbl.add macro2utf8 "Laplacetrf" "\226\132\146"
+let _ = Hashtbl.add macro2utf8 "rarrap" "\226\165\181"
+let _ = Hashtbl.add macro2utf8 "NotLessSlantEqual" "\226\137\176"
+let _ = Hashtbl.add macro2utf8 "DoubleRightArrow" "\226\135\146"
+let _ = Hashtbl.add macro2utf8 "Wfr" "\240\157\148\154"
+let _ = Hashtbl.add macro2utf8 "subrarr" "\226\165\185"
+let _ = Hashtbl.add macro2utf8 "numsp" "\226\128\135"
+let _ = Hashtbl.add macro2utf8 "khcy" "\209\133"
+let _ = Hashtbl.add macro2utf8 "oint" "\226\136\174"
+let _ = Hashtbl.add macro2utf8 "oint" "\226\136\174"
+let _ = Hashtbl.add macro2utf8 "vprop" "\226\136\157"
+let _ = Hashtbl.add macro2utf8 "hardcy" "\209\138"
+let _ = Hashtbl.add macro2utf8 "boxminus" "\226\138\159"
+let _ = Hashtbl.add macro2utf8 "GreaterLess" "\226\137\183"
+let _ = Hashtbl.add macro2utf8 "thetav" "\207\145"
+let _ = Hashtbl.add macro2utf8 "scE" "\226\137\190"
+let _ = Hashtbl.add macro2utf8 "Gt" "\226\137\171"
+let _ = Hashtbl.add macro2utf8 "Acy" "\208\144"
+let _ = Hashtbl.add macro2utf8 "backcong" "\226\137\140"
+let _ = Hashtbl.add macro2utf8 "gtquest" "\226\169\188"
+let _ = Hashtbl.add macro2utf8 "awint" "\226\168\145"
+let _ = Hashtbl.add macro2utf8 "profsurf" "\226\140\147"
+let _ = Hashtbl.add macro2utf8 "capdot" "\226\169\128"
+let _ = Hashtbl.add macro2utf8 "supdot" "\226\170\190"
+let _ = Hashtbl.add macro2utf8 "oelig" "\197\147"
+let _ = Hashtbl.add macro2utf8 "doteqdot" "\226\137\145"
+let _ = Hashtbl.add macro2utf8 "rharul" "\226\165\172"
+let _ = Hashtbl.add macro2utf8 "cylcty" "\226\140\173"
+let _ = Hashtbl.add macro2utf8 "epsi" "\206\181"
+let _ = Hashtbl.add macro2utf8 "eqcirc" "\226\137\150"
+let _ = Hashtbl.add macro2utf8 "nLeftarrow" "\226\135\141"
+let _ = Hashtbl.add macro2utf8 "rtrie" "\226\138\181"
+let _ = Hashtbl.add macro2utf8 "para" "\194\182"
+let _ = Hashtbl.add macro2utf8 "Lfr" "\240\157\148\143"
+let _ = Hashtbl.add macro2utf8 "rtrif" "\226\150\184"
+let _ = Hashtbl.add macro2utf8 "NotReverseElement" "\226\136\140"
+let _ = Hashtbl.add macro2utf8 "emptyv" "\226\136\133"
+let _ = Hashtbl.add macro2utf8 "nldr" "\226\128\165"
+let _ = Hashtbl.add macro2utf8 "leqq" "\226\137\166"
+let _ = Hashtbl.add macro2utf8 "CapitalDifferentialD" "\226\133\133"
+let _ = Hashtbl.add macro2utf8 "supsetneqq" "\226\138\139"
+let _ = Hashtbl.add macro2utf8 "boxDL" "\226\149\151"
+let _ = Hashtbl.add macro2utf8 "Im" "\226\132\145"
+let _ = Hashtbl.add macro2utf8 "Im" "\226\132\145"
+let _ = Hashtbl.add macro2utf8 "sce" "\226\137\189"
+let _ = Hashtbl.add macro2utf8 "prsim" "\226\137\190"
+let _ = Hashtbl.add macro2utf8 "diams" "\226\153\166"
+let _ = Hashtbl.add macro2utf8 "gtreqqless" "\226\139\155"
+let _ = Hashtbl.add macro2utf8 "boxDR" "\226\149\148"
+let _ = Hashtbl.add macro2utf8 "vartriangleleft" "\226\138\178"
+let _ = Hashtbl.add macro2utf8 "Omega" "\206\169"
+let _ = Hashtbl.add macro2utf8 "SupersetEqual" "\226\138\135"
+let _ = Hashtbl.add macro2utf8 "Omega" "\206\169"
+let _ = Hashtbl.add macro2utf8 "nsubseteqq" "\226\138\136"
+let _ = Hashtbl.add macro2utf8 "Subset" "\226\139\144"
+let _ = Hashtbl.add macro2utf8 "ncongdot" "\226\169\173\204\184"
+let _ = Hashtbl.add macro2utf8 "minusb" "\226\138\159"
+let _ = Hashtbl.add macro2utf8 "ltimes" "\226\139\137"
+let _ = Hashtbl.add macro2utf8 "seswar" "\226\164\169"
+let _ = Hashtbl.add macro2utf8 "part" "\226\136\130"
+let _ = Hashtbl.add macro2utf8 "bumpE" "\226\170\174"
+let _ = Hashtbl.add macro2utf8 "minusd" "\226\136\184"
+let _ = Hashtbl.add macro2utf8 "Amacr" "\196\128"
+let _ = Hashtbl.add macro2utf8 "nleq" "\226\137\176\226\131\165"
+let _ = Hashtbl.add macro2utf8 "nles" "\226\137\176"
+let _ = Hashtbl.add macro2utf8 "NotLess" "\226\137\174"
+let _ = Hashtbl.add macro2utf8 "scy" "\209\129"
+let _ = Hashtbl.add macro2utf8 "iinfin" "\226\167\156"
+let _ = Hashtbl.add macro2utf8 "Afr" "\240\157\148\132"
+let _ = Hashtbl.add macro2utf8 "isinsv" "\226\139\179"
+let _ = Hashtbl.add macro2utf8 "prnE" "\226\170\181"
+let _ = Hashtbl.add macro2utf8 "lesg" "\226\139\154\239\184\128"
+let _ = Hashtbl.add macro2utf8 "cups" "\226\136\170\239\184\128"
+let _ = Hashtbl.add macro2utf8 "thickapprox" "\226\137\136\239\184\128"
+let _ = Hashtbl.add macro2utf8 "RightTeeVector" "\226\165\155"
+let _ = Hashtbl.add macro2utf8 "LowerLeftArrow" "\226\134\153"
+let _ = Hashtbl.add macro2utf8 "bowtie" "\226\139\136"
+let _ = Hashtbl.add macro2utf8 "utdot" "\226\139\176"
+let _ = Hashtbl.add macro2utf8 "homtht" "\226\136\187"
+let _ = Hashtbl.add macro2utf8 "ddotseq" "\226\169\183"
+let _ = Hashtbl.add macro2utf8 "bowtie" "\226\139\136"
+let _ = Hashtbl.add macro2utf8 "succnsim" "\226\139\169"
+let _ = Hashtbl.add macro2utf8 "boxDl" "\226\149\150"
let _ = Hashtbl.add macro2utf8 "quot" "\""
-let _ = Hashtbl.add macro2utf8 "lvnE" "â\137¨ï¸\128"
-let _ = Hashtbl.add macro2utf8 "CircleDot" "â\138\153"
-let _ = Hashtbl.add macro2utf8 "lsime" "âª\141"
-let _ = Hashtbl.add macro2utf8 "Yacute" "Ã\157"
-let _ = Hashtbl.add macro2utf8 "esdot" "â\137\144"
-let _ = Hashtbl.add macro2utf8 "Supset" "â\139\145"
-let _ = Hashtbl.add macro2utf8 "lsimg" "âª\143"
-let _ = Hashtbl.add macro2utf8 "eDot" "â\137\145"
+let _ = Hashtbl.add macro2utf8 "lvnE" "\226\137\168\239\184\128"
+let _ = Hashtbl.add macro2utf8 "CircleDot" "\226\138\153"
+let _ = Hashtbl.add macro2utf8 "lsime" "\226\170\141"
+let _ = Hashtbl.add macro2utf8 "Yacute" "\195\157"
+let _ = Hashtbl.add macro2utf8 "esdot" "\226\137\144"
+let _ = Hashtbl.add macro2utf8 "Supset" "\226\139\145"
+let _ = Hashtbl.add macro2utf8 "lsimg" "\226\170\143"
+let _ = Hashtbl.add macro2utf8 "eDot" "\226\137\145"
let _ = Hashtbl.add macro2utf8 "sec" "sec"
-let _ = Hashtbl.add macro2utf8 "boxDr" "â\149\147"
-let _ = Hashtbl.add macro2utf8 "ddagger" "â\128¡"
+let _ = Hashtbl.add macro2utf8 "boxDr" "\226\149\147"
+let _ = Hashtbl.add macro2utf8 "ddagger" "\226\128\161"
let _ = Hashtbl.add macro2utf8 "plus" "+"
-let _ = Hashtbl.add macro2utf8 "ddagger" "â\128¡"
-let _ = Hashtbl.add macro2utf8 "Vdashl" "⫦"
-let _ = Hashtbl.add macro2utf8 "equest" "â\137\159"
+let _ = Hashtbl.add macro2utf8 "ddagger" "\226\128\161"
+let _ = Hashtbl.add macro2utf8 "Vdashl" "\226\171\166"
+let _ = Hashtbl.add macro2utf8 "equest" "\226\137\159"
let _ = Hashtbl.add macro2utf8 "quest" "?"
-let _ = Hashtbl.add macro2utf8 "divideontimes" "â\139\135"
-let _ = Hashtbl.add macro2utf8 "nsmid" "â\136¤ï¸\128"
-let _ = Hashtbl.add macro2utf8 "fnof" "Æ\146"
-let _ = Hashtbl.add macro2utf8 "bumpe" "â\137\143"
-let _ = Hashtbl.add macro2utf8 "lhblk" "â\150\132"
-let _ = Hashtbl.add macro2utf8 "prnap" "â\139¨"
-let _ = Hashtbl.add macro2utf8 "compfn" "â\136\152"
-let _ = Hashtbl.add macro2utf8 "nsucceq" "⪰̸"
-let _ = Hashtbl.add macro2utf8 "RightArrowLeftArrow" "â\135\132"
-let _ = Hashtbl.add macro2utf8 "sharp" "â\153¯"
-let _ = Hashtbl.add macro2utf8 "sharp" "â\153¯"
-let _ = Hashtbl.add macro2utf8 "CHcy" "Ч"
-let _ = Hashtbl.add macro2utf8 "dwangle" "⦦"
-let _ = Hashtbl.add macro2utf8 "angrtvbd" "â¦\157"
+let _ = Hashtbl.add macro2utf8 "divideontimes" "\226\139\135"
+let _ = Hashtbl.add macro2utf8 "nsmid" "\226\136\164\239\184\128"
+let _ = Hashtbl.add macro2utf8 "fnof" "\198\146"
+let _ = Hashtbl.add macro2utf8 "bumpe" "\226\137\143"
+let _ = Hashtbl.add macro2utf8 "lhblk" "\226\150\132"
+let _ = Hashtbl.add macro2utf8 "prnap" "\226\139\168"
+let _ = Hashtbl.add macro2utf8 "compfn" "\226\136\152"
+let _ = Hashtbl.add macro2utf8 "nsucceq" "\226\170\176\204\184"
+let _ = Hashtbl.add macro2utf8 "RightArrowLeftArrow" "\226\135\132"
+let _ = Hashtbl.add macro2utf8 "sharp" "\226\153\175"
+let _ = Hashtbl.add macro2utf8 "sharp" "\226\153\175"
+let _ = Hashtbl.add macro2utf8 "CHcy" "\208\167"
+let _ = Hashtbl.add macro2utf8 "dwangle" "\226\166\166"
+let _ = Hashtbl.add macro2utf8 "angrtvbd" "\226\166\157"
let _ = Hashtbl.add macro2utf8 "period" "."
-let _ = Hashtbl.add macro2utf8 "phone" "â\152\142"
-let _ = Hashtbl.add macro2utf8 "Eacute" "Ã\137"
-let _ = Hashtbl.add macro2utf8 "dzigrarr" "ï\150¢"
-let _ = Hashtbl.add macro2utf8 "Ll" "â\139\152"
-let _ = Hashtbl.add macro2utf8 "succapprox" "â\137¿"
-let _ = Hashtbl.add macro2utf8 "rarrfs" "â¤\158"
-let _ = Hashtbl.add macro2utf8 "dbkarow" "â¤\143"
-let _ = Hashtbl.add macro2utf8 "zeta" "ζ"
-let _ = Hashtbl.add macro2utf8 "zeta" "ζ"
-let _ = Hashtbl.add macro2utf8 "Lt" "â\137ª"
-let _ = Hashtbl.add macro2utf8 "triminus" "⨺"
-let _ = Hashtbl.add macro2utf8 "odiv" "⨸"
-let _ = Hashtbl.add macro2utf8 "ltrie" "â\138´"
-let _ = Hashtbl.add macro2utf8 "Dagger" "â\128¡"
-let _ = Hashtbl.add macro2utf8 "Dagger" "â\128¡"
-let _ = Hashtbl.add macro2utf8 "ltrif" "â\151\130"
-let _ = Hashtbl.add macro2utf8 "boxHD" "â\149¦"
-let _ = Hashtbl.add macro2utf8 "timesb" "â\138 "
-let _ = Hashtbl.add macro2utf8 "check" "â\156\147"
-let _ = Hashtbl.add macro2utf8 "urcorn" "â\140\157"
-let _ = Hashtbl.add macro2utf8 "timesd" "⨰"
-let _ = Hashtbl.add macro2utf8 "tshcy" "Ñ\155"
-let _ = Hashtbl.add macro2utf8 "sfr" "ð\157\148°"
-let _ = Hashtbl.add macro2utf8 "lmoust" "â\142°"
-let _ = Hashtbl.add macro2utf8 "ruluhar" "⥨"
-let _ = Hashtbl.add macro2utf8 "bne" "=â\131¥"
-let _ = Hashtbl.add macro2utf8 "prod" "â\136\143"
-let _ = Hashtbl.add macro2utf8 "prod" "â\136\143"
-let _ = Hashtbl.add macro2utf8 "Eopf" "ð\157\148¼"
-let _ = Hashtbl.add macro2utf8 "scsim" "â\137¿"
-let _ = Hashtbl.add macro2utf8 "GreaterEqualLess" "â\139\155"
-let _ = Hashtbl.add macro2utf8 "Igrave" "Ã\140"
-let _ = Hashtbl.add macro2utf8 "Longrightarrow" "â\135\146"
-let _ = Hashtbl.add macro2utf8 "Longrightarrow" "ï\149º"
-let _ = Hashtbl.add macro2utf8 "bigcap" "â\139\130"
-let _ = Hashtbl.add macro2utf8 "bigcap" "â\139\130"
-let _ = Hashtbl.add macro2utf8 "boxHU" "â\149©"
-let _ = Hashtbl.add macro2utf8 "uring" "ů"
-let _ = Hashtbl.add macro2utf8 "equivDD" "⩸"
-let _ = Hashtbl.add macro2utf8 "prop" "â\136\157"
-let _ = Hashtbl.add macro2utf8 "Lopf" "ð\157\149\131"
-let _ = Hashtbl.add macro2utf8 "ldrushar" "â¥\139"
-let _ = Hashtbl.add macro2utf8 "Leftarrow" "â\135\144"
-let _ = Hashtbl.add macro2utf8 "rarrhk" "â\134ª"
-let _ = Hashtbl.add macro2utf8 "Leftarrow" "â\135\144"
-let _ = Hashtbl.add macro2utf8 "lltri" "â\151º"
-let _ = Hashtbl.add macro2utf8 "NestedGreaterGreater" "â\137«"
-let _ = Hashtbl.add macro2utf8 "GreaterFullEqual" "â\137§"
-let _ = Hashtbl.add macro2utf8 "robrk" "ã\128\155"
-let _ = Hashtbl.add macro2utf8 "larrsim" "⥳"
-let _ = Hashtbl.add macro2utf8 "boxHd" "â\149¤"
-let _ = Hashtbl.add macro2utf8 "vDash" "â\138¨"
-let _ = Hashtbl.add macro2utf8 "hfr" "ð\157\148¥"
-let _ = Hashtbl.add macro2utf8 "Edot" "Ä\150"
-let _ = Hashtbl.add macro2utf8 "Vvdash" "â\138ª"
-let _ = Hashtbl.add macro2utf8 "Sopf" "ð\157\149\138"
-let _ = Hashtbl.add macro2utf8 "upuparrows" "â\135\136"
-let _ = Hashtbl.add macro2utf8 "RightUpTeeVector" "â¥\156"
-let _ = Hashtbl.add macro2utf8 "DownLeftVector" "â\134½"
-let _ = Hashtbl.add macro2utf8 "xhArr" "ï\149»"
-let _ = Hashtbl.add macro2utf8 "triplus" "⨹"
-let _ = Hashtbl.add macro2utf8 "bot" "â\138¥"
-let _ = Hashtbl.add macro2utf8 "bot" "â\138¥"
-let _ = Hashtbl.add macro2utf8 "Rcy" "Р"
-let _ = Hashtbl.add macro2utf8 "eDDot" "⩷"
-let _ = Hashtbl.add macro2utf8 "subseteqq" "â\138\134"
-let _ = Hashtbl.add macro2utf8 "cirfnint" "â¨\144"
-let _ = Hashtbl.add macro2utf8 "spadesuit" "â\153 "
-let _ = Hashtbl.add macro2utf8 "spadesuit" "â\153 "
-let _ = Hashtbl.add macro2utf8 "nacute" "Å\132"
-let _ = Hashtbl.add macro2utf8 "Zopf" "â\132¤"
-let _ = Hashtbl.add macro2utf8 "upharpoonleft" "â\134¿"
-let _ = Hashtbl.add macro2utf8 "shy" ""
-let _ = Hashtbl.add macro2utf8 "nparsl" "â\136¥ï¸\128â\131¥"
-let _ = Hashtbl.add macro2utf8 "boxHu" "â\149§"
-let _ = Hashtbl.add macro2utf8 "ThickSpace" "â\128\137â\128\138â\128\138"
-let _ = Hashtbl.add macro2utf8 "Or" "â©\148"
-let _ = Hashtbl.add macro2utf8 "raemptyv" "⦳"
-let _ = Hashtbl.add macro2utf8 "Aogon" "Ä\132"
-let _ = Hashtbl.add macro2utf8 "IEcy" "Ð\149"
-let _ = Hashtbl.add macro2utf8 "sim" "â\136¼"
-let _ = Hashtbl.add macro2utf8 "sim" "â\136¼"
+let _ = Hashtbl.add macro2utf8 "phone" "\226\152\142"
+let _ = Hashtbl.add macro2utf8 "Eacute" "\195\137"
+let _ = Hashtbl.add macro2utf8 "dzigrarr" "\239\150\162"
+let _ = Hashtbl.add macro2utf8 "Ll" "\226\139\152"
+let _ = Hashtbl.add macro2utf8 "succapprox" "\226\137\191"
+let _ = Hashtbl.add macro2utf8 "rarrfs" "\226\164\158"
+let _ = Hashtbl.add macro2utf8 "dbkarow" "\226\164\143"
+let _ = Hashtbl.add macro2utf8 "zeta" "\206\182"
+let _ = Hashtbl.add macro2utf8 "zeta" "\206\182"
+let _ = Hashtbl.add macro2utf8 "Lt" "\226\137\170"
+let _ = Hashtbl.add macro2utf8 "triminus" "\226\168\186"
+let _ = Hashtbl.add macro2utf8 "odiv" "\226\168\184"
+let _ = Hashtbl.add macro2utf8 "ltrie" "\226\138\180"
+let _ = Hashtbl.add macro2utf8 "Dagger" "\226\128\161"
+let _ = Hashtbl.add macro2utf8 "Dagger" "\226\128\161"
+let _ = Hashtbl.add macro2utf8 "ltrif" "\226\151\130"
+let _ = Hashtbl.add macro2utf8 "boxHD" "\226\149\166"
+let _ = Hashtbl.add macro2utf8 "timesb" "\226\138\160"
+let _ = Hashtbl.add macro2utf8 "check" "\226\156\147"
+let _ = Hashtbl.add macro2utf8 "urcorn" "\226\140\157"
+let _ = Hashtbl.add macro2utf8 "timesd" "\226\168\176"
+let _ = Hashtbl.add macro2utf8 "tshcy" "\209\155"
+let _ = Hashtbl.add macro2utf8 "sfr" "\240\157\148\176"
+let _ = Hashtbl.add macro2utf8 "lmoust" "\226\142\176"
+let _ = Hashtbl.add macro2utf8 "ruluhar" "\226\165\168"
+let _ = Hashtbl.add macro2utf8 "bne" "=\226\131\165"
+let _ = Hashtbl.add macro2utf8 "prod" "\226\136\143"
+let _ = Hashtbl.add macro2utf8 "prod" "\226\136\143"
+let _ = Hashtbl.add macro2utf8 "Eopf" "\240\157\148\188"
+let _ = Hashtbl.add macro2utf8 "scsim" "\226\137\191"
+let _ = Hashtbl.add macro2utf8 "GreaterEqualLess" "\226\139\155"
+let _ = Hashtbl.add macro2utf8 "Igrave" "\195\140"
+let _ = Hashtbl.add macro2utf8 "Longrightarrow" "\226\135\146"
+let _ = Hashtbl.add macro2utf8 "Longrightarrow" "\239\149\186"
+let _ = Hashtbl.add macro2utf8 "bigcap" "\226\139\130"
+let _ = Hashtbl.add macro2utf8 "bigcap" "\226\139\130"
+let _ = Hashtbl.add macro2utf8 "boxHU" "\226\149\169"
+let _ = Hashtbl.add macro2utf8 "uring" "\197\175"
+let _ = Hashtbl.add macro2utf8 "equivDD" "\226\169\184"
+let _ = Hashtbl.add macro2utf8 "prop" "\226\136\157"
+let _ = Hashtbl.add macro2utf8 "Lopf" "\240\157\149\131"
+let _ = Hashtbl.add macro2utf8 "ldrushar" "\226\165\139"
+let _ = Hashtbl.add macro2utf8 "Leftarrow" "\226\135\144"
+let _ = Hashtbl.add macro2utf8 "rarrhk" "\226\134\170"
+let _ = Hashtbl.add macro2utf8 "Leftarrow" "\226\135\144"
+let _ = Hashtbl.add macro2utf8 "lltri" "\226\151\186"
+let _ = Hashtbl.add macro2utf8 "NestedGreaterGreater" "\226\137\171"
+let _ = Hashtbl.add macro2utf8 "GreaterFullEqual" "\226\137\167"
+let _ = Hashtbl.add macro2utf8 "robrk" "\227\128\155"
+let _ = Hashtbl.add macro2utf8 "larrsim" "\226\165\179"
+let _ = Hashtbl.add macro2utf8 "boxHd" "\226\149\164"
+let _ = Hashtbl.add macro2utf8 "vDash" "\226\138\168"
+let _ = Hashtbl.add macro2utf8 "hfr" "\240\157\148\165"
+let _ = Hashtbl.add macro2utf8 "Edot" "\196\150"
+let _ = Hashtbl.add macro2utf8 "Vvdash" "\226\138\170"
+let _ = Hashtbl.add macro2utf8 "Sopf" "\240\157\149\138"
+let _ = Hashtbl.add macro2utf8 "upuparrows" "\226\135\136"
+let _ = Hashtbl.add macro2utf8 "RightUpTeeVector" "\226\165\156"
+let _ = Hashtbl.add macro2utf8 "DownLeftVector" "\226\134\189"
+let _ = Hashtbl.add macro2utf8 "xhArr" "\239\149\187"
+let _ = Hashtbl.add macro2utf8 "triplus" "\226\168\185"
+let _ = Hashtbl.add macro2utf8 "bot" "\226\138\165"
+let _ = Hashtbl.add macro2utf8 "bot" "\226\138\165"
+let _ = Hashtbl.add macro2utf8 "Rcy" "\208\160"
+let _ = Hashtbl.add macro2utf8 "eDDot" "\226\169\183"
+let _ = Hashtbl.add macro2utf8 "subseteqq" "\226\138\134"
+let _ = Hashtbl.add macro2utf8 "cirfnint" "\226\168\144"
+let _ = Hashtbl.add macro2utf8 "spadesuit" "\226\153\160"
+let _ = Hashtbl.add macro2utf8 "spadesuit" "\226\153\160"
+let _ = Hashtbl.add macro2utf8 "nacute" "\197\132"
+let _ = Hashtbl.add macro2utf8 "Zopf" "\226\132\164"
+let _ = Hashtbl.add macro2utf8 "upharpoonleft" "\226\134\191"
+let _ = Hashtbl.add macro2utf8 "shy" "\194\173"
+let _ = Hashtbl.add macro2utf8 "nparsl" "\226\136\165\239\184\128\226\131\165"
+let _ = Hashtbl.add macro2utf8 "boxHu" "\226\149\167"
+let _ = Hashtbl.add macro2utf8 "ThickSpace" "\226\128\137\226\128\138\226\128\138"
+let _ = Hashtbl.add macro2utf8 "Or" "\226\169\148"
+let _ = Hashtbl.add macro2utf8 "raemptyv" "\226\166\179"
+let _ = Hashtbl.add macro2utf8 "Aogon" "\196\132"
+let _ = Hashtbl.add macro2utf8 "IEcy" "\208\149"
+let _ = Hashtbl.add macro2utf8 "sim" "\226\136\188"
+let _ = Hashtbl.add macro2utf8 "sim" "\226\136\188"
let _ = Hashtbl.add macro2utf8 "sin" "sin"
-let _ = Hashtbl.add macro2utf8 "copysr" "â\132\151"
-let _ = Hashtbl.add macro2utf8 "scnap" "â\139©"
-let _ = Hashtbl.add macro2utf8 "rdquo" "â\128\157"
-let _ = Hashtbl.add macro2utf8 "aopf" "ð\157\149\146"
-let _ = Hashtbl.add macro2utf8 "Pi" "Π"
-let _ = Hashtbl.add macro2utf8 "Pi" "Π"
-let _ = Hashtbl.add macro2utf8 "Udblac" "Ű"
-let _ = Hashtbl.add macro2utf8 "expectation" "â\132°"
-let _ = Hashtbl.add macro2utf8 "Zacute" "Ź"
-let _ = Hashtbl.add macro2utf8 "urtri" "â\151¹"
-let _ = Hashtbl.add macro2utf8 "Gamma" "Î\147"
-let _ = Hashtbl.add macro2utf8 "NotTildeEqual" "â\137\132"
-let _ = Hashtbl.add macro2utf8 "ncedil" "Å\134"
-let _ = Hashtbl.add macro2utf8 "Gamma" "Î\147"
-let _ = Hashtbl.add macro2utf8 "ecirc" "ê"
-let _ = Hashtbl.add macro2utf8 "dsol" "⧶"
-let _ = Hashtbl.add macro2utf8 "Gcy" "Ð\147"
+let _ = Hashtbl.add macro2utf8 "copysr" "\226\132\151"
+let _ = Hashtbl.add macro2utf8 "scnap" "\226\139\169"
+let _ = Hashtbl.add macro2utf8 "rdquo" "\226\128\157"
+let _ = Hashtbl.add macro2utf8 "aopf" "\240\157\149\146"
+let _ = Hashtbl.add macro2utf8 "Pi" "\206\160"
+let _ = Hashtbl.add macro2utf8 "Pi" "\206\160"
+let _ = Hashtbl.add macro2utf8 "Udblac" "\197\176"
+let _ = Hashtbl.add macro2utf8 "expectation" "\226\132\176"
+let _ = Hashtbl.add macro2utf8 "Zacute" "\197\185"
+let _ = Hashtbl.add macro2utf8 "urtri" "\226\151\185"
+let _ = Hashtbl.add macro2utf8 "Gamma" "\206\147"
+let _ = Hashtbl.add macro2utf8 "NotTildeEqual" "\226\137\132"
+let _ = Hashtbl.add macro2utf8 "ncedil" "\197\134"
+let _ = Hashtbl.add macro2utf8 "Gamma" "\206\147"
+let _ = Hashtbl.add macro2utf8 "ecirc" "\195\170"
+let _ = Hashtbl.add macro2utf8 "dsol" "\226\167\182"
+let _ = Hashtbl.add macro2utf8 "Gcy" "\208\147"
let _ = Hashtbl.add macro2utf8 "Pr" "Pr"
-let _ = Hashtbl.add macro2utf8 "Pr" "⪻"
-let _ = Hashtbl.add macro2utf8 "Zdot" "Ż"
-let _ = Hashtbl.add macro2utf8 "mnplus" "â\136\147"
-let _ = Hashtbl.add macro2utf8 "hopf" "ð\157\149\153"
-let _ = Hashtbl.add macro2utf8 "blacktriangledown" "â\150¾"
-let _ = Hashtbl.add macro2utf8 "LeftCeiling" "â\140\136"
-let _ = Hashtbl.add macro2utf8 "searrow" "â\134\152"
-let _ = Hashtbl.add macro2utf8 "ulcorn" "â\140\156"
-let _ = Hashtbl.add macro2utf8 "searrow" "â\134\152"
-let _ = Hashtbl.add macro2utf8 "GreaterGreater" "⪢"
-let _ = Hashtbl.add macro2utf8 "Fscr" "â\132±"
-let _ = Hashtbl.add macro2utf8 "cupcup" "â©\138"
-let _ = Hashtbl.add macro2utf8 "NotEqual" "â\137 "
-let _ = Hashtbl.add macro2utf8 "sext" "â\156¶"
-let _ = Hashtbl.add macro2utf8 "CirclePlus" "â\138\149"
-let _ = Hashtbl.add macro2utf8 "erarr" "⥱"
-let _ = Hashtbl.add macro2utf8 "dArr" "â\135\147"
-let _ = Hashtbl.add macro2utf8 "PrecedesSlantEqual" "â\137¼"
-let _ = Hashtbl.add macro2utf8 "Itilde" "Ĩ"
-let _ = Hashtbl.add macro2utf8 "gesdoto" "âª\130"
-let _ = Hashtbl.add macro2utf8 "Rang" "ã\128\139"
-let _ = Hashtbl.add macro2utf8 "nwarhk" "⤣"
-let _ = Hashtbl.add macro2utf8 "minusdu" "⨪"
-let _ = Hashtbl.add macro2utf8 "oopf" "ð\157\149 "
-let _ = Hashtbl.add macro2utf8 "Mscr" "â\132³"
-let _ = Hashtbl.add macro2utf8 "Rfr" "â\132\156"
-let _ = Hashtbl.add macro2utf8 "langle" "â\140©"
-let _ = Hashtbl.add macro2utf8 "langle" "â\140©"
-let _ = Hashtbl.add macro2utf8 "And" "â©\147"
-let _ = Hashtbl.add macro2utf8 "bprime" "â\128µ"
-let _ = Hashtbl.add macro2utf8 "nLeftrightarrow" "â\135\142"
-let _ = Hashtbl.add macro2utf8 "Re" "â\132\156"
-let _ = Hashtbl.add macro2utf8 "Re" "â\132\156"
-let _ = Hashtbl.add macro2utf8 "OpenCurlyQuote" "â\128\152"
-let _ = Hashtbl.add macro2utf8 "vopf" "ð\157\149§"
-let _ = Hashtbl.add macro2utf8 "ulcorner" "â\140\156"
-let _ = Hashtbl.add macro2utf8 "nap" "â\137\137"
-let _ = Hashtbl.add macro2utf8 "Tscr" "ð\157\146¯"
-let _ = Hashtbl.add macro2utf8 "gtreqless" "â\139\155"
-let _ = Hashtbl.add macro2utf8 "Lambda" "Î\155"
-let _ = Hashtbl.add macro2utf8 "rarrlp" "â\134¬"
-let _ = Hashtbl.add macro2utf8 "Lambda" "Î\155"
-let _ = Hashtbl.add macro2utf8 "lobrk" "ã\128\154"
+let _ = Hashtbl.add macro2utf8 "Pr" "\226\170\187"
+let _ = Hashtbl.add macro2utf8 "Zdot" "\197\187"
+let _ = Hashtbl.add macro2utf8 "mnplus" "\226\136\147"
+let _ = Hashtbl.add macro2utf8 "hopf" "\240\157\149\153"
+let _ = Hashtbl.add macro2utf8 "blacktriangledown" "\226\150\190"
+let _ = Hashtbl.add macro2utf8 "LeftCeiling" "\226\140\136"
+let _ = Hashtbl.add macro2utf8 "searrow" "\226\134\152"
+let _ = Hashtbl.add macro2utf8 "ulcorn" "\226\140\156"
+let _ = Hashtbl.add macro2utf8 "searrow" "\226\134\152"
+let _ = Hashtbl.add macro2utf8 "GreaterGreater" "\226\170\162"
+let _ = Hashtbl.add macro2utf8 "Fscr" "\226\132\177"
+let _ = Hashtbl.add macro2utf8 "cupcup" "\226\169\138"
+let _ = Hashtbl.add macro2utf8 "NotEqual" "\226\137\160"
+let _ = Hashtbl.add macro2utf8 "sext" "\226\156\182"
+let _ = Hashtbl.add macro2utf8 "CirclePlus" "\226\138\149"
+let _ = Hashtbl.add macro2utf8 "erarr" "\226\165\177"
+let _ = Hashtbl.add macro2utf8 "dArr" "\226\135\147"
+let _ = Hashtbl.add macro2utf8 "PrecedesSlantEqual" "\226\137\188"
+let _ = Hashtbl.add macro2utf8 "Itilde" "\196\168"
+let _ = Hashtbl.add macro2utf8 "gesdoto" "\226\170\130"
+let _ = Hashtbl.add macro2utf8 "Rang" "\227\128\139"
+let _ = Hashtbl.add macro2utf8 "nwarhk" "\226\164\163"
+let _ = Hashtbl.add macro2utf8 "minusdu" "\226\168\170"
+let _ = Hashtbl.add macro2utf8 "oopf" "\240\157\149\160"
+let _ = Hashtbl.add macro2utf8 "Mscr" "\226\132\179"
+let _ = Hashtbl.add macro2utf8 "Rfr" "\226\132\156"
+let _ = Hashtbl.add macro2utf8 "langle" "\226\140\169"
+let _ = Hashtbl.add macro2utf8 "langle" "\226\140\169"
+let _ = Hashtbl.add macro2utf8 "And" "\226\169\147"
+let _ = Hashtbl.add macro2utf8 "bprime" "\226\128\181"
+let _ = Hashtbl.add macro2utf8 "nLeftrightarrow" "\226\135\142"
+let _ = Hashtbl.add macro2utf8 "Re" "\226\132\156"
+let _ = Hashtbl.add macro2utf8 "Re" "\226\132\156"
+let _ = Hashtbl.add macro2utf8 "OpenCurlyQuote" "\226\128\152"
+let _ = Hashtbl.add macro2utf8 "vopf" "\240\157\149\167"
+let _ = Hashtbl.add macro2utf8 "ulcorner" "\226\140\156"
+let _ = Hashtbl.add macro2utf8 "nap" "\226\137\137"
+let _ = Hashtbl.add macro2utf8 "Tscr" "\240\157\146\175"
+let _ = Hashtbl.add macro2utf8 "gtreqless" "\226\139\155"
+let _ = Hashtbl.add macro2utf8 "Lambda" "\206\155"
+let _ = Hashtbl.add macro2utf8 "rarrlp" "\226\134\172"
+let _ = Hashtbl.add macro2utf8 "Lambda" "\206\155"
+let _ = Hashtbl.add macro2utf8 "lobrk" "\227\128\154"
let _ = Hashtbl.add macro2utf8 "rbrace" "}"
let _ = Hashtbl.add macro2utf8 "rbrace" "}"
-let _ = Hashtbl.add macro2utf8 "rArr" "â\135\146"
-let _ = Hashtbl.add macro2utf8 "coloneq" "â\137\148"
-let _ = Hashtbl.add macro2utf8 "odot" "â\138\153"
-let _ = Hashtbl.add macro2utf8 "UpArrow" "â\134\145"
-let _ = Hashtbl.add macro2utf8 "odot" "â\138\153"
-let _ = Hashtbl.add macro2utf8 "LeftDownTeeVector" "⥡"
-let _ = Hashtbl.add macro2utf8 "complexes" "â\132\130"
+let _ = Hashtbl.add macro2utf8 "rArr" "\226\135\146"
+let _ = Hashtbl.add macro2utf8 "coloneq" "\226\137\148"
+let _ = Hashtbl.add macro2utf8 "odot" "\226\138\153"
+let _ = Hashtbl.add macro2utf8 "UpArrow" "\226\134\145"
+let _ = Hashtbl.add macro2utf8 "odot" "\226\138\153"
+let _ = Hashtbl.add macro2utf8 "LeftDownTeeVector" "\226\165\161"
+let _ = Hashtbl.add macro2utf8 "complexes" "\226\132\130"
let _ = Hashtbl.add macro2utf8 "rbrack" "]"
let _ = Hashtbl.add macro2utf8 "rbrack" "]"
-let _ = Hashtbl.add macro2utf8 "DownTeeArrow" "â\134§"
-let _ = Hashtbl.add macro2utf8 "sqcap" "â\138\147"
-let _ = Hashtbl.add macro2utf8 "sqcap" "â\138\147"
-let _ = Hashtbl.add macro2utf8 "Sc" "⪼"
-let _ = Hashtbl.add macro2utf8 "ycy" "Ñ\139"
-let _ = Hashtbl.add macro2utf8 "Prime" "â\128³"
-let _ = Hashtbl.add macro2utf8 "Gfr" "ð\157\148\138"
-let _ = Hashtbl.add macro2utf8 "trianglerighteq" "â\138µ"
-let _ = Hashtbl.add macro2utf8 "rangd" "â¦\146"
-let _ = Hashtbl.add macro2utf8 "gtrdot" "â\139\151"
-let _ = Hashtbl.add macro2utf8 "range" "⦥"
+let _ = Hashtbl.add macro2utf8 "DownTeeArrow" "\226\134\167"
+let _ = Hashtbl.add macro2utf8 "sqcap" "\226\138\147"
+let _ = Hashtbl.add macro2utf8 "sqcap" "\226\138\147"
+let _ = Hashtbl.add macro2utf8 "Sc" "\226\170\188"
+let _ = Hashtbl.add macro2utf8 "ycy" "\209\139"
+let _ = Hashtbl.add macro2utf8 "Prime" "\226\128\179"
+let _ = Hashtbl.add macro2utf8 "Gfr" "\240\157\148\138"
+let _ = Hashtbl.add macro2utf8 "trianglerighteq" "\226\138\181"
+let _ = Hashtbl.add macro2utf8 "rangd" "\226\166\146"
+let _ = Hashtbl.add macro2utf8 "gtrdot" "\226\139\151"
+let _ = Hashtbl.add macro2utf8 "range" "\226\166\165"
let _ = Hashtbl.add macro2utf8 "rsqb" "]"
-let _ = Hashtbl.add macro2utf8 "Euml" "Ã\139"
-let _ = Hashtbl.add macro2utf8 "Therefore" "â\136´"
-let _ = Hashtbl.add macro2utf8 "nesim" "â\137\130̸"
-let _ = Hashtbl.add macro2utf8 "order" "â\132´"
-let _ = Hashtbl.add macro2utf8 "vsupnE" "â\138\139ï¸\128"
-let _ = Hashtbl.add macro2utf8 "awconint" "â\136³"
-let _ = Hashtbl.add macro2utf8 "bscr" "ð\157\146·"
-let _ = Hashtbl.add macro2utf8 "lesseqqgtr" "â\139\154"
-let _ = Hashtbl.add macro2utf8 "cap" "â\136©"
-let _ = Hashtbl.add macro2utf8 "cap" "â\136©"
-let _ = Hashtbl.add macro2utf8 "ldquo" "â\128\156"
-let _ = Hashtbl.add macro2utf8 "nsubseteq" "â\138\136"
-let _ = Hashtbl.add macro2utf8 "rhov" "ϱ"
-let _ = Hashtbl.add macro2utf8 "xvee" "â\139\129"
-let _ = Hashtbl.add macro2utf8 "olarr" "â\134º"
-let _ = Hashtbl.add macro2utf8 "nang" "â\136 ̸"
-let _ = Hashtbl.add macro2utf8 "uwangle" "⦧"
-let _ = Hashtbl.add macro2utf8 "nlsim" "â\137´"
-let _ = Hashtbl.add macro2utf8 "smt" "⪪"
-let _ = Hashtbl.add macro2utf8 "nVdash" "â\138®"
-let _ = Hashtbl.add macro2utf8 "napE" "⩰̸"
-let _ = Hashtbl.add macro2utf8 "ngeq" "â\137±â\131¥"
-let _ = Hashtbl.add macro2utf8 "iscr" "ð\157\146¾"
-let _ = Hashtbl.add macro2utf8 "GJcy" "Ð\131"
-let _ = Hashtbl.add macro2utf8 "nges" "â\137±"
-let _ = Hashtbl.add macro2utf8 "exist" "â\136\131"
-let _ = Hashtbl.add macro2utf8 "cent" "¢"
-let _ = Hashtbl.add macro2utf8 "oacute" "ó"
-let _ = Hashtbl.add macro2utf8 "Darr" "â\134¡"
-let _ = Hashtbl.add macro2utf8 "yen" "¥"
-let _ = Hashtbl.add macro2utf8 "bigcirc" "â\151¯"
-let _ = Hashtbl.add macro2utf8 "bigcirc" "â\151¯"
-let _ = Hashtbl.add macro2utf8 "ncy" "н"
+let _ = Hashtbl.add macro2utf8 "Euml" "\195\139"
+let _ = Hashtbl.add macro2utf8 "Therefore" "\226\136\180"
+let _ = Hashtbl.add macro2utf8 "nesim" "\226\137\130\204\184"
+let _ = Hashtbl.add macro2utf8 "order" "\226\132\180"
+let _ = Hashtbl.add macro2utf8 "vsupnE" "\226\138\139\239\184\128"
+let _ = Hashtbl.add macro2utf8 "awconint" "\226\136\179"
+let _ = Hashtbl.add macro2utf8 "bscr" "\240\157\146\183"
+let _ = Hashtbl.add macro2utf8 "lesseqqgtr" "\226\139\154"
+let _ = Hashtbl.add macro2utf8 "cap" "\226\136\169"
+let _ = Hashtbl.add macro2utf8 "cap" "\226\136\169"
+let _ = Hashtbl.add macro2utf8 "ldquo" "\226\128\156"
+let _ = Hashtbl.add macro2utf8 "nsubseteq" "\226\138\136"
+let _ = Hashtbl.add macro2utf8 "rhov" "\207\177"
+let _ = Hashtbl.add macro2utf8 "xvee" "\226\139\129"
+let _ = Hashtbl.add macro2utf8 "olarr" "\226\134\186"
+let _ = Hashtbl.add macro2utf8 "nang" "\226\136\160\204\184"
+let _ = Hashtbl.add macro2utf8 "uwangle" "\226\166\167"
+let _ = Hashtbl.add macro2utf8 "nlsim" "\226\137\180"
+let _ = Hashtbl.add macro2utf8 "smt" "\226\170\170"
+let _ = Hashtbl.add macro2utf8 "nVdash" "\226\138\174"
+let _ = Hashtbl.add macro2utf8 "napE" "\226\169\176\204\184"
+let _ = Hashtbl.add macro2utf8 "ngeq" "\226\137\177\226\131\165"
+let _ = Hashtbl.add macro2utf8 "iscr" "\240\157\146\190"
+let _ = Hashtbl.add macro2utf8 "GJcy" "\208\131"
+let _ = Hashtbl.add macro2utf8 "nges" "\226\137\177"
+let _ = Hashtbl.add macro2utf8 "exist" "\226\136\131"
+let _ = Hashtbl.add macro2utf8 "cent" "\194\162"
+let _ = Hashtbl.add macro2utf8 "oacute" "\195\179"
+let _ = Hashtbl.add macro2utf8 "Darr" "\226\134\161"
+let _ = Hashtbl.add macro2utf8 "yen" "\194\165"
+let _ = Hashtbl.add macro2utf8 "bigcirc" "\226\151\175"
+let _ = Hashtbl.add macro2utf8 "bigcirc" "\226\151\175"
+let _ = Hashtbl.add macro2utf8 "ncy" "\208\189"
let _ = Hashtbl.add macro2utf8 "midast" "*"
-let _ = Hashtbl.add macro2utf8 "UpperRightArrow" "â\134\151"
-let _ = Hashtbl.add macro2utf8 "precnapprox" "â\139¨"
-let _ = Hashtbl.add macro2utf8 "OElig" "Å\146"
-let _ = Hashtbl.add macro2utf8 "hybull" "â\129\131"
-let _ = Hashtbl.add macro2utf8 "cupbrcap" "â©\136"
-let _ = Hashtbl.add macro2utf8 "rationals" "â\132\154"
-let _ = Hashtbl.add macro2utf8 "VerticalTilde" "â\137\128"
-let _ = Hashtbl.add macro2utf8 "pscr" "ð\157\147\133"
-let _ = Hashtbl.add macro2utf8 "NJcy" "Ð\138"
-let _ = Hashtbl.add macro2utf8 "NotSucceedsTilde" "â\137¿Ì¸"
-let _ = Hashtbl.add macro2utf8 "vsupne" "â\138\139ï¸\128"
-let _ = Hashtbl.add macro2utf8 "Updownarrow" "â\135\149"
-let _ = Hashtbl.add macro2utf8 "Lsh" "â\134°"
-let _ = Hashtbl.add macro2utf8 "rAarr" "â\135\155"
-let _ = Hashtbl.add macro2utf8 "precapprox" "â\137¾"
-let _ = Hashtbl.add macro2utf8 "rsquor" "â\128\153"
-let _ = Hashtbl.add macro2utf8 "pound" "£"
-let _ = Hashtbl.add macro2utf8 "lbrksld" "â¦\143"
-let _ = Hashtbl.add macro2utf8 "gesdot" "âª\128"
-let _ = Hashtbl.add macro2utf8 "Element" "â\136\136"
-let _ = Hashtbl.add macro2utf8 "xcirc" "â\151¯"
-let _ = Hashtbl.add macro2utf8 "wscr" "ð\157\147\140"
-let _ = Hashtbl.add macro2utf8 "toea" "⤨"
-let _ = Hashtbl.add macro2utf8 "setmn" "â\136\150"
-let _ = Hashtbl.add macro2utf8 "neg" "¬"
+let _ = Hashtbl.add macro2utf8 "UpperRightArrow" "\226\134\151"
+let _ = Hashtbl.add macro2utf8 "precnapprox" "\226\139\168"
+let _ = Hashtbl.add macro2utf8 "OElig" "\197\146"
+let _ = Hashtbl.add macro2utf8 "hybull" "\226\129\131"
+let _ = Hashtbl.add macro2utf8 "cupbrcap" "\226\169\136"
+let _ = Hashtbl.add macro2utf8 "rationals" "\226\132\154"
+let _ = Hashtbl.add macro2utf8 "VerticalTilde" "\226\137\128"
+let _ = Hashtbl.add macro2utf8 "pscr" "\240\157\147\133"
+let _ = Hashtbl.add macro2utf8 "NJcy" "\208\138"
+let _ = Hashtbl.add macro2utf8 "NotSucceedsTilde" "\226\137\191\204\184"
+let _ = Hashtbl.add macro2utf8 "vsupne" "\226\138\139\239\184\128"
+let _ = Hashtbl.add macro2utf8 "Updownarrow" "\226\135\149"
+let _ = Hashtbl.add macro2utf8 "Lsh" "\226\134\176"
+let _ = Hashtbl.add macro2utf8 "rAarr" "\226\135\155"
+let _ = Hashtbl.add macro2utf8 "precapprox" "\226\137\190"
+let _ = Hashtbl.add macro2utf8 "rsquor" "\226\128\153"
+let _ = Hashtbl.add macro2utf8 "pound" "\194\163"
+let _ = Hashtbl.add macro2utf8 "lbrksld" "\226\166\143"
+let _ = Hashtbl.add macro2utf8 "gesdot" "\226\170\128"
+let _ = Hashtbl.add macro2utf8 "Element" "\226\136\136"
+let _ = Hashtbl.add macro2utf8 "xcirc" "\226\151\175"
+let _ = Hashtbl.add macro2utf8 "wscr" "\240\157\147\140"
+let _ = Hashtbl.add macro2utf8 "toea" "\226\164\168"
+let _ = Hashtbl.add macro2utf8 "setmn" "\226\136\150"
+let _ = Hashtbl.add macro2utf8 "neg" "\194\172"
let _ = Hashtbl.add macro2utf8 "sol" "/"
-let _ = Hashtbl.add macro2utf8 "yfr" "ð\157\148¶"
-let _ = Hashtbl.add macro2utf8 "DoubleDownArrow" "â\135\147"
-let _ = Hashtbl.add macro2utf8 "Rarr" "â\134 "
-let _ = Hashtbl.add macro2utf8 "ngE" "â\137±"
-let _ = Hashtbl.add macro2utf8 "Upsi" "Ï\146"
-let _ = Hashtbl.add macro2utf8 "opar" "⦷"
-let _ = Hashtbl.add macro2utf8 "rarrpl" "â¥\133"
-let _ = Hashtbl.add macro2utf8 "auml" "ä"
+let _ = Hashtbl.add macro2utf8 "yfr" "\240\157\148\182"
+let _ = Hashtbl.add macro2utf8 "DoubleDownArrow" "\226\135\147"
+let _ = Hashtbl.add macro2utf8 "Rarr" "\226\134\160"
+let _ = Hashtbl.add macro2utf8 "ngE" "\226\137\177"
+let _ = Hashtbl.add macro2utf8 "Upsi" "\207\146"
+let _ = Hashtbl.add macro2utf8 "opar" "\226\166\183"
+let _ = Hashtbl.add macro2utf8 "rarrpl" "\226\165\133"
+let _ = Hashtbl.add macro2utf8 "auml" "\195\164"
let _ = Hashtbl.add macro2utf8 "bmod" "mod"
-let _ = Hashtbl.add macro2utf8 "SquareSuperset" "â\138\144"
-let _ = Hashtbl.add macro2utf8 "circleddash" "â\138\157"
-let _ = Hashtbl.add macro2utf8 "xrarr" "ï\149·"
-let _ = Hashtbl.add macro2utf8 "barwed" "â\138¼"
-let _ = Hashtbl.add macro2utf8 "lbrkslu" "â¦\141"
-let _ = Hashtbl.add macro2utf8 "planckh" "â\132\142"
-let _ = Hashtbl.add macro2utf8 "ldrdhar" "⥧"
-let _ = Hashtbl.add macro2utf8 "circledcirc" "â\138\154"
-let _ = Hashtbl.add macro2utf8 "ctdot" "â\139¯"
-let _ = Hashtbl.add macro2utf8 "fallingdotseq" "â\137\146"
-let _ = Hashtbl.add macro2utf8 "Map" "â¤\133"
-let _ = Hashtbl.add macro2utf8 "VerticalBar" "â\136£"
-let _ = Hashtbl.add macro2utf8 "succeq" "â\137½"
-let _ = Hashtbl.add macro2utf8 "succeq" "â\137½"
-let _ = Hashtbl.add macro2utf8 "tint" "â\136"
-let _ = Hashtbl.add macro2utf8 "imof" "â\138·"
-let _ = Hashtbl.add macro2utf8 "diam" "â\139\132"
-let _ = Hashtbl.add macro2utf8 "twixt" "â\137¬"
-let _ = Hashtbl.add macro2utf8 "NoBreak" ""
-let _ = Hashtbl.add macro2utf8 "langd" "â¦\145"
-let _ = Hashtbl.add macro2utf8 "Bernoullis" "â\132¬"
-let _ = Hashtbl.add macro2utf8 "rcaron" "Å\153"
+let _ = Hashtbl.add macro2utf8 "SquareSuperset" "\226\138\144"
+let _ = Hashtbl.add macro2utf8 "circleddash" "\226\138\157"
+let _ = Hashtbl.add macro2utf8 "xrarr" "\239\149\183"
+let _ = Hashtbl.add macro2utf8 "barwed" "\226\138\188"
+let _ = Hashtbl.add macro2utf8 "lbrkslu" "\226\166\141"
+let _ = Hashtbl.add macro2utf8 "planckh" "\226\132\142"
+let _ = Hashtbl.add macro2utf8 "ldrdhar" "\226\165\167"
+let _ = Hashtbl.add macro2utf8 "circledcirc" "\226\138\154"
+let _ = Hashtbl.add macro2utf8 "ctdot" "\226\139\175"
+let _ = Hashtbl.add macro2utf8 "fallingdotseq" "\226\137\146"
+let _ = Hashtbl.add macro2utf8 "Map" "\226\164\133"
+let _ = Hashtbl.add macro2utf8 "VerticalBar" "\226\136\163"
+let _ = Hashtbl.add macro2utf8 "succeq" "\226\137\189"
+let _ = Hashtbl.add macro2utf8 "succeq" "\226\137\189"
+let _ = Hashtbl.add macro2utf8 "tint" "\226\136\173"
+let _ = Hashtbl.add macro2utf8 "imof" "\226\138\183"
+let _ = Hashtbl.add macro2utf8 "diam" "\226\139\132"
+let _ = Hashtbl.add macro2utf8 "twixt" "\226\137\172"
+let _ = Hashtbl.add macro2utf8 "NoBreak" "\239\187\191"
+let _ = Hashtbl.add macro2utf8 "langd" "\226\166\145"
+let _ = Hashtbl.add macro2utf8 "Bernoullis" "\226\132\172"
+let _ = Hashtbl.add macro2utf8 "rcaron" "\197\153"
let _ = Hashtbl.add macro2utf8 "hom" "hom"
-let _ = Hashtbl.add macro2utf8 "nfr" "ð\157\148«"
-let _ = Hashtbl.add macro2utf8 "backsimeq" "â\139\141"
-let _ = Hashtbl.add macro2utf8 "target" "â\140\150"
-let _ = Hashtbl.add macro2utf8 "ouml" "ö"
-let _ = Hashtbl.add macro2utf8 "nge" "â\137±â\131¥"
-let _ = Hashtbl.add macro2utf8 "LeftTriangleBar" "â§\143"
-let _ = Hashtbl.add macro2utf8 "subplus" "⪿"
-let _ = Hashtbl.add macro2utf8 "parsim" "⫳"
-let _ = Hashtbl.add macro2utf8 "Gcedil" "Ģ"
-let _ = Hashtbl.add macro2utf8 "bnequiv" "â\137¡â\131¥"
-let _ = Hashtbl.add macro2utf8 "ubreve" "ŭ"
-let _ = Hashtbl.add macro2utf8 "iexcl" "¡"
-let _ = Hashtbl.add macro2utf8 "Xi" "Î\158"
-let _ = Hashtbl.add macro2utf8 "omega" "Ï\137"
-let _ = Hashtbl.add macro2utf8 "Xi" "Î\158"
-let _ = Hashtbl.add macro2utf8 "omega" "Ï\137"
-let _ = Hashtbl.add macro2utf8 "elsdot" "âª\151"
-let _ = Hashtbl.add macro2utf8 "propto" "â\136\157"
-let _ = Hashtbl.add macro2utf8 "propto" "â\136\157"
-let _ = Hashtbl.add macro2utf8 "squ" "â\150¡"
-let _ = Hashtbl.add macro2utf8 "Ycirc" "Ŷ"
-let _ = Hashtbl.add macro2utf8 "amacr" "Ä\129"
-let _ = Hashtbl.add macro2utf8 "curlyeqprec" "â\139\158"
-let _ = Hashtbl.add macro2utf8 "ngt" "â\137¯"
-let _ = Hashtbl.add macro2utf8 "plusdo" "â\136\148"
-let _ = Hashtbl.add macro2utf8 "ngeqslant" "â\137±"
-let _ = Hashtbl.add macro2utf8 "LongRightArrow" "ï\149·"
-let _ = Hashtbl.add macro2utf8 "LeftUpVector" "â\134¿"
-let _ = Hashtbl.add macro2utf8 "asymp" "â\137\141"
-let _ = Hashtbl.add macro2utf8 "asymp" "â\137\141"
-let _ = Hashtbl.add macro2utf8 "imped" "ð\157\149\131"
-let _ = Hashtbl.add macro2utf8 "tritime" "⨻"
-let _ = Hashtbl.add macro2utf8 "rpargt" "â¦\148"
-let _ = Hashtbl.add macro2utf8 "DDotrahd" "â¤\145"
-let _ = Hashtbl.add macro2utf8 "prnsim" "â\139¨"
-let _ = Hashtbl.add macro2utf8 "plusdu" "⨥"
-let _ = Hashtbl.add macro2utf8 "cfr" "ð\157\148 "
-let _ = Hashtbl.add macro2utf8 "abreve" "Ä\131"
-let _ = Hashtbl.add macro2utf8 "suphsol" "â\138\131/"
-let _ = Hashtbl.add macro2utf8 "NegativeThickSpace" "â\128\133ï¸\128"
-let _ = Hashtbl.add macro2utf8 "Mcy" "Ð\156"
-let _ = Hashtbl.add macro2utf8 "uarr" "â\134\145"
-let _ = Hashtbl.add macro2utf8 "LeftRightVector" "â¥\142"
-let _ = Hashtbl.add macro2utf8 "lAarr" "â\135\154"
-let _ = Hashtbl.add macro2utf8 "bsim" "â\136½"
-let _ = Hashtbl.add macro2utf8 "simrarr" "⥲"
-let _ = Hashtbl.add macro2utf8 "otimes" "â\138\151"
-let _ = Hashtbl.add macro2utf8 "otimes" "â\138\151"
-let _ = Hashtbl.add macro2utf8 "NotSucceeds" "â\138\129"
-let _ = Hashtbl.add macro2utf8 "Cross" "⨯"
-let _ = Hashtbl.add macro2utf8 "downarrow" "â\134\147"
-let _ = Hashtbl.add macro2utf8 "downarrow" "â\134\147"
-let _ = Hashtbl.add macro2utf8 "blacktriangle" "â\150´"
-let _ = Hashtbl.add macro2utf8 "TripleDot" "â\131\155"
-let _ = Hashtbl.add macro2utf8 "smallsetminus" "â\136\150ï¸\128"
-let _ = Hashtbl.add macro2utf8 "supedot" "â«\132"
-let _ = Hashtbl.add macro2utf8 "NotPrecedesSlantEqual" "â\139 "
-let _ = Hashtbl.add macro2utf8 "neArr" "â\135\151"
-let _ = Hashtbl.add macro2utf8 "rarrtl" "â\134£"
-let _ = Hashtbl.add macro2utf8 "isin" "â\136\136"
-let _ = Hashtbl.add macro2utf8 "rrarr" "â\135\137"
-let _ = Hashtbl.add macro2utf8 "Upsilon" "Ï\146"
-let _ = Hashtbl.add macro2utf8 "Upsilon" "Ï\146"
-let _ = Hashtbl.add macro2utf8 "sqsub" "â\138\143"
-let _ = Hashtbl.add macro2utf8 "boxUL" "â\149\157"
-let _ = Hashtbl.add macro2utf8 "LessTilde" "â\137²"
-let _ = Hashtbl.add macro2utf8 "chi" "Ï\135"
-let _ = Hashtbl.add macro2utf8 "Xfr" "ð\157\148\155"
-let _ = Hashtbl.add macro2utf8 "nis" "â\139¼"
-let _ = Hashtbl.add macro2utf8 "chi" "Ï\135"
-let _ = Hashtbl.add macro2utf8 "DownRightVector" "â\135\129"
-let _ = Hashtbl.add macro2utf8 "niv" "â\136\139"
-let _ = Hashtbl.add macro2utf8 "boxUR" "â\149\154"
-let _ = Hashtbl.add macro2utf8 "nlArr" "â\135\141"
-let _ = Hashtbl.add macro2utf8 "Bcy" "Ð\145"
+let _ = Hashtbl.add macro2utf8 "nfr" "\240\157\148\171"
+let _ = Hashtbl.add macro2utf8 "backsimeq" "\226\139\141"
+let _ = Hashtbl.add macro2utf8 "target" "\226\140\150"
+let _ = Hashtbl.add macro2utf8 "ouml" "\195\182"
+let _ = Hashtbl.add macro2utf8 "nge" "\226\137\177\226\131\165"
+let _ = Hashtbl.add macro2utf8 "LeftTriangleBar" "\226\167\143"
+let _ = Hashtbl.add macro2utf8 "subplus" "\226\170\191"
+let _ = Hashtbl.add macro2utf8 "parsim" "\226\171\179"
+let _ = Hashtbl.add macro2utf8 "Gcedil" "\196\162"
+let _ = Hashtbl.add macro2utf8 "bnequiv" "\226\137\161\226\131\165"
+let _ = Hashtbl.add macro2utf8 "ubreve" "\197\173"
+let _ = Hashtbl.add macro2utf8 "iexcl" "\194\161"
+let _ = Hashtbl.add macro2utf8 "Xi" "\206\158"
+let _ = Hashtbl.add macro2utf8 "omega" "\207\137"
+let _ = Hashtbl.add macro2utf8 "Xi" "\206\158"
+let _ = Hashtbl.add macro2utf8 "omega" "\207\137"
+let _ = Hashtbl.add macro2utf8 "elsdot" "\226\170\151"
+let _ = Hashtbl.add macro2utf8 "propto" "\226\136\157"
+let _ = Hashtbl.add macro2utf8 "propto" "\226\136\157"
+let _ = Hashtbl.add macro2utf8 "squ" "\226\150\161"
+let _ = Hashtbl.add macro2utf8 "Ycirc" "\197\182"
+let _ = Hashtbl.add macro2utf8 "amacr" "\196\129"
+let _ = Hashtbl.add macro2utf8 "curlyeqprec" "\226\139\158"
+let _ = Hashtbl.add macro2utf8 "ngt" "\226\137\175"
+let _ = Hashtbl.add macro2utf8 "plusdo" "\226\136\148"
+let _ = Hashtbl.add macro2utf8 "ngeqslant" "\226\137\177"
+let _ = Hashtbl.add macro2utf8 "LongRightArrow" "\239\149\183"
+let _ = Hashtbl.add macro2utf8 "LeftUpVector" "\226\134\191"
+let _ = Hashtbl.add macro2utf8 "asymp" "\226\137\141"
+let _ = Hashtbl.add macro2utf8 "asymp" "\226\137\141"
+let _ = Hashtbl.add macro2utf8 "imped" "\240\157\149\131"
+let _ = Hashtbl.add macro2utf8 "tritime" "\226\168\187"
+let _ = Hashtbl.add macro2utf8 "rpargt" "\226\166\148"
+let _ = Hashtbl.add macro2utf8 "DDotrahd" "\226\164\145"
+let _ = Hashtbl.add macro2utf8 "prnsim" "\226\139\168"
+let _ = Hashtbl.add macro2utf8 "plusdu" "\226\168\165"
+let _ = Hashtbl.add macro2utf8 "cfr" "\240\157\148\160"
+let _ = Hashtbl.add macro2utf8 "abreve" "\196\131"
+let _ = Hashtbl.add macro2utf8 "suphsol" "\226\138\131/"
+let _ = Hashtbl.add macro2utf8 "NegativeThickSpace" "\226\128\133\239\184\128"
+let _ = Hashtbl.add macro2utf8 "Mcy" "\208\156"
+let _ = Hashtbl.add macro2utf8 "uarr" "\226\134\145"
+let _ = Hashtbl.add macro2utf8 "LeftRightVector" "\226\165\142"
+let _ = Hashtbl.add macro2utf8 "lAarr" "\226\135\154"
+let _ = Hashtbl.add macro2utf8 "bsim" "\226\136\189"
+let _ = Hashtbl.add macro2utf8 "simrarr" "\226\165\178"
+let _ = Hashtbl.add macro2utf8 "otimes" "\226\138\151"
+let _ = Hashtbl.add macro2utf8 "otimes" "\226\138\151"
+let _ = Hashtbl.add macro2utf8 "NotSucceeds" "\226\138\129"
+let _ = Hashtbl.add macro2utf8 "Cross" "\226\168\175"
+let _ = Hashtbl.add macro2utf8 "downarrow" "\226\134\147"
+let _ = Hashtbl.add macro2utf8 "downarrow" "\226\134\147"
+let _ = Hashtbl.add macro2utf8 "blacktriangle" "\226\150\180"
+let _ = Hashtbl.add macro2utf8 "TripleDot" "\226\131\155"
+let _ = Hashtbl.add macro2utf8 "smallsetminus" "\226\136\150\239\184\128"
+let _ = Hashtbl.add macro2utf8 "supedot" "\226\171\132"
+let _ = Hashtbl.add macro2utf8 "NotPrecedesSlantEqual" "\226\139\160"
+let _ = Hashtbl.add macro2utf8 "neArr" "\226\135\151"
+let _ = Hashtbl.add macro2utf8 "rarrtl" "\226\134\163"
+let _ = Hashtbl.add macro2utf8 "isin" "\226\136\136"
+let _ = Hashtbl.add macro2utf8 "rrarr" "\226\135\137"
+let _ = Hashtbl.add macro2utf8 "Upsilon" "\207\146"
+let _ = Hashtbl.add macro2utf8 "Upsilon" "\207\146"
+let _ = Hashtbl.add macro2utf8 "sqsub" "\226\138\143"
+let _ = Hashtbl.add macro2utf8 "boxUL" "\226\149\157"
+let _ = Hashtbl.add macro2utf8 "LessTilde" "\226\137\178"
+let _ = Hashtbl.add macro2utf8 "chi" "\207\135"
+let _ = Hashtbl.add macro2utf8 "Xfr" "\240\157\148\155"
+let _ = Hashtbl.add macro2utf8 "nis" "\226\139\188"
+let _ = Hashtbl.add macro2utf8 "chi" "\207\135"
+let _ = Hashtbl.add macro2utf8 "DownRightVector" "\226\135\129"
+let _ = Hashtbl.add macro2utf8 "niv" "\226\136\139"
+let _ = Hashtbl.add macro2utf8 "boxUR" "\226\149\154"
+let _ = Hashtbl.add macro2utf8 "nlArr" "\226\135\141"
+let _ = Hashtbl.add macro2utf8 "Bcy" "\208\145"
let _ = Hashtbl.add macro2utf8 "tan" "tan"
-let _ = Hashtbl.add macro2utf8 "EmptyVerySmallSquare" "ï\150\156"
-let _ = Hashtbl.add macro2utf8 "dstrok" "Ä\145"
-let _ = Hashtbl.add macro2utf8 "rfisht" "⥽"
-let _ = Hashtbl.add macro2utf8 "easter" "â\137\155"
-let _ = Hashtbl.add macro2utf8 "nlE" "â\137°"
-let _ = Hashtbl.add macro2utf8 "Mellintrf" "â\132³"
-let _ = Hashtbl.add macro2utf8 "lotimes" "⨴"
-let _ = Hashtbl.add macro2utf8 "sqsup" "â\138\144"
-let _ = Hashtbl.add macro2utf8 "boxVH" "â\149¬"
-let _ = Hashtbl.add macro2utf8 "bbrk" "â\142µ"
-let _ = Hashtbl.add macro2utf8 "tau" "Ï\132"
-let _ = Hashtbl.add macro2utf8 "tau" "Ï\132"
-let _ = Hashtbl.add macro2utf8 "sub" "â\138\130"
-let _ = Hashtbl.add macro2utf8 "UpTee" "â\138¥"
-let _ = Hashtbl.add macro2utf8 "NotLeftTriangleBar" "â§\143̸"
-let _ = Hashtbl.add macro2utf8 "boxVL" "â\149£"
-let _ = Hashtbl.add macro2utf8 "equiv" "â\137¡"
-let _ = Hashtbl.add macro2utf8 "Proportion" "â\136·"
-let _ = Hashtbl.add macro2utf8 "equiv" "â\137¡"
-let _ = Hashtbl.add macro2utf8 "blk12" "â\150\146"
-let _ = Hashtbl.add macro2utf8 "blk14" "â\150\145"
-let _ = Hashtbl.add macro2utf8 "fpartint" "â¨\141"
-let _ = Hashtbl.add macro2utf8 "boxVR" "â\149 "
-let _ = Hashtbl.add macro2utf8 "starf" "â\152\133"
-let _ = Hashtbl.add macro2utf8 "risingdotseq" "â\137\147"
-let _ = Hashtbl.add macro2utf8 "Equilibrium" "â\135\140"
-let _ = Hashtbl.add macro2utf8 "ijlig" "ij"
-let _ = Hashtbl.add macro2utf8 "yicy" "Ñ\151"
-let _ = Hashtbl.add macro2utf8 "sum" "â\136\145"
-let _ = Hashtbl.add macro2utf8 "sum" "â\136\145"
-let _ = Hashtbl.add macro2utf8 "cir" "â\151\139"
-let _ = Hashtbl.add macro2utf8 "telrec" "â\140\149"
-let _ = Hashtbl.add macro2utf8 "Mfr" "ð\157\148\144"
-let _ = Hashtbl.add macro2utf8 "dHar" "⥥"
-let _ = Hashtbl.add macro2utf8 "sup" "â\138\131"
-let _ = Hashtbl.add macro2utf8 "boxUl" "â\149\156"
-let _ = Hashtbl.add macro2utf8 "apid" "â\137\139"
-let _ = Hashtbl.add macro2utf8 "nleftarrow" "â\134\154"
-let _ = Hashtbl.add macro2utf8 "curarrm" "⤼"
-let _ = Hashtbl.add macro2utf8 "Scirc" "Å\156"
-let _ = Hashtbl.add macro2utf8 "Copf" "â\132\130"
-let _ = Hashtbl.add macro2utf8 "RightTriangleEqual" "â\138µ"
-let _ = Hashtbl.add macro2utf8 "boxUr" "â\149\153"
-let _ = Hashtbl.add macro2utf8 "loplus" "⨭"
-let _ = Hashtbl.add macro2utf8 "varsupsetneq" "â\138\139ï¸\128"
-let _ = Hashtbl.add macro2utf8 "scaron" "š"
-let _ = Hashtbl.add macro2utf8 "Diamond" "â\139\132"
-let _ = Hashtbl.add macro2utf8 "lowast" "â\136\151"
-let _ = Hashtbl.add macro2utf8 "nle" "â\137°â\131¥"
-let _ = Hashtbl.add macro2utf8 "phiv" "Ï\149"
-let _ = Hashtbl.add macro2utf8 "gesdotol" "âª\132"
-let _ = Hashtbl.add macro2utf8 "boxVh" "â\149«"
-let _ = Hashtbl.add macro2utf8 "nleftrightarrow" "â\134®"
-let _ = Hashtbl.add macro2utf8 "Jopf" "ð\157\149\129"
-let _ = Hashtbl.add macro2utf8 "boxVl" "â\149¢"
-let _ = Hashtbl.add macro2utf8 "nearhk" "⤤"
-let _ = Hashtbl.add macro2utf8 "vBarv" "⫩"
-let _ = Hashtbl.add macro2utf8 "rHar" "⥤"
-let _ = Hashtbl.add macro2utf8 "boxVr" "â\149\159"
-let _ = Hashtbl.add macro2utf8 "Delta" "Î\148"
-let _ = Hashtbl.add macro2utf8 "lessdot" "â\139\150"
-let _ = Hashtbl.add macro2utf8 "LeftDoubleBracket" "ã\128\154"
-let _ = Hashtbl.add macro2utf8 "Delta" "Î\148"
+let _ = Hashtbl.add macro2utf8 "EmptyVerySmallSquare" "\239\150\156"
+let _ = Hashtbl.add macro2utf8 "dstrok" "\196\145"
+let _ = Hashtbl.add macro2utf8 "rfisht" "\226\165\189"
+let _ = Hashtbl.add macro2utf8 "easter" "\226\137\155"
+let _ = Hashtbl.add macro2utf8 "nlE" "\226\137\176"
+let _ = Hashtbl.add macro2utf8 "Mellintrf" "\226\132\179"
+let _ = Hashtbl.add macro2utf8 "lotimes" "\226\168\180"
+let _ = Hashtbl.add macro2utf8 "sqsup" "\226\138\144"
+let _ = Hashtbl.add macro2utf8 "boxVH" "\226\149\172"
+let _ = Hashtbl.add macro2utf8 "bbrk" "\226\142\181"
+let _ = Hashtbl.add macro2utf8 "tau" "\207\132"
+let _ = Hashtbl.add macro2utf8 "tau" "\207\132"
+let _ = Hashtbl.add macro2utf8 "sub" "\226\138\130"
+let _ = Hashtbl.add macro2utf8 "UpTee" "\226\138\165"
+let _ = Hashtbl.add macro2utf8 "NotLeftTriangleBar" "\226\167\143\204\184"
+let _ = Hashtbl.add macro2utf8 "boxVL" "\226\149\163"
+let _ = Hashtbl.add macro2utf8 "equiv" "\226\137\161"
+let _ = Hashtbl.add macro2utf8 "Proportion" "\226\136\183"
+let _ = Hashtbl.add macro2utf8 "equiv" "\226\137\161"
+let _ = Hashtbl.add macro2utf8 "blk12" "\226\150\146"
+let _ = Hashtbl.add macro2utf8 "blk14" "\226\150\145"
+let _ = Hashtbl.add macro2utf8 "fpartint" "\226\168\141"
+let _ = Hashtbl.add macro2utf8 "boxVR" "\226\149\160"
+let _ = Hashtbl.add macro2utf8 "starf" "\226\152\133"
+let _ = Hashtbl.add macro2utf8 "risingdotseq" "\226\137\147"
+let _ = Hashtbl.add macro2utf8 "Equilibrium" "\226\135\140"
+let _ = Hashtbl.add macro2utf8 "ijlig" "\196\179"
+let _ = Hashtbl.add macro2utf8 "yicy" "\209\151"
+let _ = Hashtbl.add macro2utf8 "sum" "\226\136\145"
+let _ = Hashtbl.add macro2utf8 "sum" "\226\136\145"
+let _ = Hashtbl.add macro2utf8 "cir" "\226\151\139"
+let _ = Hashtbl.add macro2utf8 "telrec" "\226\140\149"
+let _ = Hashtbl.add macro2utf8 "Mfr" "\240\157\148\144"
+let _ = Hashtbl.add macro2utf8 "dHar" "\226\165\165"
+let _ = Hashtbl.add macro2utf8 "sup" "\226\138\131"
+let _ = Hashtbl.add macro2utf8 "boxUl" "\226\149\156"
+let _ = Hashtbl.add macro2utf8 "apid" "\226\137\139"
+let _ = Hashtbl.add macro2utf8 "nleftarrow" "\226\134\154"
+let _ = Hashtbl.add macro2utf8 "curarrm" "\226\164\188"
+let _ = Hashtbl.add macro2utf8 "Scirc" "\197\156"
+let _ = Hashtbl.add macro2utf8 "Copf" "\226\132\130"
+let _ = Hashtbl.add macro2utf8 "RightTriangleEqual" "\226\138\181"
+let _ = Hashtbl.add macro2utf8 "boxUr" "\226\149\153"
+let _ = Hashtbl.add macro2utf8 "loplus" "\226\168\173"
+let _ = Hashtbl.add macro2utf8 "varsupsetneq" "\226\138\139\239\184\128"
+let _ = Hashtbl.add macro2utf8 "scaron" "\197\161"
+let _ = Hashtbl.add macro2utf8 "Diamond" "\226\139\132"
+let _ = Hashtbl.add macro2utf8 "lowast" "\226\136\151"
+let _ = Hashtbl.add macro2utf8 "nle" "\226\137\176\226\131\165"
+let _ = Hashtbl.add macro2utf8 "phiv" "\207\149"
+let _ = Hashtbl.add macro2utf8 "gesdotol" "\226\170\132"
+let _ = Hashtbl.add macro2utf8 "boxVh" "\226\149\171"
+let _ = Hashtbl.add macro2utf8 "nleftrightarrow" "\226\134\174"
+let _ = Hashtbl.add macro2utf8 "Jopf" "\240\157\149\129"
+let _ = Hashtbl.add macro2utf8 "boxVl" "\226\149\162"
+let _ = Hashtbl.add macro2utf8 "nearhk" "\226\164\164"
+let _ = Hashtbl.add macro2utf8 "vBarv" "\226\171\169"
+let _ = Hashtbl.add macro2utf8 "rHar" "\226\165\164"
+let _ = Hashtbl.add macro2utf8 "boxVr" "\226\149\159"
+let _ = Hashtbl.add macro2utf8 "Delta" "\206\148"
+let _ = Hashtbl.add macro2utf8 "lessdot" "\226\139\150"
+let _ = Hashtbl.add macro2utf8 "LeftDoubleBracket" "\227\128\154"
+let _ = Hashtbl.add macro2utf8 "Delta" "\206\148"
let _ = Hashtbl.add macro2utf8 "limsup" "limsup"
-let _ = Hashtbl.add macro2utf8 "tcy" "Ñ\130"
-let _ = Hashtbl.add macro2utf8 "nlt" "â\137®"
-let _ = Hashtbl.add macro2utf8 "Cdot" "Ä\138"
-let _ = Hashtbl.add macro2utf8 "blk34" "â\150\147"
-let _ = Hashtbl.add macro2utf8 "Bfr" "ð\157\148\133"
+let _ = Hashtbl.add macro2utf8 "tcy" "\209\130"
+let _ = Hashtbl.add macro2utf8 "nlt" "\226\137\174"
+let _ = Hashtbl.add macro2utf8 "Cdot" "\196\138"
+let _ = Hashtbl.add macro2utf8 "blk34" "\226\150\147"
+let _ = Hashtbl.add macro2utf8 "Bfr" "\240\157\148\133"
let _ = Hashtbl.add macro2utf8 "lowbar" "_"
-let _ = Hashtbl.add macro2utf8 "lneqq" "â\137¨"
-let _ = Hashtbl.add macro2utf8 "TildeEqual" "â\137\131"
-let _ = Hashtbl.add macro2utf8 "shortmid" "â\136£ï¸\128"
-let _ = Hashtbl.add macro2utf8 "Qopf" "â\132\154"
-let _ = Hashtbl.add macro2utf8 "drcorn" "â\140\159"
-let _ = Hashtbl.add macro2utf8 "ZeroWidthSpace" "â\128\139"
-let _ = Hashtbl.add macro2utf8 "aogon" "Ä\133"
-let _ = Hashtbl.add macro2utf8 "Rsh" "â\134±"
-let _ = Hashtbl.add macro2utf8 "lrarr" "â\135\134"
-let _ = Hashtbl.add macro2utf8 "cupdot" "â\138\141"
-let _ = Hashtbl.add macro2utf8 "Xopf" "ð\157\149\143"
-let _ = Hashtbl.add macro2utf8 "Backslash" "â\136\150"
-let _ = Hashtbl.add macro2utf8 "Union" "â\139\131"
-let _ = Hashtbl.add macro2utf8 "ratio" "â\136¶"
-let _ = Hashtbl.add macro2utf8 "duarr" "â\135µ"
-let _ = Hashtbl.add macro2utf8 "lates" "âªï¸\128"
-let _ = Hashtbl.add macro2utf8 "suphsub" "â«\151"
-let _ = Hashtbl.add macro2utf8 "gamma" "γ"
-let _ = Hashtbl.add macro2utf8 "squf" "â\150ª"
-let _ = Hashtbl.add macro2utf8 "gamma" "γ"
-let _ = Hashtbl.add macro2utf8 "lrhard" "⥭"
-let _ = Hashtbl.add macro2utf8 "intprod" "⨼"
-let _ = Hashtbl.add macro2utf8 "ReverseUpEquilibrium" "⥯"
-let _ = Hashtbl.add macro2utf8 "icy" "и"
-let _ = Hashtbl.add macro2utf8 "quatint" "â¨\150"
-let _ = Hashtbl.add macro2utf8 "nbump" "â\137\142̸"
-let _ = Hashtbl.add macro2utf8 "downharpoonleft" "â\135\131"
-let _ = Hashtbl.add macro2utf8 "otimesas" "⨶"
-let _ = Hashtbl.add macro2utf8 "nvHarr" "â\135\142"
-let _ = Hashtbl.add macro2utf8 "ContourIntegral" "â\136®"
+let _ = Hashtbl.add macro2utf8 "lneqq" "\226\137\168"
+let _ = Hashtbl.add macro2utf8 "TildeEqual" "\226\137\131"
+let _ = Hashtbl.add macro2utf8 "shortmid" "\226\136\163\239\184\128"
+let _ = Hashtbl.add macro2utf8 "Qopf" "\226\132\154"
+let _ = Hashtbl.add macro2utf8 "drcorn" "\226\140\159"
+let _ = Hashtbl.add macro2utf8 "ZeroWidthSpace" "\226\128\139"
+let _ = Hashtbl.add macro2utf8 "aogon" "\196\133"
+let _ = Hashtbl.add macro2utf8 "Rsh" "\226\134\177"
+let _ = Hashtbl.add macro2utf8 "lrarr" "\226\135\134"
+let _ = Hashtbl.add macro2utf8 "cupdot" "\226\138\141"
+let _ = Hashtbl.add macro2utf8 "Xopf" "\240\157\149\143"
+let _ = Hashtbl.add macro2utf8 "Backslash" "\226\136\150"
+let _ = Hashtbl.add macro2utf8 "Union" "\226\139\131"
+let _ = Hashtbl.add macro2utf8 "ratio" "\226\136\182"
+let _ = Hashtbl.add macro2utf8 "duarr" "\226\135\181"
+let _ = Hashtbl.add macro2utf8 "lates" "\226\170\173\239\184\128"
+let _ = Hashtbl.add macro2utf8 "suphsub" "\226\171\151"
+let _ = Hashtbl.add macro2utf8 "gamma" "\206\179"
+let _ = Hashtbl.add macro2utf8 "squf" "\226\150\170"
+let _ = Hashtbl.add macro2utf8 "gamma" "\206\179"
+let _ = Hashtbl.add macro2utf8 "lrhard" "\226\165\173"
+let _ = Hashtbl.add macro2utf8 "intprod" "\226\168\188"
+let _ = Hashtbl.add macro2utf8 "ReverseUpEquilibrium" "\226\165\175"
+let _ = Hashtbl.add macro2utf8 "icy" "\208\184"
+let _ = Hashtbl.add macro2utf8 "quatint" "\226\168\150"
+let _ = Hashtbl.add macro2utf8 "nbump" "\226\137\142\204\184"
+let _ = Hashtbl.add macro2utf8 "downharpoonleft" "\226\135\131"
+let _ = Hashtbl.add macro2utf8 "otimesas" "\226\168\182"
+let _ = Hashtbl.add macro2utf8 "nvHarr" "\226\135\142"
+let _ = Hashtbl.add macro2utf8 "ContourIntegral" "\226\136\174"
let _ = Hashtbl.add macro2utf8 "bsol" "\\"
-let _ = Hashtbl.add macro2utf8 "DoubleUpDownArrow" "â\135\149"
-let _ = Hashtbl.add macro2utf8 "disin" "â\139²"
-let _ = Hashtbl.add macro2utf8 "Breve" "Ë\152"
-let _ = Hashtbl.add macro2utf8 "YAcy" "Я"
-let _ = Hashtbl.add macro2utf8 "precsim" "â\137¾"
-let _ = Hashtbl.add macro2utf8 "NotGreaterGreater" "â\137«Ì¸ï¸\128"
-let _ = Hashtbl.add macro2utf8 "fopf" "ð\157\149\151"
-let _ = Hashtbl.add macro2utf8 "SquareSupersetEqual" "â\138\146"
-let _ = Hashtbl.add macro2utf8 "Dscr" "ð\157\146\159"
-let _ = Hashtbl.add macro2utf8 "gsime" "âª\142"
-let _ = Hashtbl.add macro2utf8 "PartialD" "â\136\130"
-let _ = Hashtbl.add macro2utf8 "Umacr" "Ū"
-let _ = Hashtbl.add macro2utf8 "tfr" "ð\157\148±"
-let _ = Hashtbl.add macro2utf8 "cularrp" "⤽"
-let _ = Hashtbl.add macro2utf8 "UnderBracket" "â\142µ"
-let _ = Hashtbl.add macro2utf8 "ugrave" "ù"
-let _ = Hashtbl.add macro2utf8 "mopf" "ð\157\149\158"
-let _ = Hashtbl.add macro2utf8 "gsiml" "âª\144"
-let _ = Hashtbl.add macro2utf8 "iquest" "¿"
-let _ = Hashtbl.add macro2utf8 "nmid" "â\136¤"
-let _ = Hashtbl.add macro2utf8 "leftarrowtail" "â\134¢"
-let _ = Hashtbl.add macro2utf8 "not" "¬"
-let _ = Hashtbl.add macro2utf8 "Kscr" "ð\157\146¦"
-let _ = Hashtbl.add macro2utf8 "xsqcup" "â\138\148"
-let _ = Hashtbl.add macro2utf8 "triangleleft" "â\151\131"
-let _ = Hashtbl.add macro2utf8 "triangleleft" "â\151\131"
-let _ = Hashtbl.add macro2utf8 "amalg" "⨿"
-let _ = Hashtbl.add macro2utf8 "amalg" "⨿"
-let _ = Hashtbl.add macro2utf8 "prcue" "â\137¼"
-let _ = Hashtbl.add macro2utf8 "ac" "â¤\143"
-let _ = Hashtbl.add macro2utf8 "nharr" "â\134®"
-let _ = Hashtbl.add macro2utf8 "dzcy" "Ñ\159"
-let _ = Hashtbl.add macro2utf8 "topf" "ð\157\149¥"
-let _ = Hashtbl.add macro2utf8 "iff" "â\135\148"
-let _ = Hashtbl.add macro2utf8 "af" "â\129¡"
-let _ = Hashtbl.add macro2utf8 "Uparrow" "â\135\145"
-let _ = Hashtbl.add macro2utf8 "Uparrow" "â\135\145"
-let _ = Hashtbl.add macro2utf8 "Iacute" "Ã\141"
-let _ = Hashtbl.add macro2utf8 "Rscr" "â\132\155"
-let _ = Hashtbl.add macro2utf8 "vrtri" "â\138³"
-let _ = Hashtbl.add macro2utf8 "multimap" "â\138¸"
-let _ = Hashtbl.add macro2utf8 "Hat" "Ì\130"
-let _ = Hashtbl.add macro2utf8 "rtriltri" "â§\142"
-let _ = Hashtbl.add macro2utf8 "npr" "â\138\128"
-let _ = Hashtbl.add macro2utf8 "agrave" "à"
-let _ = Hashtbl.add macro2utf8 "prime" "â\128²"
-let _ = Hashtbl.add macro2utf8 "UnderBar" "̲"
-let _ = Hashtbl.add macro2utf8 "prime" "â\128²"
-let _ = Hashtbl.add macro2utf8 "plusmn" "±"
-let _ = Hashtbl.add macro2utf8 "eplus" "⩱"
-let _ = Hashtbl.add macro2utf8 "ap" "â\137\136"
-let _ = Hashtbl.add macro2utf8 "dlcorn" "â\140\158"
-let _ = Hashtbl.add macro2utf8 "backsim" "â\136½"
-let _ = Hashtbl.add macro2utf8 "ifr" "ð\157\148¦"
-let _ = Hashtbl.add macro2utf8 "bigcup" "â\139\131"
-let _ = Hashtbl.add macro2utf8 "bigcup" "â\139\131"
-let _ = Hashtbl.add macro2utf8 "tcaron" "ť"
-let _ = Hashtbl.add macro2utf8 "sqcaps" "â\138\147ï¸\128"
+let _ = Hashtbl.add macro2utf8 "DoubleUpDownArrow" "\226\135\149"
+let _ = Hashtbl.add macro2utf8 "disin" "\226\139\178"
+let _ = Hashtbl.add macro2utf8 "Breve" "\203\152"
+let _ = Hashtbl.add macro2utf8 "YAcy" "\208\175"
+let _ = Hashtbl.add macro2utf8 "precsim" "\226\137\190"
+let _ = Hashtbl.add macro2utf8 "NotGreaterGreater" "\226\137\171\204\184\239\184\128"
+let _ = Hashtbl.add macro2utf8 "fopf" "\240\157\149\151"
+let _ = Hashtbl.add macro2utf8 "SquareSupersetEqual" "\226\138\146"
+let _ = Hashtbl.add macro2utf8 "Dscr" "\240\157\146\159"
+let _ = Hashtbl.add macro2utf8 "gsime" "\226\170\142"
+let _ = Hashtbl.add macro2utf8 "PartialD" "\226\136\130"
+let _ = Hashtbl.add macro2utf8 "Umacr" "\197\170"
+let _ = Hashtbl.add macro2utf8 "tfr" "\240\157\148\177"
+let _ = Hashtbl.add macro2utf8 "cularrp" "\226\164\189"
+let _ = Hashtbl.add macro2utf8 "UnderBracket" "\226\142\181"
+let _ = Hashtbl.add macro2utf8 "ugrave" "\195\185"
+let _ = Hashtbl.add macro2utf8 "mopf" "\240\157\149\158"
+let _ = Hashtbl.add macro2utf8 "gsiml" "\226\170\144"
+let _ = Hashtbl.add macro2utf8 "iquest" "\194\191"
+let _ = Hashtbl.add macro2utf8 "nmid" "\226\136\164"
+let _ = Hashtbl.add macro2utf8 "leftarrowtail" "\226\134\162"
+let _ = Hashtbl.add macro2utf8 "not" "\194\172"
+let _ = Hashtbl.add macro2utf8 "Kscr" "\240\157\146\166"
+let _ = Hashtbl.add macro2utf8 "xsqcup" "\226\138\148"
+let _ = Hashtbl.add macro2utf8 "triangleleft" "\226\151\131"
+let _ = Hashtbl.add macro2utf8 "triangleleft" "\226\151\131"
+let _ = Hashtbl.add macro2utf8 "amalg" "\226\168\191"
+let _ = Hashtbl.add macro2utf8 "amalg" "\226\168\191"
+let _ = Hashtbl.add macro2utf8 "prcue" "\226\137\188"
+let _ = Hashtbl.add macro2utf8 "ac" "\226\164\143"
+let _ = Hashtbl.add macro2utf8 "nharr" "\226\134\174"
+let _ = Hashtbl.add macro2utf8 "dzcy" "\209\159"
+let _ = Hashtbl.add macro2utf8 "topf" "\240\157\149\165"
+let _ = Hashtbl.add macro2utf8 "iff" "\226\135\148"
+let _ = Hashtbl.add macro2utf8 "af" "\226\129\161"
+let _ = Hashtbl.add macro2utf8 "Uparrow" "\226\135\145"
+let _ = Hashtbl.add macro2utf8 "Uparrow" "\226\135\145"
+let _ = Hashtbl.add macro2utf8 "Iacute" "\195\141"
+let _ = Hashtbl.add macro2utf8 "Rscr" "\226\132\155"
+let _ = Hashtbl.add macro2utf8 "vrtri" "\226\138\179"
+let _ = Hashtbl.add macro2utf8 "multimap" "\226\138\184"
+let _ = Hashtbl.add macro2utf8 "Hat" "\204\130"
+let _ = Hashtbl.add macro2utf8 "rtriltri" "\226\167\142"
+let _ = Hashtbl.add macro2utf8 "npr" "\226\138\128"
+let _ = Hashtbl.add macro2utf8 "agrave" "\195\160"
+let _ = Hashtbl.add macro2utf8 "prime" "\226\128\178"
+let _ = Hashtbl.add macro2utf8 "UnderBar" "\204\178"
+let _ = Hashtbl.add macro2utf8 "prime" "\226\128\178"
+let _ = Hashtbl.add macro2utf8 "plusmn" "\194\177"
+let _ = Hashtbl.add macro2utf8 "eplus" "\226\169\177"
+let _ = Hashtbl.add macro2utf8 "ap" "\226\137\136"
+let _ = Hashtbl.add macro2utf8 "dlcorn" "\226\140\158"
+let _ = Hashtbl.add macro2utf8 "backsim" "\226\136\189"
+let _ = Hashtbl.add macro2utf8 "ifr" "\240\157\148\166"
+let _ = Hashtbl.add macro2utf8 "bigcup" "\226\139\131"
+let _ = Hashtbl.add macro2utf8 "bigcup" "\226\139\131"
+let _ = Hashtbl.add macro2utf8 "tcaron" "\197\165"
+let _ = Hashtbl.add macro2utf8 "sqcaps" "\226\138\147\239\184\128"
let _ = Hashtbl.add macro2utf8 "equals" "="
-let _ = Hashtbl.add macro2utf8 "curlywedge" "â\139\143"
+let _ = Hashtbl.add macro2utf8 "curlywedge" "\226\139\143"
let _ = Hashtbl.add macro2utf8 "longrightarrow" "????"
-let _ = Hashtbl.add macro2utf8 "Yscr" "ð\157\146´"
-let _ = Hashtbl.add macro2utf8 "longrightarrow" "ï\149·"
-let _ = Hashtbl.add macro2utf8 "fork" "â\139\148"
+let _ = Hashtbl.add macro2utf8 "Yscr" "\240\157\146\180"
+let _ = Hashtbl.add macro2utf8 "longrightarrow" "\239\149\183"
+let _ = Hashtbl.add macro2utf8 "fork" "\226\139\148"
let _ = Hashtbl.add macro2utf8 "cos" "cos"
let _ = Hashtbl.add macro2utf8 "cot" "cot"
-let _ = Hashtbl.add macro2utf8 "ImaginaryI" "â\133\136"
-let _ = Hashtbl.add macro2utf8 "Scy" "С"
-let _ = Hashtbl.add macro2utf8 "mapsto" "â\134¦"
-let _ = Hashtbl.add macro2utf8 "mapsto" "â\134¦"
-let _ = Hashtbl.add macro2utf8 "tdot" "â\131\155"
-let _ = Hashtbl.add macro2utf8 "vellip" "â\139®"
-let _ = Hashtbl.add macro2utf8 "sqsupseteq" "â\138\146"
-let _ = Hashtbl.add macro2utf8 "sqsupseteq" "â\138\146"
-let _ = Hashtbl.add macro2utf8 "nvdash" "â\138¬"
-let _ = Hashtbl.add macro2utf8 "NotSuperset" "â\138\133"
-let _ = Hashtbl.add macro2utf8 "DoubleUpArrow" "â\135\145"
-let _ = Hashtbl.add macro2utf8 "land" "â\136§"
-let _ = Hashtbl.add macro2utf8 "topfork" "â«\154"
-let _ = Hashtbl.add macro2utf8 "llhard" "⥫"
+let _ = Hashtbl.add macro2utf8 "ImaginaryI" "\226\133\136"
+let _ = Hashtbl.add macro2utf8 "Scy" "\208\161"
+let _ = Hashtbl.add macro2utf8 "mapsto" "\226\134\166"
+let _ = Hashtbl.add macro2utf8 "mapsto" "\226\134\166"
+let _ = Hashtbl.add macro2utf8 "tdot" "\226\131\155"
+let _ = Hashtbl.add macro2utf8 "vellip" "\226\139\174"
+let _ = Hashtbl.add macro2utf8 "sqsupseteq" "\226\138\146"
+let _ = Hashtbl.add macro2utf8 "sqsupseteq" "\226\138\146"
+let _ = Hashtbl.add macro2utf8 "nvdash" "\226\138\172"
+let _ = Hashtbl.add macro2utf8 "NotSuperset" "\226\138\133"
+let _ = Hashtbl.add macro2utf8 "DoubleUpArrow" "\226\135\145"
+let _ = Hashtbl.add macro2utf8 "land" "\226\136\167"
+let _ = Hashtbl.add macro2utf8 "topfork" "\226\171\154"
+let _ = Hashtbl.add macro2utf8 "llhard" "\226\165\171"
let _ = Hashtbl.add macro2utf8 "apos" "'"
-let _ = Hashtbl.add macro2utf8 "oslash" "ø"
-let _ = Hashtbl.add macro2utf8 "oslash" "ø"
-let _ = Hashtbl.add macro2utf8 "lang" "â\140©"
-let _ = Hashtbl.add macro2utf8 "bernou" "â\132¬"
-let _ = Hashtbl.add macro2utf8 "varrho" "ϱ"
-let _ = Hashtbl.add macro2utf8 "varrho" "ϱ"
+let _ = Hashtbl.add macro2utf8 "oslash" "\195\184"
+let _ = Hashtbl.add macro2utf8 "oslash" "\195\184"
+let _ = Hashtbl.add macro2utf8 "lang" "\226\140\169"
+let _ = Hashtbl.add macro2utf8 "bernou" "\226\132\172"
+let _ = Hashtbl.add macro2utf8 "varrho" "\207\177"
+let _ = Hashtbl.add macro2utf8 "varrho" "\207\177"
let _ = Hashtbl.add macro2utf8 "rcub" "}"
-let _ = Hashtbl.add macro2utf8 "Cedilla" "¸"
-let _ = Hashtbl.add macro2utf8 "ApplyFunction" "â\129¡"
-let _ = Hashtbl.add macro2utf8 "nsce" "⪰̸"
-let _ = Hashtbl.add macro2utf8 "gscr" "â\132\138"
-let _ = Hashtbl.add macro2utf8 "imagpart" "â\132\145"
-let _ = Hashtbl.add macro2utf8 "ngtr" "â\137¯"
-let _ = Hashtbl.add macro2utf8 "nsc" "â\138\129"
-let _ = Hashtbl.add macro2utf8 "Barv" "⫧"
-let _ = Hashtbl.add macro2utf8 "tosa" "⤩"
-let _ = Hashtbl.add macro2utf8 "nwnear" "⤧"
-let _ = Hashtbl.add macro2utf8 "ltlarr" "⥶"
-let _ = Hashtbl.add macro2utf8 "PrecedesEqual" "⪯"
-let _ = Hashtbl.add macro2utf8 "lessapprox" "â\137²"
-let _ = Hashtbl.add macro2utf8 "Lcaron" "Ľ"
+let _ = Hashtbl.add macro2utf8 "Cedilla" "\194\184"
+let _ = Hashtbl.add macro2utf8 "ApplyFunction" "\226\129\161"
+let _ = Hashtbl.add macro2utf8 "nsce" "\226\170\176\204\184"
+let _ = Hashtbl.add macro2utf8 "gscr" "\226\132\138"
+let _ = Hashtbl.add macro2utf8 "imagpart" "\226\132\145"
+let _ = Hashtbl.add macro2utf8 "ngtr" "\226\137\175"
+let _ = Hashtbl.add macro2utf8 "nsc" "\226\138\129"
+let _ = Hashtbl.add macro2utf8 "Barv" "\226\171\167"
+let _ = Hashtbl.add macro2utf8 "tosa" "\226\164\169"
+let _ = Hashtbl.add macro2utf8 "nwnear" "\226\164\167"
+let _ = Hashtbl.add macro2utf8 "ltlarr" "\226\165\182"
+let _ = Hashtbl.add macro2utf8 "PrecedesEqual" "\226\170\175"
+let _ = Hashtbl.add macro2utf8 "lessapprox" "\226\137\178"
+let _ = Hashtbl.add macro2utf8 "Lcaron" "\196\189"
projects / helm.git / commitdiff