try
f p i
with Backtrack s ->
-prerr_endline ("!!BACKTRACK!! " ^ s);
+prerr_endline (">>>>>> BACKTRACK (reason: " ^ s ^") measure=$ ");
List.iter (fun (r,l) -> r := l) (List.combine p.deltas (List.hd p.trail)) ;
prerr_endline("Now trying var="^string_of_var var^" i="^string_of_int i);
aux (i+1)
let simple_expand_match ps =
let rec aux_nob level = function
- | #i_num_var as t -> aux_i_num_var level t
+ | #i_num_var as t -> (aux_i_num_var level t :> nf)
| `Lam(b,t) -> `Lam(b,aux (level+1) t)
| `Pacman as t -> t
and aux level = function
| #nf_nob as t -> aux_nob level t
and aux_i_num_var level = function
| `Match(u,v,bs_lift,bs,args) as torig ->
- let u = aux_i_num_var level u in
+ let (u : i_num_var) = aux_i_num_var level u in
bs := List.map (fun (n, x) -> n, aux 0 x) !bs;
(try
(match u with
| #i_n_var as u ->
- let i = index_of (lift (-level) u) (ps :> nf list) (* can raise Not_found *)
- in let t = mk_match (`N i) v bs_lift bs (args :> nf list) in
+ let i = index_of ~eq:eta_eq (lift (-level) u) (ps :> nf list) in (* can raise Not_found *)
+ let t = cast_to_i_num_var (mk_match (`N i) v bs_lift bs (args :> nf list)) in
if t <> torig then
- aux level (t :> nf)
- else raise Not_found
+ aux_i_num_var level t
+ else raise Not_found
| _ -> raise Not_found)
with Not_found ->
- mk_appl (`Match(cast_to_i_num_var u,v,bs_lift,bs,[])) (List.map (aux_nob level) args))
- | `I(v,args) -> mk_appl (`Var v) (List.map (aux_nob level) (Listx.to_list args))
+ cast_to_i_num_var (mk_appl (`Match(u,v,bs_lift,bs,[])) (List.map (aux_nob level) args)))
+ | `I(v,args) -> cast_to_i_num_var (mk_appl (`Var v) (List.map (aux_nob level) (Listx.to_list args)))
| `N _ | `Var _ as t -> t
in aux_i_num_var 0
;;
;;
let rec super_simplify_ps ps =
+ fixpoint (List.map (fun x -> cast_to_i_n_var (simple_expand_match ps (x :> i_num_var))))
+;;
+
+let rec super_simplify_ps_with_match ps =
fixpoint (List.map (cast_to_i_num_var ++ (simple_expand_match ps)))
;;
let super_simplify ({div; ps; conv} as p) =
- let ps = super_simplify_ps p.ps (p.ps :> i_num_var list) in
- let conv = super_simplify_ps ps (p.conv :> i_num_var list) in
+ let ps = super_simplify_ps p.ps p.ps in
+ let conv = super_simplify_ps ps p.conv in
let div = option_map (fun div ->
- let divs = super_simplify_ps p.ps ([div] :> i_num_var list) in
+ let divs = super_simplify_ps p.ps ([div] :> i_n_var list) in
List.hd divs) div in
- {p with div=option_map cast_to_i_var div; ps=List.map cast_to_i_n_var ps; conv=List.map cast_to_i_n_var conv}
+ {p with div=option_map cast_to_i_var div; ps; conv}
-let cast_to_ps =
+let cast_to_ps_with_match =
function
#i_num_var as y -> (y : i_num_var)
- | `Bottom | `Pacman -> raise (Backtrack "foo")
+ | `Bottom | `Pacman -> raise (Backtrack "BOT/PAC in ps")
| t ->
prerr_endline (print (t :> nf));
assert false (* algorithm failed *)
function
| None -> freshno, None, acc_new_ps
| Some t ->
+ let t = subst false false x inst (t :> nf) in
try
- let t = subst false false x inst (t :> nf) in
let freshno,new_t,acc_new_ps = expand_match (freshno,ps,acc_new_ps) t in
- freshno,Some(cast_to_i_var new_t),acc_new_ps
- with Bottom -> freshno, None, acc_new_ps
- | Pacman -> raise (Backtrack "Pacman in div")
+ (* backtrack if it is a number or a variable *)
+ match new_t with
+ | `N _ -> raise (Backtrack "div=`N")
+ | `Var _
+ | `I _ as new_t -> freshno, Some(new_t), acc_new_ps
+ with
+ | Bottom -> freshno, None, acc_new_ps
+ | Pacman -> raise (Backtrack "div=PAC")
and expand_match ((freshno,acc_ps,acc_new_ps) as acc) t =
match t with
match u with
| `N i -> acc_new_ps,i
| _ ->
- let ps = List.map (fun t -> cast_to_ps (subst false false x inst (t:> nf))) (acc_ps@acc_new_ps) in
- let super_simplified_ps = super_simplify_ps ps ps in
+ let ps = List.map (fun t -> cast_to_ps_with_match (subst false false x inst (t:> nf))) (acc_ps@acc_new_ps) in
+ let super_simplified_ps = super_simplify_ps_with_match ps ps in
(*prerr_endline ("CERCO u:" ^ print (fst u :> nf));
List.iter (fun x -> prerr_endline ("IN: " ^ print (fst x :> nf))) ps;
List.iter (fun x -> prerr_endline ("IN2: " ^ print (fst x :> nf))) super_simplified_ps;*)
- match index_of_opt ~eq:eta_eq super_simplified_ps u with
+ match index_of_opt ~eq:eta_eq super_simplified_ps (u :> i_num_var) with
Some i -> acc_new_ps, i
| None -> acc_new_ps@[u], len_ps + List.length acc_new_ps
in
| `Pacman -> raise Pacman
| #i_n_var as x ->
let x = simple_expand_match (acc_ps@acc_new_ps) x in
- freshno,cast_to_i_num_var x,acc_new_ps in
+ freshno,cast_to_i_n_var x,acc_new_ps in
- let freshno,old_ps,new_ps = aux_ps (freshno,[],[]) (ps :> i_num_var list) in
- let freshno,conv,new_ps = aux_conv old_ps (freshno,[],new_ps) (conv :> i_num_var list) in
+ let freshno,old_ps,new_ps = aux_ps (freshno,[],[]) ps in
+ let freshno,conv,new_ps = aux_conv old_ps (freshno,[],new_ps) conv in
let freshno,div,new_ps = aux_div old_ps (freshno,new_ps) (div :> i_num_var option) in
let ps = List.map cast_to_i_n_var (old_ps @ new_ps) in
else
`Continue p
+
+let safe_arity_of_var p x =
+ (* Compute the minimum number of arguments when x is in head
+ position at p.div or p.ps *)
+ let aux = function
+ | `Var(y,_) -> if x = y then 0 else max_int
+ | `I((y,_),args) -> if x = y then Listx.length args else max_int
+ | _ -> max_int in
+ let tms = ((match p.div with None -> [] | Some t -> [(t :> i_n_var)]) @ p.ps) in
+ List.fold_left (fun acc t -> Pervasives.min acc (aux t)) max_int tms
+;;
+
let instantiate p x perm n =
- let arity_of_x = max_arity_tms x (all_terms p) in
- (if arity_of_x = None then failwithProblem p "step on var non occurring in problem");
- let arity_of_x = Util.option_get(arity_of_x) in
- (if arity_of_x = min_int then failwithProblem p "step on fake variable");
- (if arity_of_x <= 0 then failwithProblem p "step on var of non-positive arity");
- (if perm < 1 || perm > arity_of_x then
- failwithProblem p ("Tried to permutate variable "^ string_of_var x ^" beyond its max arity"));
let n = (prerr_endline "WARNING: using constant initialSpecialK"); p.initialSpecialK in
let arities = Array.to_list (Array.make (n+1) min_int) in
let p,vars = make_fresh_vars p arities in
prerr_endline ("INSTANTIATING AND HOPING " ^ string_of_var x);
x
with
- Not_found -> x in
+ Not_found ->
+ let arity_of_x = max_arity_tms x (all_terms p) in
+ assert (Util.option_get arity_of_x > 0);
+ x in
(* Instantiate in decreasing order of compute_special_k
1:15m14s 2:13m14s 3:4m55s 4:4m43s 5:4m34s 6:6m28s 7:3m31s
let x =
if special_k < n then
prerr_endline ("@@@@ NEW INSTANTIATE PHASE (" ^ string_of_int special_k ^ ") @@@@");
let arity_of_x = Util.option_get (max_arity_tms x (all_terms p)) in
- x,arity_of_x,special_k
+ let safe_arity_of_x = safe_arity_of_var p x in
+ x, min arity_of_x safe_arity_of_x, special_k
let rec auto_eat (n,p) =
prerr_endline "{{{{{{{{ Computing measure before auto_instantiate }}}}}}";