From: Enrico Tassi Date: Wed, 1 Dec 2004 09:42:42 +0000 (+0000) Subject: Added universes handling. The PRE_UNIVERSES tag may help ;) X-Git-Tag: V_0_1_0~175 X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=commitdiff_plain;h=31851952e1cc2db59168c5fd6f6093d9bc37ea86;p=helm.git Added universes handling. The PRE_UNIVERSES tag may help ;) --- diff --git a/helm/ocaml/METAS/meta.helm-cic.src b/helm/ocaml/METAS/meta.helm-cic.src index ee898d894..d096cab7f 100644 --- a/helm/ocaml/METAS/meta.helm-cic.src +++ b/helm/ocaml/METAS/meta.helm-cic.src @@ -1,4 +1,4 @@ -requires="helm-urimanager helm-pxp" +requires="helm-urimanager helm-pxp helm-xml" version="0.0.1" archive(byte)="cic.cma" archive(native)="cic.cmxa" diff --git a/helm/ocaml/cic/Makefile b/helm/ocaml/cic/Makefile index 8fb3c7c0c..176baf453 100644 --- a/helm/ocaml/cic/Makefile +++ b/helm/ocaml/cic/Makefile @@ -1,5 +1,5 @@ PACKAGE = cic -REQUIRES = helm-urimanager helm-pxp +REQUIRES = helm-urimanager helm-pxp helm-xml PREDICATES = INTERFACE_FILES = \ diff --git a/helm/ocaml/cic/cicUniv.ml b/helm/ocaml/cic/cicUniv.ml index 05e0a99a1..7e6bde44e 100644 --- a/helm/ocaml/cic/cicUniv.ml +++ b/helm/ocaml/cic/cicUniv.ml @@ -23,519 +23,884 @@ * http://cs.unibo.it/helm/. *) -(******************************************************************************) -(* *) -(* PROJECT HELM *) -(* *) -(* Enrico Tassi *) -(* 23/04/2004 *) -(* *) -(* This module implements the aciclic graph of universes. *) -(* *) -(******************************************************************************) +(*****************************************************************************) +(* *) +(* PROJECT HELM *) +(* *) +(* Enrico Tassi *) +(* 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 +;; + + +(*****************************************************************************) +(** _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 **) -(******************************************************************************) + +(*****************************************************************************) +(** 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' + + +(*****************************************************************************) +(** 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 "\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 + + +(*****************************************************************************) +(** 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 *) diff --git a/helm/ocaml/cic/cicUniv.mli b/helm/ocaml/cic/cicUniv.mli index f98ea84c6..71ad1ef00 100644 --- a/helm/ocaml/cic/cicUniv.mli +++ b/helm/ocaml/cic/cicUniv.mli @@ -23,27 +23,98 @@ * 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 diff --git a/helm/ocaml/cic_disambiguation/disambiguate.ml b/helm/ocaml/cic_disambiguation/disambiguate.ml index 055630971..c384dc59f 100644 --- a/helm/ocaml/cic_disambiguation/disambiguate.ml +++ b/helm/ocaml/cic_disambiguation/disambiguate.ml @@ -56,20 +56,25 @@ type test_result = | 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 @@ -219,7 +224,8 @@ let interpretate ~context ~env ast = 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 @@ -227,7 +233,8 @@ let interpretate ~context ~env ast = 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 @@ -235,7 +242,8 @@ let interpretate ~context ~env ast = 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 @@ -243,7 +251,8 @@ let interpretate ~context ~env ast = 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 @@ -404,6 +413,7 @@ let domain_of_term ~context ast = | 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 *) @@ -446,7 +456,7 @@ module Make (C: Callbacks) = 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 *) @@ -508,28 +518,26 @@ module Make (C: Callbacks) = (* (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 = @@ -565,15 +573,14 @@ module Make (C: Callbacks) = 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 = @@ -589,15 +596,7 @@ module Make (C: Callbacks) = 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 diff --git a/helm/ocaml/cic_disambiguation/disambiguate.mli b/helm/ocaml/cic_disambiguation/disambiguate.mli index 4c62c894f..b0fe0fcd3 100644 --- a/helm/ocaml/cic_disambiguation/disambiguate.mli +++ b/helm/ocaml/cic_disambiguation/disambiguate.mli @@ -36,9 +36,11 @@ module Make (C : Callbacks) : 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 diff --git a/helm/ocaml/cic_disambiguation/disambiguateTypes.ml b/helm/ocaml/cic_disambiguation/disambiguateTypes.ml index d01f82ee9..18c78a2e8 100644 --- a/helm/ocaml/cic_disambiguation/disambiguateTypes.ml +++ b/helm/ocaml/cic_disambiguation/disambiguateTypes.ml @@ -76,3 +76,4 @@ let string_of_domain dom = Buffer.contents buf *) +let empty_environment = Environment.empty diff --git a/helm/ocaml/cic_disambiguation/disambiguateTypes.mli b/helm/ocaml/cic_disambiguation/disambiguateTypes.mli index db9829e03..e88aa51bf 100644 --- a/helm/ocaml/cic_disambiguation/disambiguateTypes.mli +++ b/helm/ocaml/cic_disambiguation/disambiguateTypes.mli @@ -64,3 +64,4 @@ type term = CicAst.term type tactic = (term, string) TacticAst.tactic type tactical = (term, string) TacticAst.tactical +val empty_environment: environment diff --git a/helm/ocaml/cic_omdoc/cic2acic.ml b/helm/ocaml/cic_omdoc/cic2acic.ml index 071950543..5b95ab4d6 100644 --- a/helm/ocaml/cic_omdoc/cic2acic.ml +++ b/helm/ocaml/cic_omdoc/cic2acic.ml @@ -37,7 +37,7 @@ let type_of_aux'_add_time = ref 0.0;; 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 diff --git a/helm/ocaml/cic_omdoc/cic2content.ml b/helm/ocaml/cic_omdoc/cic2content.ml index 49e2e23ad..56459d197 100644 --- a/helm/ocaml/cic_omdoc/cic2content.ml +++ b/helm/ocaml/cic_omdoc/cic2content.ml @@ -368,11 +368,14 @@ let rec build_subproofs_and_args seed l ~ids_to_inner_types ~ids_to_inner_sorts 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 @@ -538,12 +541,13 @@ and acic2content seed ?name ~ids_to_inner_sorts ~ids_to_inner_types t = 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 = @@ -686,12 +690,13 @@ and inductive seed name id li ~ids_to_inner_types ~ids_to_inner_sorts = 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 diff --git a/helm/ocaml/cic_omdoc/doubleTypeInference.ml b/helm/ocaml/cic_omdoc/doubleTypeInference.ml index 5b0cc01fc..235d8d835 100644 --- a/helm/ocaml/cic_omdoc/doubleTypeInference.ml +++ b/helm/ocaml/cic_omdoc/doubleTypeInference.ml @@ -41,7 +41,7 @@ let double_work = ref 0;; 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 @@ -266,8 +266,8 @@ let type_of_constant 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 constant") in @@ -281,8 +281,8 @@ let type_of_variable uri = 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)) @@ -293,8 +293,8 @@ let type_of_mutual_inductive_defs uri i = 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 @@ -310,8 +310,8 @@ let type_of_mutual_inductive_constr uri i j = 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 @@ -400,11 +400,7 @@ let rec type_of_aux' subterms_to_types metasenv context t expectedty = (* 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) -> @@ -541,9 +537,9 @@ let rec type_of_aux' subterms_to_types metasenv context t expectedty = (* 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 @@ -644,9 +640,9 @@ let rec type_of_aux' subterms_to_types metasenv context t expectedty = 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 @@ -656,9 +652,9 @@ let rec type_of_aux' subterms_to_types metasenv context t expectedty = | 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 @@ -690,11 +686,7 @@ let rec type_of_aux' subterms_to_types metasenv context t expectedty = (* 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? *) diff --git a/helm/ocaml/cic_omdoc/eta_fixing.ml b/helm/ocaml/cic_omdoc/eta_fixing.ml index 29d22ccb9..b86779337 100644 --- a/helm/ocaml/cic_omdoc/eta_fixing.ml +++ b/helm/ocaml/cic_omdoc/eta_fixing.ml @@ -206,8 +206,11 @@ let eta_fix metasenv context t = (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 = @@ -234,7 +237,8 @@ let eta_fix metasenv context t = 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 @@ -252,9 +256,10 @@ let eta_fix metasenv context t = 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 = @@ -292,9 +297,12 @@ let eta_fix metasenv context t = (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) diff --git a/helm/ocaml/cic_proof_checking/.depend b/helm/ocaml/cic_proof_checking/.depend index 9249839cd..808126a3f 100644 --- a/helm/ocaml/cic_proof_checking/.depend +++ b/helm/ocaml/cic_proof_checking/.depend @@ -2,6 +2,8 @@ cicLogger.cmo: cicLogger.cmi 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 diff --git a/helm/ocaml/cic_proof_checking/Makefile b/helm/ocaml/cic_proof_checking/Makefile index 61d7d5002..5a5e21389 100644 --- a/helm/ocaml/cic_proof_checking/Makefile +++ b/helm/ocaml/cic_proof_checking/Makefile @@ -1,13 +1,13 @@ 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) diff --git a/helm/ocaml/cic_proof_checking/cicEnvironment.ml b/helm/ocaml/cic_proof_checking/cicEnvironment.ml index 0c5c9c01e..0f01a0a55 100644 --- a/helm/ocaml/cic_proof_checking/cicEnvironment.ml +++ b/helm/ocaml/cic_proof_checking/cicEnvironment.ml @@ -23,17 +23,18 @@ * http://cs.unibo.it/helm/. *) -(******************************************************************************) -(* *) -(* PROJECT HELM *) -(* *) -(* Claudio Sacerdoti Coen *) -(* 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 *) +(* 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;; @@ -42,7 +43,7 @@ let set_trust f = trust := f 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 *) ;; @@ -59,25 +60,44 @@ exception Term_not_found of UriManager.uri;; 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 *) @@ -102,10 +122,9 @@ module 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 @@ -127,7 +146,8 @@ module Cache : 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) -> @@ -256,7 +276,12 @@ module Cache : 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 ;; @@ -265,40 +290,119 @@ module Cache : 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" @@ -307,7 +411,11 @@ module Cache : ;; 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 ;; @@ -333,112 +441,173 @@ let find_or_add_unchecked_to_cache uri = (* 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 diff --git a/helm/ocaml/cic_proof_checking/cicEnvironment.mli b/helm/ocaml/cic_proof_checking/cicEnvironment.mli index b7b4a5179..c3ca6ef95 100644 --- a/helm/ocaml/cic_proof_checking/cicEnvironment.mli +++ b/helm/ocaml/cic_proof_checking/cicEnvironment.mli @@ -23,29 +23,37 @@ * http://cs.unibo.it/helm/. *) -(******************************************************************************) -(* *) -(* PROJECT HELM *) -(* *) -(* Claudio Sacerdoti Coen *) -(* 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 *) +(* 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 *) @@ -54,16 +62,27 @@ type type_checked_obj = (* 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 @@ -74,7 +93,9 @@ val remove_term: UriManager.uri -> unit (* 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 *) @@ -85,7 +106,8 @@ exception OnlyPutOfInductiveDefinitionsIsAllowed (* 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 diff --git a/helm/ocaml/cic_proof_checking/cicPp.ml b/helm/ocaml/cic_proof_checking/cicPp.ml index b9a5b72f4..49d004ee0 100644 --- a/helm/ocaml/cic_proof_checking/cicPp.ml +++ b/helm/ocaml/cic_proof_checking/cicPp.ml @@ -109,7 +109,7 @@ let rec pp t l = 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 @@ -119,7 +119,7 @@ let rec pp t 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 @@ -132,7 +132,7 @@ let rec pp t l = ) | 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 diff --git a/helm/ocaml/cic_proof_checking/cicReduction.mli b/helm/ocaml/cic_proof_checking/cicReduction.mli index eaa2265ba..341b0834b 100644 --- a/helm/ocaml/cic_proof_checking/cicReduction.mli +++ b/helm/ocaml/cic_proof_checking/cicReduction.mli @@ -31,4 +31,7 @@ exception ReferenceToInductiveDefinition 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 + diff --git a/helm/ocaml/cic_proof_checking/cicReductionMachine.ml b/helm/ocaml/cic_proof_checking/cicReductionMachine.ml index f53471414..e0fd252a6 100644 --- a/helm/ocaml/cic_proof_checking/cicReductionMachine.ml +++ b/helm/ocaml/cic_proof_checking/cicReductionMachine.ml @@ -353,7 +353,10 @@ prerr_endline ("%%%%%UWVAR " ^ String.concat " ; " (List.map (function (uri,t) - 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 @@ -382,7 +385,10 @@ prerr_endline ("%%%%%UWVAR " ^ String.concat " ; " (List.map (function (uri,t) - | 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 @@ -395,7 +401,10 @@ prerr_endline ("%%%%%UWVAR " ^ String.concat " ; " (List.map (function (uri,t) - 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 @@ -408,7 +417,10 @@ prerr_endline ("%%%%%UWVAR " ^ String.concat " ; " (List.map (function (uri,t) - 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 @@ -530,7 +542,10 @@ if List.mem uri params then prerr_endline "---- OK2" ; 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 @@ -585,7 +600,10 @@ if List.mem uri params then prerr_endline "---- OK2" ; 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 *) @@ -640,11 +658,14 @@ if List.mem uri params then prerr_endline "---- OK2" ; 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 @@ -726,10 +747,22 @@ if List.mem uri params then prerr_endline "---- OK2" ; | (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 = @@ -778,140 +811,210 @@ let whd = R.whd;; 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"; (* @@ -925,8 +1028,9 @@ let are_convertible ?(subst=[]) ?(metasenv=[]) = 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 *) ;; + diff --git a/helm/ocaml/cic_proof_checking/cicReductionMachine.mli b/helm/ocaml/cic_proof_checking/cicReductionMachine.mli index 7a6255003..7e36a05d2 100644 --- a/helm/ocaml/cic_proof_checking/cicReductionMachine.mli +++ b/helm/ocaml/cic_proof_checking/cicReductionMachine.mli @@ -30,4 +30,4 @@ exception ReferenceToCurrentProof 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 diff --git a/helm/ocaml/cic_proof_checking/cicReductionNaif.ml b/helm/ocaml/cic_proof_checking/cicReductionNaif.ml index 95f24ebf3..6a4b07aab 100644 --- a/helm/ocaml/cic_proof_checking/cicReductionNaif.ml +++ b/helm/ocaml/cic_proof_checking/cicReductionNaif.ml @@ -57,7 +57,10 @@ let whd context = | 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 @@ -80,7 +83,10 @@ let whd context = | 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) @@ -120,7 +126,8 @@ let whd context = 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) @@ -182,144 +189,219 @@ t in prerr_endline "DOPO WHD" ; flush stderr ; res ;; (* 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 ;; diff --git a/helm/ocaml/cic_proof_checking/cicReductionNaif.mli b/helm/ocaml/cic_proof_checking/cicReductionNaif.mli index 7a6255003..624eebf5d 100644 --- a/helm/ocaml/cic_proof_checking/cicReductionNaif.mli +++ b/helm/ocaml/cic_proof_checking/cicReductionNaif.mli @@ -30,4 +30,6 @@ exception ReferenceToCurrentProof 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 diff --git a/helm/ocaml/cic_proof_checking/cicSubstitution.ml b/helm/ocaml/cic_proof_checking/cicSubstitution.ml index c718524fc..38f2e7a6d 100644 --- a/helm/ocaml/cic_proof_checking/cicSubstitution.ml +++ b/helm/ocaml/cic_proof_checking/cicSubstitution.ml @@ -202,7 +202,7 @@ prerr_endline ("@@@POSSIBLE BUG: SUBSTITUTION IS NOT SIMULTANEOUS") ; 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 @@ -251,7 +251,7 @@ prerr_endline "---- END\n\n " ; | 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 @@ -265,7 +265,7 @@ prerr_endline "---- END\n\n " ; 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 @@ -279,7 +279,7 @@ prerr_endline "---- END\n\n " ; 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 diff --git a/helm/ocaml/cic_proof_checking/cicTypeChecker.ml b/helm/ocaml/cic_proof_checking/cicTypeChecker.ml index be7c4b0d0..4035b3217 100644 --- a/helm/ocaml/cic_proof_checking/cicTypeChecker.ml +++ b/helm/ocaml/cic_proof_checking/cicTypeChecker.ml @@ -118,86 +118,117 @@ let debrujin_constructor uri number_of_types = 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 @@ -373,7 +404,8 @@ and strictly_positive context n nn te = 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) @@ -462,11 +494,14 @@ and are_all_occurrences_positive context uri indparamsno i n nn te = (* 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. *) @@ -474,99 +509,116 @@ and typecheck_mutual_inductive_defs ~logger uri (itl,_,indparamsno) = (* 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 @@ -687,7 +739,8 @@ and check_is_really_smaller_arg ?(subst = []) context n nn kl x safes te = (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 @@ -725,7 +778,8 @@ and check_is_really_smaller_arg ?(subst = []) context n nn kl x safes te = ) (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 = @@ -851,7 +905,8 @@ and guarded_by_destructors ?(subst = []) context n nn kl x safes = (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 @@ -895,7 +950,8 @@ and guarded_by_destructors ?(subst = []) context n nn kl x safes = ) (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 = @@ -1005,11 +1061,11 @@ and guarded_by_constructors context n nn h te args coInductiveTypeURI = 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 @@ -1176,103 +1232,125 @@ and guarded_by_constructors context n nn h te args coInductiveTypeURI = 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 @@ -1304,128 +1382,157 @@ and type_of_branch context argsno need_dummy outtype term constype = 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)) @@ -1438,39 +1545,63 @@ and type_of_aux' ~logger ?(subst = []) metasenv 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 @@ -1498,28 +1629,68 @@ and type_of_aux' ~logger ?(subst = []) metasenv context t = "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 @@ -1528,23 +1699,30 @@ and type_of_aux' ~logger ?(subst = []) metasenv context t = "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 @@ -1553,133 +1731,167 @@ and type_of_aux' ~logger ?(subst = []) metasenv context t = 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 @@ -1687,59 +1899,69 @@ and type_of_aux' ~logger ?(subst = []) metasenv context t = (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 @@ -1752,7 +1974,8 @@ and type_of_aux' ~logger ?(subst = []) metasenv context t = 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) @@ -1770,93 +1993,125 @@ and type_of_aux' ~logger ?(subst = []) metasenv context t = 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 *) diff --git a/helm/ocaml/cic_proof_checking/cicTypeChecker.mli b/helm/ocaml/cic_proof_checking/cicTypeChecker.mli index 5f7e3ae97..ce94601f2 100644 --- a/helm/ocaml/cic_proof_checking/cicTypeChecker.mli +++ b/helm/ocaml/cic_proof_checking/cicTypeChecker.mli @@ -27,14 +27,19 @@ 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 diff --git a/helm/ocaml/cic_proof_checking/cicUnivUtils.ml b/helm/ocaml/cic_proof_checking/cicUnivUtils.ml new file mode 100644 index 000000000..8182f72e3 --- /dev/null +++ b/helm/ocaml/cic_proof_checking/cicUnivUtils.ml @@ -0,0 +1,163 @@ +(* 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 *) +(* 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) + + + diff --git a/helm/ocaml/cic_proof_checking/cicUnivUtils.mli b/helm/ocaml/cic_proof_checking/cicUnivUtils.mli new file mode 100644 index 000000000..e39ac0ab5 --- /dev/null +++ b/helm/ocaml/cic_proof_checking/cicUnivUtils.mli @@ -0,0 +1,27 @@ +(* 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 diff --git a/helm/ocaml/cic_transformations/acic2Ast.ml b/helm/ocaml/cic_transformations/acic2Ast.ml index 567b7f7bb..d8ded0356 100644 --- a/helm/ocaml/cic_transformations/acic2Ast.ml +++ b/helm/ocaml/cic_transformations/acic2Ast.ml @@ -37,11 +37,12 @@ let sort_of_string = function | _ -> 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 diff --git a/helm/ocaml/cic_transformations/content_expressions.ml b/helm/ocaml/cic_transformations/content_expressions.ml new file mode 100644 index 000000000..65216f5d6 --- /dev/null +++ b/helm/ocaml/cic_transformations/content_expressions.ml @@ -0,0 +1,448 @@ +(* 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 *) +(* 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 +;; + + + + + + + + + + + diff --git a/helm/ocaml/cic_unification/cicRefine.ml b/helm/ocaml/cic_unification/cicRefine.ml index d778ff59f..82b472fa0 100644 --- a/helm/ocaml/cic_unification/cicRefine.ml +++ b/helm/ocaml/cic_unification/cicRefine.ml @@ -31,12 +31,12 @@ exception AssertFailure of string;; 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 = @@ -46,7 +46,7 @@ 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 @@ -57,14 +57,15 @@ let rec type_of_constant uri = 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 @@ -75,14 +76,15 @@ and type_of_variable uri = 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 @@ -93,16 +95,17 @@ and type_of_mutual_inductive_defs uri i = 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 @@ -113,16 +116,18 @@ and type_of_mutual_inductive_constr uri i j = 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. @@ -132,36 +137,36 @@ and type_of_mutual_inductive_constr uri i j = 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 @@ -170,70 +175,72 @@ and type_of_aux' metasenv context t = 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 _ -> () @@ -243,58 +250,62 @@ and type_of_aux' metasenv context t = 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 @@ -302,9 +313,10 @@ and type_of_aux' metasenv context t = 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 @@ -330,48 +342,48 @@ and type_of_aux' metasenv context t = 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' = @@ -382,8 +394,8 @@ and type_of_aux' metasenv context t = (* (* 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 @@ -398,59 +410,59 @@ and type_of_aux' metasenv context t = (* 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 @@ -473,28 +485,28 @@ and type_of_aux' metasenv context t = 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 @@ -504,13 +516,14 @@ and type_of_aux' metasenv context t = (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,_,_) -> @@ -524,22 +537,23 @@ and type_of_aux' metasenv context t = ("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 @@ -547,17 +561,17 @@ and type_of_aux' metasenv context t = 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 *) @@ -566,17 +580,17 @@ and type_of_aux' metasenv context t = * 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 [] -> @@ -615,9 +629,9 @@ and type_of_aux' metasenv context t = 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) @@ -627,15 +641,15 @@ and type_of_aux' metasenv context t = 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) @@ -666,18 +680,18 @@ and type_of_aux' metasenv context t = *) 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 @@ -718,11 +732,9 @@ and type_of_aux' metasenv context t = (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 diff --git a/helm/ocaml/cic_unification/cicRefine.mli b/helm/ocaml/cic_unification/cicRefine.mli index c239f8e1f..4289905c8 100644 --- a/helm/ocaml/cic_unification/cicRefine.mli +++ b/helm/ocaml/cic_unification/cicRefine.mli @@ -31,5 +31,5 @@ exception AssertFailure of string;; (* 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 diff --git a/helm/ocaml/cic_unification/cicUnification.ml b/helm/ocaml/cic_unification/cicUnification.ml index c88e6b78d..4cfc79660 100644 --- a/helm/ocaml/cic_unification/cicUnification.ml +++ b/helm/ocaml/cic_unification/cicUnification.ml @@ -31,9 +31,9 @@ exception AssertFailure of string;; 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 = @@ -47,8 +47,9 @@ let type_of_aux' metasenv subst context term = (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 @@ -71,26 +72,44 @@ let rec deref subst = | 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 @@ -101,81 +120,105 @@ let rec beta_expand test_equality_only metasenv subst context t arg = (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 @@ -185,8 +228,8 @@ let rec beta_expand test_equality_only metasenv subst context t arg = 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 @@ -196,36 +239,49 @@ let rec beta_expand test_equality_only metasenv subst context t arg = 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 @@ -236,47 +292,94 @@ and beta_expand_many test_equality_only metasenv subst context t args = 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 @@ -291,9 +394,10 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str (* (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 = @@ -305,18 +409,93 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str 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 -> @@ -330,7 +509,7 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str * 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 @@ -339,34 +518,37 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str 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 @@ -375,7 +557,7 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str | 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 @@ -385,7 +567,7 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str 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 @@ -393,26 +575,36 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str (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 = @@ -435,6 +627,13 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str (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 @@ -448,7 +647,15 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str 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 @@ -463,36 +670,55 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str 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")) @@ -500,7 +726,7 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str "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 @@ -512,31 +738,42 @@ prerr_endline ("restringo Meta n." ^ (string_of_int n) ^ "on variable n." ^ (str | (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 = @@ -556,26 +793,28 @@ and fo_unif_subst_exp_named_subst test_equality_only subst context metasenv (* 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)) diff --git a/helm/ocaml/cic_unification/cicUnification.mli b/helm/ocaml/cic_unification/cicUnification.mli index 9d26fd3df..2c8e12f60 100644 --- a/helm/ocaml/cic_unification/cicUnification.mli +++ b/helm/ocaml/cic_unification/cicUnification.mli @@ -34,8 +34,9 @@ exception AssertFailure of string;; (* 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] *) @@ -51,7 +52,7 @@ val fo_unif : (*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 diff --git a/helm/ocaml/cic_unification/freshNamesGenerator.ml b/helm/ocaml/cic_unification/freshNamesGenerator.ml index 3bdde5b59..fbb90552a 100644 --- a/helm/ocaml/cic_unification/freshNamesGenerator.ml +++ b/helm/ocaml/cic_unification/freshNamesGenerator.ml @@ -34,7 +34,10 @@ let mk_fresh_name ~subst metasenv context name ~typ = 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" diff --git a/helm/ocaml/getter/.depend b/helm/ocaml/getter/.depend index 295c638b9..fb041c6e0 100644 --- a/helm/ocaml/getter/.depend +++ b/helm/ocaml/getter/.depend @@ -18,8 +18,8 @@ http_getter_common.cmo: http_getter_env.cmi http_getter_misc.cmi \ 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 diff --git a/helm/ocaml/getter/http_getter.ml b/helm/ocaml/getter/http_getter.ml index 35a19db82..539fa90a7 100644 --- a/helm/ocaml/getter/http_getter.ml +++ b/helm/ocaml/getter/http_getter.ml @@ -77,7 +77,7 @@ let map_of_uri = function | 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); @@ -230,11 +230,17 @@ let resolve_remote uri = 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 = @@ -263,8 +269,17 @@ let resolve uri = 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 @@ -287,7 +302,9 @@ let getxml ?(format = `Normal) ?(patch_dtd = true) uri = 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; @@ -299,6 +316,7 @@ let getxslt ?(patch_dtd = true) uri = 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; diff --git a/helm/ocaml/getter/http_getter_misc.ml b/helm/ocaml/getter/http_getter_misc.ml index ba7e7defa..eeea89160 100644 --- a/helm/ocaml/getter/http_getter_misc.ml +++ b/helm/ocaml/getter/http_getter_misc.ml @@ -62,18 +62,37 @@ let hashtbl_sorted_iter f tbl = 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 @@ -144,11 +163,11 @@ let gunzip ?(keep = false) ?output fname = 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 ;; diff --git a/helm/ocaml/mathql_generator/cGMatchConclusion.ml b/helm/ocaml/mathql_generator/cGMatchConclusion.ml index 1e721a456..70dfde475 100644 --- a/helm/ocaml/mathql_generator/cGMatchConclusion.ml +++ b/helm/ocaml/mathql_generator/cGMatchConclusion.ml @@ -50,7 +50,7 @@ let levels_of_term metasenv context term = | 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) = diff --git a/helm/ocaml/metadata/.depend b/helm/ocaml/metadata/.depend index 07fbe69d7..15500d2c4 100644 --- a/helm/ocaml/metadata/.depend +++ b/helm/ocaml/metadata/.depend @@ -3,8 +3,8 @@ metadataPp.cmi: metadataTypes.cmo 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 \ diff --git a/helm/ocaml/tactics/discriminationTactics.ml b/helm/ocaml/tactics/discriminationTactics.ml index ceaccdcef..66a860a45 100644 --- a/helm/ocaml/tactics/discriminationTactics.ml +++ b/helm/ocaml/tactics/discriminationTactics.ml @@ -32,10 +32,11 @@ let rec injection_tac ~term = 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) -> ( @@ -88,11 +89,12 @@ and injection1_tac ~term ~i = 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)) @@ -110,13 +112,16 @@ and injection1_tac ~term ~i = (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 @@ -218,9 +223,10 @@ let discriminate'_tac ~term = 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) -> ( @@ -269,7 +275,8 @@ prerr_endline ("XXXX consno2 " ^ (string_of_int consno2)) ; 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 @@ -327,17 +334,21 @@ prerr_endline ("XXXX nth funzionano ") ; ) ~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) @@ -490,7 +501,8 @@ prerr_endline ("XXXX consno2' " ^ (string_of_int consno2')) ; 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 diff --git a/helm/ocaml/tactics/eliminationTactics.ml b/helm/ocaml/tactics/eliminationTactics.ml index b75e2da89..15645951e 100644 --- a/helm/ocaml/tactics/eliminationTactics.ml +++ b/helm/ocaml/tactics/eliminationTactics.ml @@ -94,9 +94,9 @@ let decompose_tac ?(uris_choice_callback=(function l -> l)) term = 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) *) @@ -136,7 +136,9 @@ let decompose_tac ?(uris_choice_callback=(function l -> l)) term = 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) diff --git a/helm/ocaml/tactics/equalityTactics.ml b/helm/ocaml/tactics/equalityTactics.ml index fe566ab74..718a1bac2 100644 --- a/helm/ocaml/tactics/equalityTactics.ml +++ b/helm/ocaml/tactics/equalityTactics.ml @@ -24,13 +24,16 @@ *) 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 = @@ -66,9 +69,9 @@ let rewrite_tac ~term:equality = [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) ;; @@ -81,7 +84,7 @@ let rewrite_simpl_tac ~term = (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) ;; @@ -91,8 +94,11 @@ let rewrite_back_tac ~term:equality = 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 = @@ -154,34 +160,35 @@ let replace_tac ~what ~with_what = 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) ;; diff --git a/helm/ocaml/tactics/metadataQuery.ml b/helm/ocaml/tactics/metadataQuery.ml index e5656b9b3..180091c0a 100644 --- a/helm/ocaml/tactics/metadataQuery.ml +++ b/helm/ocaml/tactics/metadataQuery.ml @@ -94,15 +94,27 @@ let compare_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 - 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 diff --git a/helm/ocaml/tactics/negationTactics.ml b/helm/ocaml/tactics/negationTactics.ml index a4b7d9ba8..c8c9785da 100644 --- a/helm/ocaml/tactics/negationTactics.ml +++ b/helm/ocaml/tactics/negationTactics.ml @@ -29,19 +29,21 @@ let absurd_tac ~term = 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 = diff --git a/helm/ocaml/tactics/primitiveTactics.ml b/helm/ocaml/tactics/primitiveTactics.ml index f959746e2..0cb8acead 100644 --- a/helm/ocaml/tactics/primitiveTactics.ml +++ b/helm/ocaml/tactics/primitiveTactics.ml @@ -115,8 +115,8 @@ let eta_expand metasenv context t arg = 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:[] @@ -204,11 +204,12 @@ let = 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 @@ -219,10 +220,11 @@ let [],[] -> [] | 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 @@ -301,17 +303,19 @@ let apply_tac_verbose ~term (proof, goal) = | _ -> [],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 @@ -364,7 +368,7 @@ let apply_tac ~term = 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 @@ -425,7 +429,8 @@ let letin_tac ?(mk_fresh_name_callback=FreshNamesGenerator.mk_fresh_name ~subst: 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 @@ -453,7 +458,9 @@ let exact_tac ~term = 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 @@ -473,7 +480,8 @@ let elim_tac ~term = 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,[]) @@ -484,24 +492,28 @@ let elim_tac ~term = 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 @@ -520,8 +532,9 @@ let elim_tac ~term = 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 @@ -560,37 +573,45 @@ exception NotConvertible (*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) + diff --git a/helm/ocaml/tactics/proofEngineReduction.ml b/helm/ocaml/tactics/proofEngineReduction.ml index 99eb43f6a..e7975793f 100644 --- a/helm/ocaml/tactics/proofEngineReduction.ml +++ b/helm/ocaml/tactics/proofEngineReduction.ml @@ -389,7 +389,8 @@ let reduce context = 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 @@ -429,7 +430,8 @@ let reduce context = 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)) @@ -490,11 +492,12 @@ let reduce context = 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 = @@ -612,7 +615,8 @@ let simpl context = 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 @@ -652,7 +656,8 @@ let simpl context = 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')) @@ -710,11 +715,12 @@ let simpl context = 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 = diff --git a/helm/ocaml/tactics/proofEngineStructuralRules.ml b/helm/ocaml/tactics/proofEngineStructuralRules.ml index e89569445..3b8b6f92c 100644 --- a/helm/ocaml/tactics/proofEngineStructuralRules.ml +++ b/helm/ocaml/tactics/proofEngineStructuralRules.ml @@ -50,8 +50,9 @@ let clearbody ~hyp = 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 @@ -59,9 +60,10 @@ let clearbody ~hyp = | 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 @@ -76,9 +78,10 @@ let clearbody ~hyp = | 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 @@ -122,9 +125,10 @@ let clear ~hyp = | 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 @@ -138,9 +142,10 @@ let clear ~hyp = entry::context ) canonical_context [] in - let _ = + let _,_ = try CicTypeChecker.type_of_aux' metasenv canonical_context' ty + CicUniv.empty_ugraph (* TASSI: FIXME *) with _ -> raise diff --git a/helm/ocaml/tactics/proofEngineTypes.ml b/helm/ocaml/tactics/proofEngineTypes.ml index b4992aca3..e90e43807 100644 --- a/helm/ocaml/tactics/proofEngineTypes.ml +++ b/helm/ocaml/tactics/proofEngineTypes.ml @@ -64,12 +64,7 @@ exception Fail of string 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 = diff --git a/helm/ocaml/tactics/ring.ml b/helm/ocaml/tactics/ring.ml index cf6950c4b..4691239f4 100644 --- a/helm/ocaml/tactics/ring.ml +++ b/helm/ocaml/tactics/ring.ml @@ -495,7 +495,9 @@ let ring_tac status = "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 @@ -536,7 +538,10 @@ let ring_tac status = 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 diff --git a/helm/ocaml/tactics/tacticChaser.ml b/helm/ocaml/tactics/tacticChaser.ml new file mode 100644 index 000000000..2d1b0dcfd --- /dev/null +++ b/helm/ocaml/tactics/tacticChaser.ml @@ -0,0 +1,261 @@ +(* 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 *) +(* 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' = + "

^ Exception raised trying to apply " ^ + uri ^ ": " ^ Printexc.to_string e ^ "

" ^ exc + in + tl',exc' + in + filter_out uris + in + let html' = + "

Objects that can actually be applied:

" ^ + String.concat "
" uris' ^ exc ^ + "

Number of false matches: " ^ + string_of_int (List.length uris - List.length uris') ^ "

" ^ + "

Number of good matches: " ^ + string_of_int (List.length uris') ^ "

" + 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 +;; + diff --git a/helm/ocaml/tactics/tactics.mli b/helm/ocaml/tactics/tactics.mli index 7b771249e..cc2498577 100644 --- a/helm/ocaml/tactics/tactics.mli +++ b/helm/ocaml/tactics/tactics.mli @@ -1,62 +1 @@ (* 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 diff --git a/helm/ocaml/tactics/variousTactics.ml b/helm/ocaml/tactics/variousTactics.ml index 5e2e39c5d..38ad2ebfb 100644 --- a/helm/ocaml/tactics/variousTactics.ml +++ b/helm/ocaml/tactics/variousTactics.ml @@ -36,18 +36,22 @@ let assumption_tac = 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") @@ -75,17 +79,19 @@ let generalize_tac 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 diff --git a/helm/ocaml/utf8_macros/utf8MacroTable.ml b/helm/ocaml/utf8_macros/utf8MacroTable.ml index c5d935591..d33361f3d 100644 --- a/helm/ocaml/utf8_macros/utf8MacroTable.ml +++ b/helm/ocaml/utf8_macros/utf8MacroTable.ml @@ -1,2315 +1,2315 @@ (* 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"