open Pure
open Num
-let bomb = ref(`Var(-1,-666));;
+let divergent = ref(`Var(-1, -666));;
(*
The number of arguments which can applied to numbers
For Scott's encoding, two.
*)
let num_more_args = 2;;
+(* verbosity *)
let _very_verbose = false;;
+(** Display measure of every term when printing problem *)
+let _measure_of_terms = false;;
let verbose s =
if _very_verbose then prerr_endline s
let string_of_var l x =
try
List.nth l x
- with Failure "nth" -> "`" ^ string_of_int x
+ with Failure _ -> "`" ^ string_of_int x
;;
let string_of_term p t = print ~l:p.var_names (t :> nf);;
@ p.ps
;;
-let sum_arities p =
+let measure_of_term, measure_of_terms =
let rec aux = function
| `N _ -> 0
| `Var(_,ar) -> if ar = min_int then 0 else max 0 ar (*assert (ar >= 0); ar*)
| `Lam(_,t) -> aux t
- | `I(v,args) -> aux (`Var v) + aux_many (Listx.to_list args)
- | `Match(u,(_,ar),_,_,args) -> aux (u :> nf) + (if ar = min_int then 0 else ar - 1) + aux_many args
+ | `I(v,args) -> aux (`Var v) + aux_many (Listx.to_list args :> nf list)
+ | `Match(u,(_,ar),_,_,args) -> aux (u :> nf) + (if ar <= 0 then 0 else ar - 1) + aux_many args
and aux_many tms = List.fold_right ((+) ++ aux) tms 0 in
- aux_many (all_terms p :> nf list)
- ;;
+ (fun t -> aux (t :> nf)), (fun l -> aux_many (l :> nf list))
+;;
+
+let sum_arities p = measure_of_terms (all_terms p)
let count_fakevars p =
let rec aux = function
let string_of_measure = string_of_int;;
let string_of_problem label ({freshno; div; conv; ps; deltas} as p) =
+ let aux_measure_terms t = if _measure_of_terms then "(" ^ string_of_int (measure_of_term t) ^ ") " else "" in
let deltas = String.concat ("\n# ") (List.map (fun r -> String.concat " <> " (List.map (fun (i,_) -> string_of_int i) !r)) deltas) in
let l = p.var_names in
String.concat "\n" ([
) else "# ";
"#";
"$" ^ p.label;
- (match div with None -> "# no D" | Some div -> "D " ^ print ~l (div :> nf));
+ (match div with None -> "# D" | Some div -> "D " ^ aux_measure_terms div ^ print ~l (div :> nf));
]
- @ List.map (fun t -> "C " ^ (if t = convergent_dummy then "#C" else "C " ^ print ~l (t :> nf))) conv
- @ List.mapi (fun i t -> string_of_int i ^ " " ^ print ~l (t :> nf)) ps
+ @ List.map (fun t -> if t = convergent_dummy then "# C" else "C " ^ aux_measure_terms t ^ print ~l (t :> nf)) conv
+ @ List.mapi (fun i t -> string_of_int i ^ " " ^ aux_measure_terms t ^ print ~l (t :> nf)) ps
@ [""])
;;
exception Dangerous
-let arity_of arities k =
- let _,pos,y = List.find (fun (v,_,_) -> v=k) arities in
- let arity = match y with `Var _ -> 0 | `I(_,args) -> Listx.length args | `N _ -> assert false in
- arity + if pos = -1 then - 1 else 0
+let arity_of arities hd =
+ let pos,_,nargs = List.find (fun (_,hd',_) -> hd=hd') arities in
+ nargs + if pos = -1 then - 1 else 0
;;
let rec dangerous arities showstoppers =
;;
let precompute_edible_data {ps; div} xs =
- (match div with None -> [] | Some div -> [hd_of_i_var div, -1, (div :> i_n_var)]) @
- List.map (fun hd ->
+ let aux t = match t with `Var _ -> 0 | `I(_, args) -> Listx.length args | `N _ -> assert false in
+ (fun l -> match div with
+ | None -> l
+ | Some div -> (-1, hd_of_i_var div, aux div) :: l)
+ (List.map (fun hd ->
let i, tm = Util.findi (fun y -> hd_of y = Some hd) ps in
- hd, i, tm
- ) xs
+ i, hd, aux tm
+ ) xs)
;;
+(** Returns (p, showstoppers_step, showstoppers_eat) where:
+ - showstoppers_step are the heads occurring twice
+ in the same discriminating set
+ - showstoppers_eat are the heads in ps having different number
+ of arguments *)
let critical_showstoppers p =
let p = super_simplify p in
let hd_of_div = match p.div with None -> [] | Some t -> [hd_of_i_var t] in
let showstoppers = showstoppers_step @ showstoppers_eat in
let heads = List.sort compare (filter_map hd_of ps) in
let arities = precompute_edible_data p (uniq heads) in
- let showstoppers, showstoppers_conv =
- edible p arities showstoppers in
- let l = List.filter (fun (x,_,_) -> not (List.mem x showstoppers)) arities in
+ let inedible, showstoppers_conv = edible p arities showstoppers in
+ let l = List.filter (fun (_,hd,_) -> not (List.mem hd inedible)) arities in
let p =
- List.fold_left (fun p (x,pos,(xx : i_n_var)) -> if pos = -1 then p else
- let n = match xx with `I(_,args) -> Listx.length args | _ -> 0 in
- let v = `N(pos) in
- let inst = make_lams v n in
-prerr_endline ("# INST_IN_EAT: " ^ string_of_var p.var_names x ^ " := " ^ string_of_term p inst);
- { p with sigma = p.sigma @ [x,inst] }
+ List.fold_left (fun p (pos,hd,nargs) -> if pos = -1 then p else
+ let v = `N pos in
+ let inst = make_lams v nargs in
+prerr_endline ("# INST_IN_EAT: " ^ string_of_var p.var_names hd ^ " := " ^ string_of_term p inst);
+ { p with sigma = p.sigma @ [hd,inst] }
) p l in
(* to avoid applied numbers in safe positions that
trigger assert failures subst_in_problem x inst p*)
let ps =
List.map (fun t ->
try
- let _,j,_ = List.find (fun (h,_,_) -> hd_of t = Some h) l in
+ let j,_,_ = List.find (fun (_,hd,_) -> hd_of t = Some hd) l in
`N j
with Not_found -> t
) ps in
let p = match p.div with
| None -> p
| Some div ->
- if List.mem (hd_of_i_var div) showstoppers
+ if List.mem (hd_of_i_var div) inedible
then p
- else
- let n = match div with `I(_,args) -> Listx.length args | `Var _ -> 0 in
- let p, bomb' = make_fresh_var p (-666) in
- (if !bomb <> `Var (-1,-666) then
- failwithProblem p
- ("Bomb was duplicated! It was " ^ string_of_nf !bomb ^
- ", tried to change it to " ^ string_of_nf bomb'));
- bomb := bomb';
- prerr_endline ("Just created bomb var: " ^ string_of_nf !bomb);
- let x = hd_of_i_var div in
- let inst = make_lams !bomb n in
- let p = {p with div=None} in
- (* subst_in_problem (hd_of_i_var div) inst p in *)
- {p with sigma=p.sigma@[x,inst]} in
- let dangerous_conv = showstoppers_conv in
-let _ = prerr_endline ("dangerous_conv lenght:" ^ string_of_int (List.length dangerous_conv));
-List.iter (fun l -> prerr_endline (String.concat " " (List.map (string_of_var p.var_names) l))) dangerous_conv; in
+ else (divergent := `Var(hd_of_i_var div, -666); {p with div=None}) in
+ let dangerous_conv = showstoppers_conv in
+prerr_endline ("dangerous_conv lenght:" ^ string_of_int (List.length dangerous_conv));
+List.iter (fun l -> prerr_endline (String.concat " " (List.map (string_of_var p.var_names) l))) dangerous_conv;
let conv =
List.map (function s,t ->
try
if s <> [] then t else (
(match t with | `Var _ -> raise Not_found | _ -> ());
- let _ = List.find (fun h -> hd_of t = Some h) showstoppers in
+ let _ = List.find (fun h -> hd_of t = Some h) inedible in
t)
with Not_found -> match hd_of t with
| None -> assert (t = convergent_dummy); t
`Continue p
let instantiate p x n =
- (if hd_of_i_var (cast_to_i_var !bomb) = x
- then failwithProblem p ("BOMB (" ^ string_of_nf !bomb ^ ") cannot be instantiated!"));
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");
(if Util.option_get(arity_of_x) = min_int then failwithProblem p "step on fake variable");
List.fold_left max 0 (List.map (aux 0) ((t :> nf)::args@List.map snd !bs))
| `N _
| `Var _ -> 0
- ) in Listx.max (Listx.map (aux 0) tms)
+ ) in
+ let rec aux' top t = match t with
+ | `Lam(_,t) -> aux' false t
+ | `I((_,ar), tms) -> max ar
+ (Listx.max (Listx.map (aux' false) (tms :> nf Listx.listx)))
+ | `Match(t, _, liftno, bs, args) ->
+ List.fold_left max 0 (List.map (aux' false) ((t :> nf)::(args :> nf list)@List.map snd !bs))
+ | `N _
+ | `Var _ -> 0 in
+ Listx.max (Listx.map (aux 0) tms) + Listx.max (Listx.map (aux' true) tms)
;;
let auto_instantiate (n,p) =
| x::_, _ ->
prerr_endline ("INSTANTIATING " ^ string_of_var p.var_names x);
x in
-(* Strategy that decreases the special_k to 0 first (round robin)
-1:11m42 2:14m5 3:11m16s 4:14m46s 5:12m7s 6:6m31s *)
- let x =
- try
- match
- hd_of (List.find (fun t ->
- compute_special_k (Listx.Nil (t :> nf)) > 0 && arity_of_hd t > 0
- ) (all_terms p))
- with
- | None -> assert false
- | Some x ->
- prerr_endline ("INSTANTIATING AND HOPING " ^ string_of_var p.var_names x);
- x
- with
- 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 =
- try
- (match hd_of (snd (List.hd (List.sort (fun c1 c2 -> - compare (fst c1) (fst c2)) (filter_map (function `I _ as t -> Some (compute_special_k (Listx.Nil (t :> nf)),t) | _ -> None) (all_terms p))))) with
- None -> assert false
- | Some x ->
- prerr_endline ("INSTANTIATING AND HOPING " ^ string_of_var x);
- x)
- with
- Not_found -> x
-in*)
let special_k =
compute_special_k (Listx.from_list (all_terms p :> nf list) )in
if special_k < n then
replace_in_sigma (List.rev perm) p.sigma
;;
-let env_of_sigma freshno sigma should_explode =
- let rec aux n =
- if n > freshno then
- []
- else
- let e = aux (n+1) in
- (try
- e,Pure.lift (-n-1) (snd (List.find (fun (i,_) -> i = n) sigma)),[]
- with
- Not_found ->
- if should_explode && n = hd_of_i_var (cast_to_i_var !bomb)
- then ([], (let f t = Pure.A(t,t) in f (Pure.L (f (Pure.V 0)))), [])
- else ([],Pure.V n,[]))::e
- in aux 0
-;;
(* ************************************************************************** *)
type result = [
match check p with
| Some s -> `Unseparable s
| None ->
- bomb := `Var(-1,-666);
Console.print_hline();
let p_finale = auto p p.initialSpecialK in
let freshno,sigma = p_finale.freshno, p_finale.sigma in
(string_of_var p_finale.var_names x ^ " := " ^ string_of_term p_finale inst)) sigma;
prerr_endline "---------<PURE>---------";
+ ToScott.bomb := !divergent;
let scott_of_nf t = ToScott.t_of_nf (t :> nf) in
let div = option_map scott_of_nf p.div in
let conv = List.map scott_of_nf p.conv in
let ps = List.map scott_of_nf p.ps in
let sigma' = List.map (fun (x,inst) -> x, scott_of_nf inst) sigma in
- let e' = env_of_sigma freshno sigma' false (* FIXME shoudl_explode *) in
+ let e' = Pure.env_of_sigma freshno sigma' in
prerr_endline "--------<REDUCE>---------";
- let pure_bomb = ToScott.t_of_nf (!bomb) in (* Pure.B *)
(function
| Some div ->
print_endline (Pure.print div);
let t = Pure.mwhd (e',div,[]) in
prerr_endline ("*:: " ^ (Pure.print t));
- assert (t = pure_bomb)
+ assert (Pure.diverged t)
| None -> ()) div;
List.iter (fun n ->
verbose ("_::: " ^ (Pure.print n));
let t = Pure.mwhd (e',n,[]) in
verbose ("_:: " ^ (Pure.print t));
- assert (t <> pure_bomb)
+ assert (not (Pure.diverged t))
) conv ;
List.iteri (fun i n ->
verbose ((string_of_int i) ^ "::: " ^ (Pure.print n));
[ ref (Array.to_list (Array.init (List.length ps) (fun i -> i, dummy))) ] in
{freshno; div; conv; ps; sigma=[]; deltas; initialSpecialK; var_names; label}
;;
+
+(* assert_depends solves the problem, and checks if the result was expected *)
+let assert_depends x =
+ let c = String.sub (label_of_problem x) 0 1 in
+ match solve x with
+ | `Unseparable s when c = "!" ->
+ failwith ("assert_depends: unseparable because: " ^ s ^ ".")
+ | `Separable _ when c = "?" ->
+ failwith ("assert_depends: separable.")
+ | _ -> () in
+Problems.main (assert_depends ++ problem_of);
projects / fireball-separation.git / blobdiff