DP locations defined by abstract values and not by formula.

2 files changed, 107 insertions, 92 deletions

diff --git a/abstract/abs_interp_dynpart.ml b/abstract/abs_interp_dynpart.ml
index 1adc430..32ed890 100644
--- a/abstract/abs_interp_dynpart.ml
+++ b/abstract/abs_interp_dynpart.ml
@@ -21,9 +21,9 @@ end = struct
 
     type location = {
         id              : int;
+        depth           : int;
 
-        mutable def     : bool_expr list;   (* conjunction of formula *)
-        mutable def_cl  : conslist;
+        mutable def     : abs_v;
         is_init         : bool;
 
         mutable f       : bool_expr;
@@ -108,22 +108,45 @@ end = struct
       apply_cl : abs_v -> conslist -> abs_v
     *)
     let rec apply_cl (enum, num) (ec, nc, r) =
-        try
-          begin match r with
-          | CLTrue ->
-            (ED.apply_cl enum ec, ND.apply_cl num nc)
-          | CLFalse ->
-            (ED.vtop enum, ND.vbottom num)
-          | CLAnd(a, b) ->
-            let enum, num = apply_cl (enum, num) (ec, nc, a) in
-            let enum, num = apply_cl (enum, num) ([], nc, b) in
-            enum, num
-          | CLOr((eca, nca, ra), (ecb, ncb, rb)) ->
-            let a = apply_cl (enum, num) (ec@eca, nc@nca, ra) in 
-            let b = apply_cl (enum, num) (ec@ecb, nc@ncb, rb) in 
-            join a b
+        begin match r with
+        | CLTrue ->
+          begin
+            try (ED.apply_cl enum ec, ND.apply_cl num nc)
+            with Bot -> ED.vtop enum, ND.vbottom num
           end
-        with Bot -> ED.vtop enum, ND.vbottom num
+        | CLFalse ->
+          (ED.vtop enum, ND.vbottom num)
+        | CLAnd(a, b) ->
+          let enum, num = apply_cl (enum, num) (ec, nc, a) in
+          let enum, num = apply_cl (enum, num) ([], nc, b) in
+          enum, num
+        | CLOr((eca, nca, ra), (ecb, ncb, rb)) ->
+          let a = apply_cl (enum, num) (ec@eca, nc@nca, ra) in 
+          let b = apply_cl (enum, num) (ec@ecb, nc@ncb, rb) in 
+          join a b
+        end
+
+    (*
+      apply_cl_all_cases : abs_v -> conslist -> abs_v list
+    *)
+    let rec apply_cl_all_cases v (ec, nc, r) =
+        match r with
+        | CLTrue ->
+          let v =
+            try ED.apply_cl (fst v) ec, ND.apply_cl (snd v) nc
+            with Bot -> ED.vtop (fst v), ND.vbottom (snd v)
+          in
+          if is_bot v then [] else [v]
+        | CLFalse ->
+          []
+        | CLAnd(a, b) ->
+          let q1 = apply_cl_all_cases v (ec, nc, a) in
+          List.flatten
+            (List.map (fun c -> apply_cl_all_cases c ([], [], b)) q1)
+        | CLOr((eca, nca, ra), (ecb, ncb, rb)) ->
+          let la = apply_cl_all_cases v (ec@eca, nc@nca, ra) in 
+          let lb = apply_cl_all_cases v (ec@ecb, nc@ncb, rb) in 
+          lb@(List.filter (fun a -> not (List.exists (fun b -> eq_v a b) lb)) la)
 
 
     (* ***************************
@@ -190,17 +213,17 @@ end = struct
           loc = Hashtbl.create 2; counter = ref 2; } in
 
         (* add initial disjunction : L/must_reset = tt, L/must_reset ≠ tt *)
-        let rstc = [BEnumCons(E_EQ, "L/must_reset", EItem bool_true)] in
-        let rstf = simplify_k rstc f in
+        let rstc = BEnumCons(E_EQ, "L/must_reset", EItem bool_true) in
+        let rstf = simplify_k [rstc] f in
         let rstf = simplify_k (get_root_true rstf) rstf in
-        let nrstc = [BEnumCons(E_NE, "L/must_reset", EItem bool_true)] in
-        let nrstf = simplify_k nrstc f in
+        let nrstc = BEnumCons(E_NE, "L/must_reset", EItem bool_true) in
+        let nrstf = simplify_k [nrstc] f in
         let nrstf = simplify_k (get_root_true nrstf) nrstf in
         Hashtbl.add env.loc 0
           {
             id = 0;
-            def = rstc;
-            def_cl = conslist_of_f (f_and_list rstc);
+            depth = 0;
+            def = apply_cl (top env) (conslist_of_f rstc);
             is_init = true;
 
             f = rstf;
@@ -215,8 +238,8 @@ end = struct
         Hashtbl.add env.loc 1
           {
             id = 1;
-            def = nrstc;
-            def_cl = conslist_of_f (f_and_list nrstc);
+            depth = 0;
+            def = apply_cl (top env) (conslist_of_f nrstc);
             is_init = false;
 
             f = nrstf;
@@ -282,23 +305,24 @@ end = struct
 
         (ED.forgetvars enum ef, List.fold_left ND.forgetvar num nf)
 
-    let set_target_case e v cl =
-        let tgt = (unpass_cycle e (apply_cl (top e) cl)) in
-        (*Format.printf "Target %a = %a@." Formula_printer.print_conslist cl print_v tgt;*)
-        meet v tgt
-
     (*
       print_locs : env -> unit
     *)
 
+    let print_locs_defs e =
+        Hashtbl.iter
+          (fun id loc ->
+            Format.printf "q%d: @[<v 2>%a@]@." id print_v loc.def;
+            )
+          e.loc
+
     let print_locs e =
         Hashtbl.iter
           (fun id loc ->
             Format.printf "@.";
-            Format.printf "q%d: @[<v 2>[ %a ]@]@." id
-              (print_list Formula_printer.print_expr " ∧ ") loc.def;
+            Format.printf "q%d (depth = %d):@.  D: @[<v 2>%a@]@." id loc.depth print_v loc.def;
             (*Format.printf "  F: (%a)@." Formula_printer.print_expr loc.f;*)
-            Format.printf "    %a@." print_v loc.v;
+            Format.printf "  V: %a@." print_v loc.v;
             Format.printf " -> @[<hov>[%a]@]@."
               (print_list (fun fmt i -> Format.fprintf fmt "q%d" i) ", ") loc.out_t;
             )
@@ -325,7 +349,7 @@ end = struct
               loc.v <- bottom e)
           e.loc;
 
-        print_locs e;
+        print_locs_defs e;
 
         (* Iterate *)
         let it_counter = ref 0 in
@@ -339,11 +363,11 @@ end = struct
           let start = loc.v in
           let f i =
             (*Format.printf "I: %a@." print_v i;*)
-            let i' = set_target_case e i loc.def_cl in
+            let i' = meet i (unpass_cycle e loc.def) in
             (*Format.printf "I': %a@." print_v i';*)
             let j = join start
               (apply_cl
-                (apply_cl (pass_cycle e.ve i') loc.def_cl)
+                (meet (pass_cycle e.ve i') loc.def)
                 loc.cl) in
             (*Format.printf "J: %a@." print_v j;*)
             j
@@ -372,7 +396,7 @@ end = struct
 
           Hashtbl.iter
             (fun t loc2 ->
-                let v = apply_cl u loc2.def_cl in
+                let v = meet u loc2.def in
                 let w = apply_cl v loc2.cl in
                 (*Format.printf "u: %a@.v: %a@. w: %a@." print_v u print_v v print_v w;*)
                 if not (is_bot w) then begin
@@ -384,9 +408,9 @@ end = struct
                     then loc.out_t <- t::loc.out_t;
                   if not (subset_v w loc2.v) then begin
                     if loc2.in_c < e.opt.widen_delay then
-                      loc2.v <- join w loc2.v
+                      loc2.v <- join loc2.v w
                     else
-                      loc2.v <- widen w loc2.v;
+                      loc2.v <- widen loc2.v w;
                     loc2.in_c <- loc2.in_c + 1;
                     if not (List.mem t !delta)
                       then delta := t::!delta
@@ -438,10 +462,7 @@ end = struct
                     then BNot cond
                     else cond
                   in
-                  if not (List.mem tr loc.def) then begin
-                    loc.def <- tr::loc.def;
-                    loc.def_cl <- conslist_of_f (f_and_list loc.def);
-                  end;
+                  loc.def <- apply_cl loc.def (conslist_of_f tr);
                   loc.f <- simplify_k [tr] loc.f;
                   loc.f <- simplify_k (get_root_true loc.f) loc.f;
                   loc.cl <- conslist_of_f loc.f;
@@ -453,31 +474,17 @@ end = struct
           (* find splitting condition *)
           Hashtbl.iter
             (fun q (loc:location) ->
-              if !qc = None then
+              if !qc = None && loc.depth < e.opt.max_dp_depth then
               let cs = ternary_conds loc.f in
               List.iter
                 (fun c ->
-                  let split_e_case_fold_aux cases c =
-                        match c with
-                        | BEnumCons(op, x, EItem _) ->
-                          let op = match op with | E_EQ -> (=) | E_NE -> (<>) in
-                          (List.map (fun v -> BEnumCons(E_EQ, x, EItem v))
-                            (List.filter (op x) (List.assoc x e.ve.evars)))
-                          @cases
-                        | _ -> c::cases
-                  in
-                  let cases_t =
-                    List.fold_left split_e_case_fold_aux []
-                     [c] in
-                  let cases_f =
-                    List.fold_left split_e_case_fold_aux []
-                     [eliminate_not_negate c] in
+                  let cases_t = apply_cl_all_cases (top e) (conslist_of_f c) in
+                  let cases_f = apply_cl_all_cases (top e) (conslist_of_f (BNot c)) in
                   let cases = cases_t @ cases_f in
                   if
                     List.length 
                       (List.filter
-                        (fun case ->
-                          not (is_bot (apply_cl loc.v (conslist_of_f case))))
+                        (fun case -> not (is_bot (meet loc.v case)))
                         cases)
                       >= 2
                   &&
@@ -485,20 +492,20 @@ end = struct
                         (fun qi ->
                           let loci = Hashtbl.find e.loc qi in
                           let v = apply_cl
-                            (apply_cl (pass_cycle e.ve loci.v) loc.def_cl)
+                            (meet (pass_cycle e.ve loci.v) loc.def)
                             loc.cl in
                           List.exists
-                            (fun case -> is_bot (apply_cl v (conslist_of_f case)))
+                            (fun case -> is_bot (meet v case))
                             cases)
                         loc.in_t
                     || List.exists
                         (fun case ->
-                          let v = apply_cl loc.v (conslist_of_f case) in
+                          let v = meet loc.v case in
                           List.exists
                             (fun qo ->
                               let loco = Hashtbl.find e.loc qo in
                               let w = apply_cl
-                                (apply_cl (pass_cycle e.ve v) loco.def_cl)
+                                (meet (pass_cycle e.ve v) loco.def)
                                 loco.cl in
                               is_bot w)
                             loc.out_t)
@@ -510,27 +517,27 @@ end = struct
             )
             e.loc;
 
-          (*if n < 7 then*)
+          if Hashtbl.length e.loc < e.opt.max_dp_width then
             match !qc with
             | None ->
-              Format.printf "@.Found no more possible refinement."
+              Format.printf "@.Found no more possible refinement.@.@."
             | Some (q, c, cases_t, cases_f) ->
               Format.printf "@.Refine q%d : @[<v 2>[ %a ]@]@." q
-                (print_list Formula_printer.print_expr ", ") (cases_t@cases_f);
+                (print_list print_v ", ") (cases_t@cases_f);
 
               let loc = Hashtbl.find e.loc q in
               Hashtbl.remove e.loc loc.id;
 
               let handle_case cc case =
-                  if not (is_bot (apply_cl loc.v (conslist_of_f case))) then
+                  if not (is_bot (meet loc.v case)) then
                     let ff = simplify_k [cc] loc.f in
                     let ff = simplify_k (get_root_true ff) ff in
                   
                     let loc2 =
                       { loc with
                         id = (incr e.counter; !(e.counter));
-                        def = case::loc.def;
-                        def_cl = conslist_of_f (f_and_list (case::loc.def));
+                        depth = loc.depth + 1;
+                        def = meet loc.def case;
                         f = ff;
                         cl = conslist_of_f ff } in
                     Hashtbl.add e.loc loc2.id loc2
@@ -539,6 +546,34 @@ end = struct
                 List.iter (handle_case (BNot c)) cases_f;
                           
               iter (n+1)
-        in iter 0
+        in iter 0;
+
+        (* Check guarantees *)
+        let check_guarantee (id, f) =
+          Format.printf "@[<v 4>";
+          let cl = Formula.conslist_of_f f in
+          Format.printf "%s:@ %a ⇒ ⊥  @ "
+            id Formula_printer.print_conslist cl;
+          let violate = ref [] in
+          Hashtbl.iter
+            (fun id loc ->
+              if not (is_bot (apply_cl loc.v cl)) then
+                violate := id::!violate)
+            e.loc;
+          if !violate = [] then
+            Format.printf "OK"
+          else
+            Format.printf "VIOLATED in @[<hov 2>[ %a ]@]"
+              (print_list (fun fmt i -> Format.fprintf fmt "q%d" i) ", ") !violate;
+          Format.printf "@]@ ";
+        in
+        if e.guarantees <> [] then begin
+          Format.printf "Guarantee @[<v 0>";
+          List.iter check_guarantee e.guarantees;
+          Format.printf "@]@."
+        end
+
+
+
 
 end
diff --git a/abstract/formula.ml b/abstract/formula.ml
index a124a84..f2a3bd1 100644
--- a/abstract/formula.ml
+++ b/abstract/formula.ml
@@ -263,23 +263,3 @@ let rec formula_replace_evars repls e =
   | x -> x
 
 
-
-(*
-  Extract all cases that make a formula true, to a limited degree
-
-  [A || B; not (A || B)] -> A; (B && (not A)); not A && not B]
-*)
-
-let rec split_cases c =
-  let c = List.map eliminate_not c in
-  let u, l = List.fold_left
-    (fun (u, l) c ->
-      match c with
-      | BOr(a, b) ->
-        true, a::(BAnd(BNot a, b))::l
-      | BTernary(c, a, b) ->
-        true, (BAnd(c, a))::(BAnd(BNot c, b))::l
-      | x -> u, x::l)
-    (false, []) c
-  in
-    if u then split_cases l else l