X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Focaml%2Ftactics%2FmetadataQuery.ml;h=b9c0536538e4295726347b7ad82071e1c89ed160;hb=771ee8b9d122fa963881c876e86f90531bb7434f;hp=644e764ef56c18b927777d013cfc6a0dd8bebd3d;hpb=a7b90d2494f7d580faa54ecd2835bd4649129763;p=helm.git

diff --git a/helm/ocaml/tactics/metadataQuery.ml b/helm/ocaml/tactics/metadataQuery.ml
index 644e764ef..b9c053653 100644
--- a/helm/ocaml/tactics/metadataQuery.ml
+++ b/helm/ocaml/tactics/metadataQuery.ml
@@ -23,87 +23,18 @@
  * http://helm.cs.unibo.it/
  *)
 
-open Printf
+(* $Id$ *)
 
-module Constr = MetadataConstraints
-module PET = ProofEngineTypes 
+open Printf
 
-let debug_print = fun _ -> ()
+let nonvar uri = not (UriManager.uri_is_var uri)
 
-  (** maps a shell like pattern (which uses '*' and '?') to a sql pattern for
-  * the "like" operator (which uses '%' and '_'). Does not support escaping. *)
-let sqlpat_of_shellglob =
-  let star_RE, qmark_RE, percent_RE, uscore_RE =
-    Pcre.regexp "\\*", Pcre.regexp "\\?", Pcre.regexp "%", Pcre.regexp "_"
-  in
-  fun shellglob ->
-    Pcre.replace ~rex:star_RE ~templ:"%"
-      (Pcre.replace ~rex:qmark_RE ~templ:"_"
-        (Pcre.replace ~rex:percent_RE ~templ:"\\%"
-          (Pcre.replace ~rex:uscore_RE ~templ:"\\_"
-            shellglob)))
-
-let nonvar s =
-  let s = UriManager.string_of_uri s in
-  let len = String.length s in
-  let suffix = String.sub s (len-4) 4 in
-  not (suffix  = ".var")
+module Constr = MetadataConstraints
 
-let locate ~(dbd:Mysql.dbd) ?(vars = false) pat =
-  let sql_pat = sqlpat_of_shellglob pat in
-  let query =
-        sprintf ("SELECT source FROM %s WHERE value LIKE \"%s\" UNION "^^
-                 "SELECT source FROM %s WHERE value LIKE \"%s\"")
-          (MetadataTypes.name_tbl ()) sql_pat
-           MetadataTypes.library_name_tbl sql_pat
-  in
-  let result = Mysql.exec dbd query in
-  List.filter nonvar
-    (Mysql.map result
-      (fun cols -> match cols.(0) with Some s -> UriManager.uri_of_string s | _ -> assert false))
+exception Goal_is_not_an_equation
 
-let match_term ~(dbd:Mysql.dbd) ty =
-(*   debug_print (CicPp.ppterm ty); *)
-  let metadata = MetadataExtractor.compute ~body:None ~ty in
-  let constants_no =
-    MetadataConstraints.UriManagerSet.cardinal (MetadataConstraints.constants_of ty)
-  in
-  let full_card, diff =
-    if CicUtil.is_meta_closed ty then
-      Some (MetadataConstraints.Eq constants_no), None
-    else
-      let diff_no =
-        let (hyp_constants, concl_constants) =
-          (* collect different constants in hypotheses and conclusions *)
-          List.fold_left
-            (fun ((hyp, concl) as acc) metadata ->
-               match (metadata: MetadataTypes.metadata) with
-               | `Sort _ | `Rel _ -> acc
-               | `Obj (uri, `InConclusion) | `Obj (uri, `MainConclusion _)
-                 when not (List.mem uri concl) -> (hyp, uri :: concl)
-               | `Obj (uri, `InHypothesis) | `Obj (uri, `MainHypothesis _)
-                 when not (List.mem uri hyp) -> (uri :: hyp, concl)
-               | `Obj _ -> acc)
-            ([], [])
-            metadata
-        in
-        List.length hyp_constants - List.length concl_constants
-      in
-      let (concl_metas, hyp_metas) = MetadataExtractor.compute_metas ty in
-      let diff =
-        if MetadataExtractor.IntSet.equal concl_metas hyp_metas then
-          Some (MetadataConstraints.Eq diff_no)
-        else if MetadataExtractor.IntSet.subset concl_metas hyp_metas then
-          Some (MetadataConstraints.Gt (diff_no - 1))
-        else if MetadataExtractor.IntSet.subset hyp_metas concl_metas then
-          Some (MetadataConstraints.Lt (diff_no + 1))
-        else
-          None
-      in
-      None, diff
-  in
-  let constraints = List.map MetadataTypes.constr_of_metadata metadata in
-    Constr.at_least ~dbd ?full_card ?diff constraints
+let debug = false
+let debug_print s = if debug then prerr_endline (Lazy.force s)
 
 let ( ** ) x y = int_of_float ((float_of_int x) ** (float_of_int y))
 
@@ -125,6 +56,19 @@ let intersect uris siguris =
   let inter = Constr.UriManagerSet.inter set1 set2 in
   List.filter (fun s -> Constr.UriManagerSet.mem s inter) uris
 
+(* Profiling code
+let at_most =
+ let profiler = CicUtil.profile "at_most" in
+ fun ~dbd ~where uri -> profiler.profile (Constr.at_most ~dbd ~where) uri
+
+let sigmatch =
+ let profiler = CicUtil.profile "sigmatch" in
+ fun ~dbd ~facts ~where signature ->
+  profiler.profile (MetadataConstraints.sigmatch ~dbd ~facts ~where) signature
+*)
+let at_most = Constr.at_most
+let sigmatch = MetadataConstraints.sigmatch
+
 let filter_uris_forward ~dbd (main, constants) uris =
   let main_uris =
     match main with
@@ -134,12 +78,12 @@ let filter_uris_forward ~dbd (main, constants) uris =
   let full_signature =
     List.fold_right Constr.UriManagerSet.add main_uris constants
   in
-  List.filter (Constr.at_most ~dbd ~where:`Statement full_signature) uris
+  List.filter (at_most ~dbd ~where:`Statement full_signature) uris
 
 let filter_uris_backward ~dbd ~facts signature uris =
   let siguris =
     List.map snd 
-      (MetadataConstraints.sigmatch ~dbd ~facts ~where:`Statement signature)
+      (sigmatch ~dbd ~facts ~where:`Statement signature)
   in
     intersect uris siguris 
 
@@ -171,65 +115,6 @@ let compare_goal_list proof goal1 goal2 =
   in
   prop1 - prop2
 
-let hint ~(dbd:Mysql.dbd) ?(facts=false) ?signature ((proof, goal) as status) =
-  let (_, metasenv, _, _) = proof in
-  let (_, context, ty) = CicUtil.lookup_meta goal metasenv in
-  let (uris, (main, sig_constants)) =
-    match signature with
-    | Some signature -> (Constr.sigmatch ~dbd ~facts signature, signature)
-    | None -> (Constr.cmatch' ~dbd ~facts ty, Constr.signature_of ty)
-  in
-  let uris = List.filter nonvar (List.map snd uris) in
-  let uris = List.filter Hashtbl_equiv.not_a_duplicate uris in
-  let types_constants =
-    match main with
-    | None -> Constr.UriManagerSet.empty
-    | Some (main, types) ->
-        List.fold_right Constr.UriManagerSet.add (main :: types)
-          Constr.UriManagerSet.empty
-  in
-  let hyp_constants =
-    Constr.UriManagerSet.diff (signature_of_hypothesis context) types_constants
-  in
-(* Constr.UriManagerSet.iter debug_print hyp_constants; *)
-  let other_constants = Constr.UriManagerSet.union sig_constants hyp_constants in
-  let uris = 
-    let pow = 2 ** (Constr.UriManagerSet.cardinal other_constants) in
-    if ((List.length uris < pow) or (pow <= 0))
-    then begin
-(*       debug_print "MetadataQuery: large sig, falling back to old method"; *)
-      filter_uris_forward ~dbd (main, other_constants) uris
-    end else
-      filter_uris_backward ~dbd ~facts (main, other_constants) uris
-  in
-  let rec aux = function
-    | [] -> []
-    | uri :: tl ->
-        (let status' =
-            try
-              let (proof, goal_list) =
-(*                debug_print ("STO APPLICANDO " ^ uri); *)
-		PET.apply_tactic
-                  (PrimitiveTactics.apply_tac
-		    ~term:(CicUtil.term_of_uri (UriManager.string_of_uri uri)))
-                  status
-              in
-              let goal_list =
-                List.stable_sort (compare_goal_list proof) goal_list
-              in
-              Some (uri, (proof, goal_list))
-            with ProofEngineTypes.Fail _ -> None
-          in
-          match status' with
-          | None -> aux tl
-          | Some status' ->
-              status' :: aux tl)
-  in
-  List.stable_sort
-    (fun (_, (_, goals1)) (_, (_, goals2)) ->
-      Pervasives.compare (List.length goals1) (List.length goals2))
-    (aux uris)
-
 (* experimental_hint is a version of hint for experimental 
     purposes. It uses auto_tac_verbose instead of auto tac.
     Auto_tac verbose also returns a substitution - for the moment 
@@ -242,23 +127,124 @@ let hint ~(dbd:Mysql.dbd) ?(facts=false) ?signature ((proof, goal) as status) =
 let close_with_types s metasenv context =
   Constr.UriManagerSet.fold 
     (fun e bag -> 
-      let t = CicUtil.term_of_uri (UriManager.string_of_uri e) in
+      let t = CicUtil.term_of_uri e in
       let ty, _ = 
         CicTypeChecker.type_of_aux' metasenv context t CicUniv.empty_ugraph  
       in
       Constr.UriManagerSet.union bag (Constr.constants_of ty)) 
     s s
 
+let close_with_constructors s metasenv context =
+  Constr.UriManagerSet.fold 
+    (fun e bag -> 
+      let t = CicUtil.term_of_uri e in
+      match t with
+	  Cic.MutInd (uri,_,_)  
+	| Cic.MutConstruct (uri,_,_,_) ->  
+	    (match fst (CicEnvironment.get_obj CicUniv.empty_ugraph uri) with
+		 Cic.InductiveDefinition(tl,_,_,_) ->
+		   snd
+		     (List.fold_left
+			(fun (i,s) (_,_,_,cl) ->
+			   let _,s =
+			     List.fold_left 
+			       (fun (j,s) _ -> 
+				  let curi = UriManager.uri_of_uriref uri i (Some j) in
+				    j+1,Constr.UriManagerSet.add curi s) (1,s) cl in
+			     (i+1,s)) (0,bag) tl)
+	       | _ -> assert false)
+	| _ -> bag)
+    s s
+
+(* Profiling code
+let apply_tac_verbose =
+ let profiler = CicUtil.profile "apply_tac_verbose" in
+  fun ~term status -> profiler.profile (PrimitiveTactics.apply_tac_verbose ~term) status
+
+let sigmatch =
+ let profiler = CicUtil.profile "sigmatch" in
+ fun ~dbd ~facts ?(where=`Conclusion) signature -> profiler.profile (Constr.sigmatch ~dbd ~facts ~where) signature
+
+let cmatch' =
+ let profiler = CicUtil.profile "cmatch'" in
+ fun ~dbd ~facts signature -> profiler.profile (Constr.cmatch' ~dbd ~facts) signature
+*)
+let apply_tac_verbose = PrimitiveTactics.apply_tac_verbose
+let cmatch' = Constr.cmatch'
+
+let signature_of_goal ~(dbd:HMysql.dbd) ((proof, goal) as _status) =
+ let (_, metasenv, _, _) = proof in
+ let (_, context, ty) = CicUtil.lookup_meta goal metasenv in
+ let main, sig_constants = Constr.signature_of ty in
+ let set = signature_of_hypothesis context in
+ let set =
+  match main with
+     None -> set
+   | Some (main,l) ->
+      List.fold_right Constr.UriManagerSet.add (main::l) set in
+ let set = Constr.UriManagerSet.union set sig_constants in
+ let all_constants_closed = close_with_types set metasenv context in
+ let uris =
+  sigmatch ~dbd ~facts:false ~where:`Statement (None,all_constants_closed) in
+ let uris = List.filter nonvar (List.map snd uris) in
+ let uris = List.filter Hashtbl_equiv.not_a_duplicate uris in
+  uris
+
+let equations_for_goal ~(dbd:HMysql.dbd) ((proof, goal) as _status) =
+(*   let to_string set =
+    "{ " ^
+      (String.concat ", "
+         (Constr.UriManagerSet.fold
+            (fun u l -> (UriManager.string_of_uri u)::l) set []))
+    ^ " }"
+  in *)
+ let (_, metasenv, _, _) = proof in
+ let (_, context, ty) = CicUtil.lookup_meta goal metasenv in
+ let main, sig_constants = Constr.signature_of ty in
+(*  Printf.printf "\nsig_constants: %s\n\n" (to_string sig_constants); *)
+(*  match main with *)
+(*      None -> raise Goal_is_not_an_equation *)
+(*    | Some (m,l) -> *)
+ let m, l =
+   let eq_URI =
+     let us = UriManager.string_of_uri (LibraryObjects.eq_URI ()) in
+     UriManager.uri_of_string (us ^ "#xpointer(1/1)")
+   in
+   match main with
+   | None -> eq_URI, []
+   | Some (m, l) when UriManager.eq m eq_URI -> m, l
+   | Some (m, l) -> eq_URI, []
+ in
+ Printf.printf "\nSome (m, l): %s, [%s]\n\n"
+   (UriManager.string_of_uri m)
+   (String.concat "; " (List.map UriManager.string_of_uri l));
+ (*        if m == UriManager.uri_of_string HelmLibraryObjects.Logic.eq_XURI then ( *)
+ let set = signature_of_hypothesis context in
+ (*          Printf.printf "\nsignature_of_hypothesis: %s\n\n" (to_string set); *)
+ let set = Constr.UriManagerSet.union set sig_constants in
+ let set = close_with_types set metasenv context in
+ (*          Printf.printf "\ndopo close_with_types: %s\n\n" (to_string set); *)
+ let set = close_with_constructors set metasenv context in
+ (*          Printf.printf "\ndopo close_with_constructors: %s\n\n" (to_string set); *)
+ let set = List.fold_right Constr.UriManagerSet.remove (m::l) set in
+ let uris =
+   sigmatch ~dbd ~facts:false ~where:`Statement (main,set) in
+ let uris = List.filter nonvar (List.map snd uris) in
+ let uris = List.filter Hashtbl_equiv.not_a_duplicate uris in
+ uris
+   (*        ) *)
+   (*        else raise Goal_is_not_an_equation *)
+
 let experimental_hint 
-  ~(dbd:Mysql.dbd) ?(facts=false) ?signature ((proof, goal) as status) =
+  ~(dbd:HMysql.dbd) ?(facts=false) ?signature ((proof, goal) as status) =
   let (_, metasenv, _, _) = proof in
   let (_, context, ty) = CicUtil.lookup_meta goal metasenv in
   let (uris, (main, sig_constants)) =
     match signature with
     | Some signature -> 
-	(Constr.sigmatch ~dbd ~facts signature, signature)
+	(sigmatch ~dbd ~facts signature, signature)
     | None -> 
-	(Constr.cmatch' ~dbd ~facts ty, Constr.signature_of ty)
+	(cmatch' ~dbd ~facts ty, Constr.signature_of ty)
   in 
   let uris = List.filter nonvar (List.map snd uris) in
   let uris = List.filter Hashtbl_equiv.not_a_duplicate uris in
@@ -281,7 +267,7 @@ let experimental_hint
       | Some (main,_) -> 
           let ty, _ = 
             CicTypeChecker.type_of_aux' 
-              metasenv context (CicUtil.term_of_uri (UriManager.string_of_uri main)) CicUniv.empty_ugraph
+              metasenv context (CicUtil.term_of_uri main) CicUniv.empty_ugraph
           in
           Constr.constants_of ty
     in
@@ -292,15 +278,15 @@ let experimental_hint
   let other_constants = 
     Constr.UriManagerSet.diff all_constants_closed types_constants
   in
-  debug_print "all_constants_closed";
-  Constr.UriManagerSet.iter debug_print all_constants_closed;
-  debug_print "other_constants";
-  Constr.UriManagerSet.iter debug_print other_constants;
+  debug_print (lazy "all_constants_closed");
+  if debug then Constr.UriManagerSet.iter (fun s -> debug_print (lazy (UriManager.string_of_uri s))) all_constants_closed;
+  debug_print (lazy "other_constants");
+  if debug then Constr.UriManagerSet.iter (fun s -> debug_print (lazy (UriManager.string_of_uri s))) other_constants;
   let uris = 
     let pow = 2 ** (Constr.UriManagerSet.cardinal other_constants) in
     if ((List.length uris < pow) or (pow <= 0))
     then begin
-      debug_print "MetadataQuery: large sig, falling back to old method";
+      debug_print (lazy "MetadataQuery: large sig, falling back to old method");
       filter_uris_forward ~dbd (main, other_constants) uris
     end else
       filter_uris_backward ~dbd ~facts (main, other_constants) uris
@@ -311,9 +297,9 @@ let experimental_hint
         (let status' =
             try
               let (subst,(proof, goal_list)) =
-                  (* debug_print ("STO APPLICANDO" ^ uri); *)
-                  PrimitiveTactics.apply_tac_verbose 
-		    ~term:(CicUtil.term_of_uri (UriManager.string_of_uri uri))
+                  (* debug_print (lazy ("STO APPLICANDO" ^ uri)); *)
+                  apply_tac_verbose 
+		    ~term:(CicUtil.term_of_uri uri)
                   status
               in
               let goal_list =
@@ -331,184 +317,51 @@ let experimental_hint
       Pervasives.compare (List.length goals1) (List.length goals2))
     (aux uris)
 
-let elim ~dbd uri =
-  let constraints =
-    [`Rel [`MainConclusion None];
-     `Sort (Cic.Prop,[`MainHypothesis (Some (MetadataTypes.Ge 1))]);
-     `Obj (uri,[`MainHypothesis (Some (MetadataTypes.Eq 0))]);
-     `Obj (uri,[`InHypothesis]);
-    ]
-  in
-  MetadataConstraints.at_least ~rating:`Hits ~dbd constraints
-
-
-let fill_with_dummy_constants t =
-  let rec aux i types =
-    function
-	Cic.Lambda (n,s,t) -> 
-	  let dummy_uri = 
-	    UriManager.uri_of_string ("cic:/dummy_"^(string_of_int i)) in
-	    (aux (i+1) (s::types)
-	       (CicSubstitution.subst (Cic.Const(dummy_uri,[])) t))
-      | t -> t,types
-  in 
-  let t,types = aux 0 [] t in
-  t, List.rev types
-      
-let instance ~dbd t =
-  let t',types = fill_with_dummy_constants t in 
-  let metadata = MetadataExtractor.compute ~body:None ~ty:t' in
-(*   List.iter 
-    (fun x -> 
-       debug_print 
-         (MetadataPp.pp_constr (MetadataTypes.constr_of_metadata x))) 
-    metadata; *)
-  let no_concl = MetadataDb.count_distinct `Conclusion metadata in
-  let no_hyp = MetadataDb.count_distinct `Hypothesis metadata in
-  let no_full = MetadataDb.count_distinct `Statement metadata in
-  let is_dummy = function
-    | `Obj(s, _) -> (String.sub (UriManager.string_of_uri s) 0 10) <> "cic:/dummy" 
-	  | _ -> true 
-  in
-  let rec look_for_dummy_main = function
-	  | [] -> None
-    | `Obj(s,`MainConclusion (Some (MetadataTypes.Eq d)))::_ 
-      when (String.sub (UriManager.string_of_uri s) 0 10 = "cic:/dummy") -> 
-      let s = UriManager.string_of_uri s in
-      let len = String.length s in
-            let dummy_index = int_of_string (String.sub s 11 (len-11)) in
-      let dummy_type = List.nth types dummy_index in
-      Some (d,dummy_type)
-    | _::l -> look_for_dummy_main l 
+let new_experimental_hint 
+  ~(dbd:HMysql.dbd) ?(facts=false) ?signature ~universe
+  ((proof, goal) as status)
+=
+  let (_, metasenv, _, _) = proof in
+  let (_, context, ty) = CicUtil.lookup_meta goal metasenv in
+  let (uris, (main, sig_constants)) =
+    match signature with
+    | Some signature -> 
+	(sigmatch ~dbd ~facts signature, signature)
+    | None -> 
+	(cmatch' ~dbd ~facts ty, Constr.signature_of ty) in 
+  let universe =
+   List.fold_left
+    (fun res u -> Constr.UriManagerSet.add u res)
+    Constr.UriManagerSet.empty universe in
+  let uris =
+   List.fold_left
+    (fun res (_,u) -> Constr.UriManagerSet.add u res)
+    Constr.UriManagerSet.empty uris in
+  let uris = Constr.UriManagerSet.inter uris universe in
+  let uris = Constr.UriManagerSet.elements uris in
+  let rec aux = function
+    | [] -> []
+    | uri :: tl ->
+        (let status' =
+            try
+              let (subst,(proof, goal_list)) =
+                  (* debug_print (lazy ("STO APPLICANDO" ^ uri)); *)
+                  apply_tac_verbose 
+		    ~term:(CicUtil.term_of_uri uri)
+                  status
+              in
+              let goal_list =
+                List.stable_sort (compare_goal_list proof) goal_list
+              in
+              Some (uri, (subst,(proof, goal_list)))
+            with ProofEngineTypes.Fail _ -> None
+          in
+          match status' with
+          | None -> aux tl
+          | Some status' -> status' :: aux tl)
   in
-  match (look_for_dummy_main metadata) with
-    | None->
-(*         debug_print "Caso None"; *)
-        (* no dummy in main position *)
-        let metadata = List.filter is_dummy metadata in
-        let constraints = List.map MetadataTypes.constr_of_metadata metadata in
-        let concl_card = Some (MetadataConstraints.Eq no_concl) in
-        let full_card = Some (MetadataConstraints.Eq no_full) in
-        let diff = Some (MetadataConstraints.Eq (no_hyp - no_concl)) in
-          Constr.at_least ~dbd ?concl_card ?full_card ?diff constraints
-    | Some (depth, dummy_type) ->
-(*         debug_print 
-          (sprintf "Caso Some %d %s" depth (CicPp.ppterm dummy_type)); *)
-        (* a dummy in main position *)
-        let metadata_for_dummy_type = 
-          MetadataExtractor.compute ~body:None ~ty:dummy_type in
-        (* Let us skip this for the moment 
-           let main_of_dummy_type = 
-           look_for_dummy_main metadata_for_dummy_type in *)
-        let metadata = List.filter is_dummy metadata in
-        let constraints = List.map MetadataTypes.constr_of_metadata metadata in
-        let metadata_for_dummy_type = 
-          List.filter is_dummy metadata_for_dummy_type in
-        let metadata_for_dummy_type, depth' = 
-          (* depth' = the depth of the A -> A -> Prop *)
-          List.fold_left (fun (acc,dep) c ->
-            match c with
-            | `Sort (s,`MainConclusion (Some (MetadataTypes.Eq i))) -> 
-                (`Sort (s,`MainConclusion (Some (MetadataTypes.Ge i))))::acc, i
-            | `Obj  (s,`MainConclusion (Some (MetadataTypes.Eq i))) -> 
-                (`Obj (s,`MainConclusion (Some (MetadataTypes.Ge i))))::acc, i
-            | `Rel  (`MainConclusion (Some (MetadataTypes.Eq i))) -> 
-                (`Rel (`MainConclusion (Some (MetadataTypes.Ge i))))::acc, i
-            | _ -> (c::acc,dep)) ([],0) metadata_for_dummy_type
-        in
-        let constraints_for_dummy_type =
-           List.map MetadataTypes.constr_of_metadata metadata_for_dummy_type in
-        (* start with the dummy constant in main conlusion *)
-        let from = ["refObj as table0"] in
-        let where = 
-          [sprintf "table0.h_position = \"%s\"" MetadataTypes.mainconcl_pos;
-                 sprintf "table0.h_depth >= %d" depth] in
-        let (n,from,where) =
-          List.fold_left 
-            (MetadataConstraints.add_constraint ~start:2)
-            (2,from,where) constraints in
-        let concl_card = Some (MetadataConstraints.Eq no_concl) in
-        let full_card = Some (MetadataConstraints.Eq no_full) in
-        let diff = Some (MetadataConstraints.Eq (no_hyp - no_concl)) in
-        let (n,from,where) = 
-          MetadataConstraints.add_all_constr 
-            (n,from,where) concl_card full_card diff in
-              (* join with the constraints over the type of the constant *)
-        let where = 
-          (sprintf "table0.h_occurrence = table%d.source" n)::where in
-        let where = 
-          sprintf "table0.h_depth - table%d.h_depth = %d" 
-            n (depth - depth')::where
-        in
-        let (m,from,where) =
-          List.fold_left 
-            (MetadataConstraints.add_constraint ~start:n)
-            (n,from,where) constraints_for_dummy_type in
-        Constr.exec ~dbd (m,from,where)
-
-(* fwd_simpl ****************************************************************)
-
-let rec map_filter f n = function
-   | []       -> []
-   | hd :: tl -> 
-      match f n hd with
-         | None    -> map_filter f (succ n) tl
-	 | Some hd -> hd :: map_filter f (succ n) tl
-
-let get_uri t =
-   let aux = function
-      | Cic.Appl (hd :: tl) -> Some (CicUtil.uri_of_term hd, tl)
-      | hd                  -> Some (CicUtil.uri_of_term hd, []) 
-   in
-   try aux t with
-      | Invalid_argument "uri_of_term" -> None
-
-let get_metadata t =
-   let f n t =
-      match get_uri t with
-         | None          -> None 
-	 | Some (uri, _) -> Some (n, uri)
-   in
-   match get_uri t with
-      | None             -> None
-      | Some (uri, args) -> Some (uri, map_filter f 1 args) 
-
-let debug_metadata = function
-   | None                 -> ()
-   | Some (outer, inners) -> 
-      let f (n, uri) = Printf.eprintf "%s: %i %s\n" "fwd" n uri in
-      Printf.eprintf "\n%s: %s\n" "fwd" outer;
-      List.iter f inners; prerr_newline ()
+  List.stable_sort
+    (fun (_,(_, (_, goals1))) (_,(_, (_, goals2))) ->
+      Pervasives.compare (List.length goals1) (List.length goals2))
+    (aux uris)
 
-let fwd_simpl ~dbd t =
-   let map inners row = 
-      match row.(0), row.(1), row.(2) with  
-         | Some source, Some inner, Some index -> 
-	    source, List.mem (int_of_string index, inner) inners
-	 | _                                   -> "", false
-   in
-   let rec rank ranks (source, ok) = 
-      match ranks, ok with
-         | [], false                               -> [source, 0]
-	 | [], true                                -> [source, 1]
-	 | (uri, i) :: tl, false when uri = source -> (uri, 0) :: tl
-	 | (uri, 0) :: tl, true when uri = source  -> (uri, 0) :: tl
-	 | (uri, i) :: tl, true when uri = source  -> (uri, succ i) :: tl
-	 | hd :: tl, _ -> hd :: rank tl (source, ok)
-   in
-   let compare (_, x) (_, y) = compare x y in
-   let filter n (uri, rank) =
-      if rank > 0 then Some (UriManager.uri_of_string uri) else None
-   in   
-   match get_metadata t with
-      | None                 -> []
-      | Some (outer, inners) ->
-         let select = "source, h_inner, h_index" in
-	 let from = "genLemma" in
-	 let where = Printf.sprintf "h_outer = \"%s\"" (Mysql.escape outer) in
-         let query = Printf.sprintf "SELECT %s FROM %s WHERE %s" select from where in
-	 let result = Mysql.exec dbd query in
-         let lemmas = Mysql.map result ~f:(map inners) in
-	 let ranked = List.fold_left rank [] lemmas in
-	 let ordered = List.rev (List.fast_sort compare ranked) in
-	 map_filter filter 0 ordered