diff --git a/src_colibri2/core/choice_group.ml b/src_colibri2/core/choice_group.ml
new file mode 100644
index 0000000000000000000000000000000000000000..77a101da112be0d1c5a7c93d8bdcab9fd951867a
--- /dev/null
+++ b/src_colibri2/core/choice_group.ml
@@ -0,0 +1,99 @@
+(*************************************************************************)
+(* This file is part of Colibri2. *)
+(* *)
+(* Copyright (C) 2014-2021 *)
+(* CEA (Commissariat à l'énergie atomique et aux énergies *)
+(* alternatives) *)
+(* *)
+(* you can redistribute it and/or modify it under the terms of the GNU *)
+(* Lesser General Public License as published by the Free Software *)
+(* Foundation, version 2.1. *)
+(* *)
+(* It 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 Lesser General Public License for more details. *)
+(* *)
+(* See the GNU Lesser General Public License version 2.1 *)
+(* for more details (enclosed in the file licenses/LGPLv2.1). *)
+(*************************************************************************)
+
+open Base
+module HThTerm = Datastructure.Hashtbl2 (Nodes.ThTerm)
+
+type t = {
+ activated : bool Context.Ref.t;
+ terms : Nodes.ThTerm.t Context.Queue.t;
+}
+
+and choosable =
+ | Choosable
+ | Init
+ | Wait of { choices : Egraph.choice list; groups : t list }
+
+let pp_choosable fmt = function
+ | Choosable -> Fmt.pf fmt "!"
+ | Wait _ -> Fmt.pf fmt "?"
+ | Init -> Fmt.pf fmt "??"
+
+let state : choosable HThTerm.t =
+ HThTerm.create pp_choosable "Choice_group.cells" (fun _ -> Init)
+
+let register_decision d thterm choice =
+ match HThTerm.find state d thterm with
+ | Choosable -> Egraph.register_decision d choice
+ | Init ->
+ HThTerm.set state d thterm Choosable;
+ Egraph.register_decision d choice
+ | Wait l ->
+ HThTerm.set state d thterm
+ (Wait { choices = choice :: l.choices; groups = l.groups })
+
+let add_to_group d thterm group =
+ let add_group () = Context.Queue.enqueue group.terms thterm in
+ match HThTerm.find state d thterm with
+ | Choosable -> ()
+ | Init ->
+ HThTerm.set state d thterm (Wait { choices = []; groups = [ group ] });
+ add_group ()
+ | Wait l ->
+ add_group ();
+ HThTerm.set state d thterm
+ (Wait { choices = l.choices; groups = group :: l.groups })
+
+let create d =
+ (* Fmt.epr "Create_to_group@."; *)
+ {
+ activated = Context.Ref.create (Egraph.context d) false;
+ terms = Context.Queue.create (Egraph.context d);
+ }
+
+let make_choosable d thterm =
+ match HThTerm.find state d thterm with
+ | Choosable -> ()
+ | Init -> HThTerm.set state d thterm Choosable
+ | Wait l ->
+ HThTerm.set state d thterm Choosable;
+ List.iter l.choices ~f:(Egraph.register_decision d)
+
+let activate d t =
+ (* Fmt.epr "Activate group@."; *)
+ if not (Context.Ref.get t.activated) then (
+ Context.Ref.set t.activated true;
+ Context.Queue.iter (make_choosable d) t.terms)
+
+let add_to_group_of d thterm thterm' =
+ let add_group groups choices =
+ match HThTerm.find state d thterm' with
+ | Choosable -> make_choosable d thterm
+ | Init -> ()
+ | Wait { groups = groups'; _ } ->
+ List.iter groups' ~f:(fun group ->
+ Context.Queue.enqueue group.terms thterm);
+ HThTerm.set state d thterm (Wait { choices; groups = groups' @ groups })
+ in
+
+ match HThTerm.find state d thterm with
+ | Choosable -> ()
+ | Init -> add_group [] []
+ | Wait l -> add_group l.groups l.choices
diff --git a/src_colibri2/core/choice_group.mli b/src_colibri2/core/choice_group.mli
new file mode 100644
index 0000000000000000000000000000000000000000..12cf70fa5735480c490bd13b62a9b7858f7e29cc
--- /dev/null
+++ b/src_colibri2/core/choice_group.mli
@@ -0,0 +1,39 @@
+(*************************************************************************)
+(* This file is part of Colibri2. *)
+(* *)
+(* Copyright (C) 2014-2021 *)
+(* CEA (Commissariat à l'énergie atomique et aux énergies *)
+(* alternatives) *)
+(* *)
+(* you can redistribute it and/or modify it under the terms of the GNU *)
+(* Lesser General Public License as published by the Free Software *)
+(* Foundation, version 2.1. *)
+(* *)
+(* It 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 Lesser General Public License for more details. *)
+(* *)
+(* See the GNU Lesser General Public License version 2.1 *)
+(* for more details (enclosed in the file licenses/LGPLv2.1). *)
+(*************************************************************************)
+
+type t
+(** A scope for decision, allows to wait before adding decisions for terms.
+ Used for propagating into a term without decisions *)
+
+val create : _ Egraph.t -> t
+
+val activate : _ Egraph.t -> t -> unit
+
+val add_to_group : _ Egraph.t -> Nodes.ThTerm.t -> t -> unit
+
+val register_decision : _ Egraph.t -> Nodes.ThTerm.t -> Egraph.choice -> unit
+(** If no group have been specified at that point, the default is
+ for the decision to be directly activated *)
+
+val make_choosable : _ Egraph.t -> Nodes.ThTerm.t -> unit
+(** Register the decisions attached to the node, and will not delay them in the
+ future *)
+
+val add_to_group_of : _ Egraph.t -> Nodes.ThTerm.t -> Nodes.ThTerm.t -> unit
diff --git a/src_colibri2/core/colibri2_core.ml b/src_colibri2/core/colibri2_core.ml
index 3faa8c1483498af7b715d7335b7b836a4195af5a..780a21f70ba6b0054dcb010c667e44200eccbfbd 100644
--- a/src_colibri2/core/colibri2_core.ml
+++ b/src_colibri2/core/colibri2_core.ml
@@ -210,6 +210,9 @@ module Events = struct
type daemon_key = Events.Wait.daemon_key =
| DaemonKey : 'runable Dem.t * 'runable * ThTerm.t option -> daemon_key
+ let pp_daemon_key fmt = function
+ | DaemonKey (dem, run, _) -> Wait.print_dem_runable dem fmt run
+
module type T = Egraph.Wait.Dem
(** Basic daemons *)
@@ -259,5 +262,9 @@ module Choice = struct
print_cho : string;
}
- let register = Egraph.register_decision
+ let register d g dec = Choice_group.register_decision d (Ground.thterm g) dec
+
+ let register_thterm = Choice_group.register_decision
+
+ module Group = Choice_group
end
diff --git a/src_colibri2/core/colibri2_core.mli b/src_colibri2/core/colibri2_core.mli
index 9d739358ec0804e3dd9d1b848b9ee056948d9f16..9e3fc5993fb6bd4b3aef0703abe1df78bf3d82c6 100644
--- a/src_colibri2/core/colibri2_core.mli
+++ b/src_colibri2/core/colibri2_core.mli
@@ -203,10 +203,14 @@ and Ground : sig
(** Return the user type. Raise if the ThTerm does not belong to this
module *)
- val convert : ?subst:Subst.t -> Expr.Term.t -> Node.t
+ val convert : ?subst:Subst.t -> _ Egraph.t -> Expr.Term.t -> Node.t
val apply :
- Expr.Term.Const.t -> Ty.t list -> Node.t Colibri2_popop_lib.IArray.t -> s
+ _ Egraph.t ->
+ Expr.Term.Const.t ->
+ Ty.t list ->
+ Node.t Colibri2_popop_lib.IArray.t ->
+ s
val init : Egraph.wt -> unit
@@ -1119,6 +1123,8 @@ and Events : sig
type daemon_key =
| DaemonKey : 'runable Dem.t * 'runable * ThTerm.t option -> daemon_key
+ val pp_daemon_key : daemon_key Fmt.t
+
(** {3 Basic daemons} *)
module type T = sig
type runable
@@ -1201,10 +1207,36 @@ module Choice : sig
and t = { choice : Egraph.wt -> choice_state; prio : int; print_cho : string }
- val register : Egraph.wt -> t -> unit
- (** register a decision that would be scheduled later. The
- [choose_decision] of the [Cho] will be called at that time to know
- if the decision is still needed. *)
+ val register : _ Egraph.t -> Ground.t -> t -> unit
+ (** register a decision that would be scheduled later. The [choose_decision]
+ of the [Cho] will be called at that time to know if the decision is still
+ needed. The decision will not be scheduled if the ground term is part of a
+ group not activated.If no group have been specified at that point, the
+ default is for the decision to be directly activated *)
+
+ val register_thterm : _ Egraph.t -> ThTerm.t -> t -> unit
+ (** Same as {!register} but for {!ThTerm.t} *)
+
+ module Group : sig
+ type t
+ (** A scope for decision, allows to wait before adding decisions for terms.
+ Used for propagating into a term without decisions *)
+
+ val create : _ Egraph.t -> t
+ (** Create a new group *)
+
+ val activate : _ Egraph.t -> t -> unit
+
+ val add_to_group : _ Egraph.t -> ThTerm.t -> t -> unit
+ (** Add a {!ThTerm.t} to a group *)
+
+ val make_choosable : _ Egraph.t -> ThTerm.t -> unit
+ (** Register the decisions attached to the node, and will not delay them in the
+ future *)
+
+ val add_to_group_of : _ Egraph.t -> ThTerm.t -> ThTerm.t -> unit
+ (** [add_to_group_of d t1 t2] add t1 in the group of t2 *)
+ end
end
(** {3 Helpers } *)
diff --git a/src_colibri2/core/demon.ml b/src_colibri2/core/demon.ml
index 065a46de4fd816aa5154a4a2abab539acba5ca54..6f3fa8e3f8be5600b47ade04b920255524c5c596 100644
--- a/src_colibri2/core/demon.ml
+++ b/src_colibri2/core/demon.ml
@@ -90,11 +90,16 @@ module type Attach = sig
(?thterm:Nodes.ThTerm.t -> (Node.t -> result) env -> unit, 'b) arg
end
-module type Simple =
- Attach
- with type ('a, 'b) arg := 'b Egraph.t -> 'a
- and type 'a env := Egraph.wt -> 'a
- and type result := unit
+module type Simple = sig
+ include
+ Attach
+ with type ('a, 'b) arg := 'b Egraph.t -> 'a
+ and type 'a env := Egraph.wt -> 'a
+ and type result := unit
+
+ val schedule_immediately :
+ _ Egraph.t -> ?thterm:Nodes.ThTerm.t -> (Egraph.wt -> unit) -> unit
+end
module Simple = struct
module Make (Info : sig
@@ -158,6 +163,9 @@ module Simple = struct
let attach_any_repr d ?thterm f =
Egraph.attach_any_repr d (wrap_node thterm f)
+
+ let schedule_immediately d ?thterm f =
+ Egraph.new_pending_daemon d ?thterm D.key (fun d -> f d)
end
module FixingModel = Make (struct
@@ -166,6 +174,12 @@ module Simple = struct
let delay = Events.FixingModel
end)
+ module LastEffort = Make (struct
+ let name = "Demon.Simple.FixingModel"
+
+ let delay = Events.LastEffort 1
+ end)
+
module DelayedBy1 = Make (struct
let name = "Demon.Simple.DelayedBy1"
diff --git a/src_colibri2/core/demon.mli b/src_colibri2/core/demon.mli
index cc089afd200614853e031d0e3d3dcc19259cf65b..43f3d1cd4f0e38667815f98506ccd2218bb9a1e7 100644
--- a/src_colibri2/core/demon.mli
+++ b/src_colibri2/core/demon.mli
@@ -90,16 +90,23 @@ module type Attach = sig
(?thterm:Nodes.ThTerm.t -> (Node.t -> result) env -> unit, 'b) arg
end
-module type Simple =
- Attach
- with type ('a, 'b) arg := 'b Egraph.t -> 'a
- and type 'a env := Egraph.wt -> 'a
- and type result := unit
+module type Simple = sig
+ include
+ Attach
+ with type ('a, 'b) arg := 'b Egraph.t -> 'a
+ and type 'a env := Egraph.wt -> 'a
+ and type result := unit
+
+ val schedule_immediately :
+ _ Egraph.t -> ?thterm:Nodes.ThTerm.t -> (Egraph.wt -> unit) -> unit
+end
module Simple : sig
include Simple
module FixingModel : Simple
+
+ module LastEffort : Simple
end
module WithFilter :
diff --git a/src_colibri2/core/egraph.mli b/src_colibri2/core/egraph.mli
index 5e51dd991fb5cf482450b5d5c5d2d417fa349efe..18e63212a03de746cabc34bb935937f372607acc 100644
--- a/src_colibri2/core/egraph.mli
+++ b/src_colibri2/core/egraph.mli
@@ -128,7 +128,7 @@ and choice = {
print_cho: string;
}
-val register_decision: wt -> choice -> unit
+val register_decision: _ t -> choice -> unit
(** register a decision that would be scheduled later. The
[choose_decision] of the [Cho] will be called at that time to know
if the decision is still needed. *)
diff --git a/src_colibri2/core/ground.ml b/src_colibri2/core/ground.ml
index 5bea372d0a8b5c38a76c12ef7ecbfd4e08190de5..f64774bdf6ad5eb284927cf0140df0a4e0c25e32 100644
--- a/src_colibri2/core/ground.ml
+++ b/src_colibri2/core/ground.ml
@@ -442,11 +442,14 @@ let rec convert_and_iter ?(subst = Subst.empty) fg fcq fnt (t : Expr.Term.t) =
(* TODO convert to one multitest like
the match of why3 and projection *)
-let convert ?subst e =
- let funit _ = () in
- convert_and_iter funit funit funit ?subst e
-
-let apply (f : Expr.Term.Const.t) tyargs args =
+let convert ?subst d e =
+ convert_and_iter
+ (fun th -> Choice_group.make_choosable d (ThTerm.thterm th))
+ (fun th -> Choice_group.make_choosable d (ClosedQuantifier.thterm th))
+ (fun th -> Choice_group.make_choosable d (NotTotallyApplied.thterm th))
+ ?subst e
+
+let apply _ (f : Expr.Term.Const.t) tyargs args =
let rec apply_ty subst tyargs (ty : Expr.Ty.t) =
match (ty.ty_descr, tyargs) with
| Pi (ty_vars, ty), _ ->
@@ -479,17 +482,21 @@ module Defs = struct
let add d tc tyl tvl body =
Expr.Term.Const.HC.set fundefs d tc { tyl; tvl; body }
- module ThTermH = Datastructure.Hashtbl2 (ThTerm)
+ module ThTermH = Datastructure.Hashtbl (ThTerm)
+
+ let levels = ThTermH.create Popop_stdlib.DInt.pp "ground_levels"
- let levels = ThTermH.create Popop_stdlib.DInt.pp "ground_levels" (fun _ -> 0)
+ (** Maximum level of unfolding *)
+ let level_max = 10
- let level_max = 3
+ (** Maximum level where the terms can be directly decided *)
+ let level_dec = 0
let stats_function_call =
Debug.register_stats_int ~name:"Ground.function_call" ~init:0
let converter d (v : ThTerm.t) =
- let level = ThTermH.find levels d v in
+ let level = Option.value ~default:0 (ThTermH.find_opt levels d v) in
if level <= level_max then
let cl = ThTerm.node v in
match ThTerm.sem v with
@@ -507,18 +514,39 @@ module Defs = struct
Subst.ty = Expr.Ty.Var.M.of_list (List.combine fundef.tyl tyl);
}
in
+ let group = Choice_group.create d in
let n =
convert_and_iter ~subst
(fun th ->
+ if level <= level_dec then
+ Choice_group.make_choosable d (ThTerm.thterm th)
+ else Choice_group.add_to_group d (ThTerm.thterm th) group;
match ThTerm.sem th with
| { app = tc; _ } -> (
match Expr.Term.Const.HC.find fundefs d tc with
| exception Not_found -> ()
- | _ -> ThTermH.set levels d th (1 + level)))
- (fun _ -> ())
- (fun _ -> ())
+ | _ ->
+ if not (ThTermH.mem levels d th) then
+ ThTermH.set levels d th (1 + level)))
+ (fun th ->
+ if level <= level_dec then
+ Choice_group.make_choosable d (ClosedQuantifier.thterm th)
+ else
+ Choice_group.add_to_group d
+ (ClosedQuantifier.thterm th)
+ group)
+ (fun th ->
+ if level <= level_dec then
+ Choice_group.make_choosable d
+ (NotTotallyApplied.thterm th)
+ else
+ Choice_group.add_to_group d
+ (NotTotallyApplied.thterm th)
+ group)
fundef.body
in
+ Demon.Simple.LastEffort.schedule_immediately d (fun d ->
+ Choice_group.activate d group);
Debug.incr stats_function_call;
Egraph.register d n;
Egraph.merge d cl n)
diff --git a/src_colibri2/core/ground.mli b/src_colibri2/core/ground.mli
index baa3fbc47921565706d45050c47d5d0ba73270c2..7391b92737a4e33b517e7262313e9d4ac958d22a 100644
--- a/src_colibri2/core/ground.mli
+++ b/src_colibri2/core/ground.mli
@@ -101,9 +101,10 @@ type s = All.term = {
include RegisteredThTerm with type s := Term.t
-val convert : ?subst:Subst.t -> Expr.Term.t -> Node.t
+val convert : ?subst:Subst.t -> _ Egraph.t -> Expr.Term.t -> Node.t
-val apply : Expr.Term.Const.t -> Ty.t list -> Node.t IArray.t -> Term.t
+val apply :
+ _ Egraph.t -> Expr.Term.Const.t -> Ty.t list -> Node.t IArray.t -> Term.t
val init : Egraph.wt -> unit
diff --git a/src_colibri2/solver/input.ml b/src_colibri2/solver/input.ml
index f77b5d5d4a5c3f815bd31f8f7f3b200409a610f1..89e160d477e264a4b61fee38f0f2d3f60117f413 100644
--- a/src_colibri2/solver/input.ml
+++ b/src_colibri2/solver/input.ml
@@ -212,7 +212,7 @@ let def st (d : Typer.def) =
Ground.Defs.add d tc tyl tvl b)
let set_term_true ~set_true d t =
- let t = Ground.convert t in
+ let t = Ground.convert d t in
Egraph.register d t;
set_true d t
diff --git a/src_colibri2/solver/scheduler.ml b/src_colibri2/solver/scheduler.ml
index ea9b40a7dd6a63445a30c3afb10a708a7cc66223..2ecad1f0cd0896532b178499e67476962977c298 100644
--- a/src_colibri2/solver/scheduler.ml
+++ b/src_colibri2/solver/scheduler.ml
@@ -24,11 +24,17 @@ open ForSchedulers
let debug =
Debug.register_info_flag ~desc:"for the scheduler in the simple version"
- "sched_queue"
+ "sched"
+
+let debug_queue =
+ Debug.register_info_flag ~desc:"for the scheduler queues" "sched_queue"
let debug_pushpop =
Debug.register_info_flag ~desc:"for the scheduler push/pop" "sched_pushpop"
+let debug_learn =
+ Debug.register_info_flag ~desc:"for the scheduler learning" "sched_learn"
+
let debug_dotgui =
Debug.register_flag ~desc:"print graph at interesting time (push/pop)"
"sched_dotgui"
@@ -40,6 +46,9 @@ let stats_propa = Debug.register_stats_int ~name:"Scheduler.daemon" ~init:0
let stats_lasteffort =
Debug.register_stats_int ~name:"Scheduler.lasteffort" ~init:0
+let stats_lasteffort_propa =
+ Debug.register_stats_int ~name:"Scheduler.lasteffort_propa" ~init:0
+
let stats_dec = Debug.register_stats_int ~name:"Scheduler.decision" ~init:0
let stats_con = Debug.register_stats_int ~name:"Scheduler.conflict" ~init:0
@@ -82,10 +91,18 @@ struct
mutable next : int;
db : float Popop_stdlib.DInt.H.t;
prio : P.t Context.Ref.t;
- mutable size : int;
+ size : int Context.Ref.t;
}
- let reprio t = Context.Ref.set t.prio (P.reprio t.db (Context.Ref.get t.prio))
+ let reprio_is_changed t =
+ let prio_old = Context.Ref.get t.prio in
+ let prio = P.reprio t.db prio_old in
+ if Base.phys_equal prio_old prio then false
+ else (
+ Context.Ref.set t.prio prio;
+ true)
+
+ let reprio t = ignore (reprio_is_changed t)
let change t x coef =
Popop_stdlib.DInt.H.change
@@ -93,7 +110,7 @@ struct
t.db x.Att.id
let insert t v =
- t.size <- t.size + 1;
+ Context.Ref.set t.size (Context.Ref.get t.size + 1);
let x = { Att.v; id = t.next } in
t.next <- t.next + 1;
Context.Ref.set t.prio (P.insert t.db x (Context.Ref.get t.prio))
@@ -102,7 +119,7 @@ struct
match P.extract_min (Context.Ref.get t.prio) with
| x, prio ->
Context.Ref.set t.prio prio;
- t.size <- t.size - 1;
+ Context.Ref.set t.size (Context.Ref.get t.size - 1);
Some x
| exception Leftistheap.Empty -> None
@@ -116,14 +133,14 @@ struct
| _, prio -> Context.Ref.set t.prio prio
| exception Leftistheap.Empty -> ()
- let size t = t.size
+ let size t = Context.Ref.get t.size
let create c =
{
next = 0;
db = Popop_stdlib.DInt.H.create 10;
prio = Context.Ref.create c P.empty;
- size = 0;
+ size = Context.Ref.create c 0;
}
end
@@ -161,7 +178,10 @@ type bp = {
last_todo : (Egraph.wt -> unit) * bp_kind;
}
-type solve_step = Propagate | FixModel
+type solve_step =
+ | Propagate
+ | FixModel
+ | BacktrackChoice of (Egraph.wt -> unit) * (Egraph.wt -> unit) Base.Sequence.t
type t = {
choices : Prio.t;
@@ -493,9 +513,17 @@ let learn t =
let rec conflict_analysis t =
Option.iter
- (fun v -> PrioLastEffort.change t.lasteffort v 2.)
+ (fun v ->
+ Debug.dprintf2 debug_learn "[Learnt] %a is useful" Events.pp_daemon_key
+ v.PrioLastEffort.Att.v;
+ PrioLastEffort.change t.lasteffort v 2.)
t.last_effort_made;
- Option.iter (fun v -> Prio.change t.choices v 2.) t.last_decision_made;
+ Option.iter
+ (fun v ->
+ Debug.dprintf1 debug_learn "[Learnt] %s has a useful decision"
+ v.Prio.Att.v.Choice.print_cho;
+ Prio.change t.choices v 2.)
+ t.last_decision_made;
t.last_effort_made <- None;
t.last_decision_made <- None;
if t.allow_learning then learn t;
@@ -512,12 +540,17 @@ let rec conflict_analysis t =
| Some prev -> (
pop_to t prev;
Prio.reprio t.choices;
- PrioLastEffort.reprio t.lasteffort;
+ let has_learnt = PrioLastEffort.reprio_is_changed t.lasteffort in
match prev.kind with
| Choices seq -> (
match Base.Sequence.next seq with
| None -> rewind ()
- | Some (choice, choices) -> make_choice t choice choices)
+ | Some (choice, choices) ->
+ if has_learnt && false then (
+ assert (Context.Ref.get t.solve_step = Propagate);
+ Context.Ref.set t.solve_step
+ (BacktrackChoice (choice, choices)))
+ else make_choice t choice choices)
| External -> raise Contradiction)
in
rewind ()
@@ -546,7 +579,7 @@ and make_choice t todo todos =
try todo (Backtrackable.get_delayed t.solver_state)
with Egraph.Contradiction ->
Debug.dprintf2 debug_pushpop
- "[Scheduler] Contradiction when chosing at level %a" print_level t;
+ "[Scheduler] Contradiction when choosing at level %a" print_level t;
conflict_analysis t
(* let rec run_until_dec t d =
@@ -581,27 +614,29 @@ let run_one_step_propagation ~nodec t =
let d = Backtrackable.get_delayed t.solver_state in
Backtrackable.run_daemon d att)
(fun () -> true)
- | None when nodec -> false
| None -> (
match PrioLastEffort.get_min_and_skew t.lasteffort with
| Some (att, skew) when skew > 32. ->
PrioLastEffort.pop t.lasteffort;
- Debug.incr stats_propa;
+ Debug.dprintf2 debug_learn "[Learnt] %a is directly propagated"
+ Events.pp_daemon_key att.PrioLastEffort.Att.v;
+ Debug.incr stats_lasteffort_propa;
protect_against_contradiction t
(fun () ->
let d = Backtrackable.get_delayed t.solver_state in
Backtrackable.run_daemon d att.v)
(fun () -> true)
+ | _ when nodec -> false
| _ -> (
match Prio.extract_min t.choices with
| Some chogen as o ->
t.last_decision_made <- o;
- Debug.dprintf0 debug "[Scheduler] Decision mode";
+ Debug.dprintf0 debug_queue "[Scheduler] Decision mode";
try_run_dec t chogen.v;
true
| None -> (
t.last_decision_made <- None;
- Debug.dprintf1 debug "[Scheduler] LastEffort: %i"
+ Debug.dprintf1 debug_queue "[Scheduler] LastEffort: %i"
(PrioLastEffort.size t.lasteffort);
(* if Context.TimeWheel.current_time t.lasteffort < max_last_effort then *)
match PrioLastEffort.extract_min t.lasteffort with
@@ -653,6 +688,13 @@ let run_one_step ~nodec t =
Debug.dprintf0 debug "[Scheduler] FixModel";
Context.Ref.set t.solve_step FixModel;
true)
+ | BacktrackChoice (choice, choices) -> (
+ match run_one_step_propagation ~nodec:true t with
+ | true -> true
+ | false ->
+ Context.Ref.set t.solve_step Propagate;
+ make_choice t choice choices;
+ true)
| FixModel -> run_one_step_fix_model t
let rec flush t =
@@ -691,8 +733,9 @@ let init_theories ~theories t =
let add_assertion t f =
try
let d = Backtrackable.get_delayed t.solver_state in
- f d;
- flush t
+ let res = f d in
+ flush t;
+ res
with Egraph.Contradiction ->
Debug.dprintf0 debug "[Scheduler] Contradiction during assertion";
raise Contradiction
@@ -708,11 +751,11 @@ let check_sat ?limit t =
let run_exn ?nodec ?limit ?(learning = false) ~theories f =
let t = new_solver ~learning () in
init_theories ~theories t;
- add_assertion t f;
+ let check = add_assertion t f in
flush t;
run_inf_step ~nodec:(nodec = Some ()) ?limit t;
let d = Backtrackable.get_delayed t.solver_state in
- d
+ check d
let run ?nodec ?limit ~theories f =
try `Done (run_exn ?nodec ?limit ~theories f)
diff --git a/src_colibri2/solver/scheduler.mli b/src_colibri2/solver/scheduler.mli
index 88b61ad2c573da4bee4b47945453b6e1cbf2b518..9f3d37d5e4a03f76f153076f0980f5ec52d9ddae 100644
--- a/src_colibri2/solver/scheduler.mli
+++ b/src_colibri2/solver/scheduler.mli
@@ -23,15 +23,21 @@ val run_exn :
?limit:int ->
?learning:bool ->
theories:(Egraph.wt -> unit) list ->
- (Egraph.wt -> unit) ->
- Egraph.wt
+ (Egraph.wt -> Egraph.wt -> 'a) ->
+ 'a
+(** [run_exn ?nodec ?limit ?learning ~theories add_assertions].
+
+ [add_assertions d] should add the assertions. The resulting function is
+ applied on the environment after propagation and possibly decisions
+
+ *)
val run :
?nodec:unit ->
?limit:int ->
theories:(Egraph.wt -> unit) list ->
- (Egraph.wt -> unit) ->
- [> `Contradiction | `Done of Egraph.wt ]
+ (Egraph.wt -> Egraph.wt -> 'a) ->
+ [> `Contradiction | `Done of 'a ]
type t
diff --git a/src_colibri2/tests/.ocamlformat b/src_colibri2/tests/.ocamlformat
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src_colibri2/tests/generate_tests/generate_dune_tests.ml b/src_colibri2/tests/generate_tests/generate_dune_tests.ml
index 7a3261dd8dce452d2df53cfff8f78152a7e9101c..ed68c9afae6098645f38e7a01752e25eb667af97 100644
--- a/src_colibri2/tests/generate_tests/generate_dune_tests.ml
+++ b/src_colibri2/tests/generate_tests/generate_dune_tests.ml
@@ -22,7 +22,7 @@ let dir = Sys.argv.(1)
let result = if Array.length Sys.argv >= 3 then Some Sys.argv.(2) else None
-let cmd = "%{bin:colibri2} --size=20M --time=30s --max-steps 3500"
+let cmd = "%{bin:colibri2} --size=100M --time=30s --max-steps 3500"
let print_test cout file =
match result with
diff --git a/src_colibri2/tests/solve/all/sat/dune.inc b/src_colibri2/tests/solve/all/sat/dune.inc
index c126645af6fe337a080b2d8a6df208797cf706da..d13402ca18f7dff4af3f02dbe0c2902cfe31f1dc 100644
--- a/src_colibri2/tests/solve/all/sat/dune.inc
+++ b/src_colibri2/tests/solve/all/sat/dune.inc
@@ -1,9 +1,9 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:div_abs.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:div_abs.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:div_abs.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:div_abs2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:div_abs2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:div_abs2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:union-Union-is_singletonqtvc_2.psmt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:union-Union-is_singletonqtvc_2.psmt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:union-Union-is_singletonqtvc_2.psmt2})))
diff --git a/src_colibri2/tests/solve/all/unsat/dune.inc b/src_colibri2/tests/solve/all/unsat/dune.inc
index 514754ced3fe6d5b81cc1a0aceda3f631e123415..54cb6af43354a8191bd634f4325476146533fa81 100644
--- a/src_colibri2/tests/solve/all/unsat/dune.inc
+++ b/src_colibri2/tests/solve/all/unsat/dune.inc
@@ -1,33 +1,36 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:bag-BagImpl-createqtvc.psmt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:bag-BagImpl-createqtvc.psmt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:bag-BagImpl-createqtvc.psmt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:div_abs.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:div_abs.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:div_abs.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:fact-FactRecursive-fact_recqtvc.psmt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:fact-FactRecursive-fact_recqtvc.psmt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:fact-FactRecursive-fact_recqtvc.psmt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:interval-Convexe-exists_memqtvc_1.psmt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:interval-Convexe-exists_memqtvc_1.psmt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:interval-Convexe-exists_memqtvc_1.psmt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:interval-Convexe-exists_memqtvc_2.psmt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:interval-Convexe-exists_memqtvc_2.psmt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:interval-Convexe-exists_memqtvc_2.psmt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
+--dont-print-result %{dep:lost_in_search_union.psmt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:lost_in_search_union.psmt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:mul_abs.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_abs.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_abs.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:ordered_is_ordered.psmt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:ordered_is_ordered.psmt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:ordered_is_ordered.psmt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:union-Union-is_singletonqtvc_1.psmt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:union-Union-is_singletonqtvc_1.psmt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:union-Union-is_singletonqtvc_1.psmt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:union-Union-is_singletonqtvc_2.psmt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:union-Union-is_singletonqtvc_2.psmt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:union-Union-is_singletonqtvc_2.psmt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:union-Union-is_singletonqtvc_5.psmt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:union-Union-is_singletonqtvc_5.psmt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:union-Union-is_singletonqtvc_5.psmt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:union-Union-length0_positiveqtvc_1.psmt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:union-Union-length0_positiveqtvc_1.psmt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:union-Union-length0_positiveqtvc_1.psmt2})))
diff --git a/src_colibri2/tests/solve/all/unsat/lost_in_search_union.psmt2 b/src_colibri2/tests/solve/all/unsat/lost_in_search_union.psmt2
new file mode 100644
index 0000000000000000000000000000000000000000..618aeb15c2fac01b35ae895df4582d6286820965
--- /dev/null
+++ b/src_colibri2/tests/solve/all/unsat/lost_in_search_union.psmt2
@@ -0,0 +1,377 @@
+;; produced by local colibri2.drv ;;
+(set-logic ALL)
+(set-info :smt-lib-version 2.6)
+;;; SMT-LIB2: integer arithmetic
+;;; SMT-LIB2: real arithmetic
+(set-option :max-steps-colibri2 41000)
+(declare-sort t 0)
+
+;; real
+(declare-fun real (t) Real)
+
+;; infix <=
+(define-fun infix_lseq ((a11 t) (b1 t)) Bool
+ (<= (real a11) (real b1)))
+
+;; infix <
+(define-fun infix_ls ((a11 t) (b1 t)) Bool
+ (< (real a11) (real b1)))
+
+(declare-datatypes ((t1 0))
+ (((Eq) (Lt) (Gt))))
+
+;; infix +
+(declare-fun infix_pl (t
+ t) t)
+
+(declare-datatypes ((t2 0))
+ (((Strict) (Large))))
+
+(declare-datatypes ((t0 0))
+ (((Singleton (Singleton_proj_1 t)(Singleton_proj_2 t0))
+ (Inter
+ (Inter_proj_1 t)(Inter_proj_2 t2)(Inter_proj_3 t)(Inter_proj_4 t2)(Inter_proj_5 t0))
+ (FiniteInf (FiniteInf_proj_1 t)(FiniteInf_proj_2 t2)) (End))))
+
+(declare-datatypes ((t3 0))
+ (((InfFinite
+ (InfFinite_proj_1 t)(InfFinite_proj_2 t2)(InfFinite_proj_3 t0))
+ (Finite (Finite_proj_1 t0)) (Inf))))
+
+;; length0
+(define-fun-rec length0 ((l t0)) Int
+ (ite ((_ is Singleton) l) (let (
+ (x (Singleton_proj_2 l))) (+ (length0 x) 1))
+ (ite ((_ is Inter) l) (let (
+
+
+
+ (x1 (Inter_proj_5 l))) (+ (length0 x1) 2))
+ (ite ((_ is FiniteInf) l) 1 0))))
+
+;; length0_positive
+(assert (forall ((l t0)) (>= (length0 l) 0)))
+
+;; length
+(define-fun length ((l t3)) Int
+ (ite ((_ is InfFinite) l) (let (
+
+ (x10 (InfFinite_proj_3 l))) (+ (length0 x10) 1))
+ (ite ((_ is Finite) l) (let ((x11 (Finite_proj_1 l))) (length0 x11)) 0)))
+
+;; lt_bound0
+(define-fun-rec lt_bound0 ((x15 t) (l t0)) Bool
+ (ite ((_ is Singleton) l) (let ((x16 (Singleton_proj_1 l))
+ (x17 (Singleton_proj_2 l))) (and
+ (infix_ls
+ x15
+ x16)
+ (lt_bound0
+ x15
+ x17)))
+ (ite ((_ is Inter) l) (let ((x18 (Inter_proj_1 l))
+
+ (x19 (Inter_proj_3 l))
+
+ (x20 (Inter_proj_5 l))) (and
+ (infix_ls x15 x18)
+ (and
+ (infix_ls x15 x19)
+ (lt_bound0 x15 x20))))
+ (ite ((_ is FiniteInf) l) (let ((x21 (FiniteInf_proj_1 l))
+ ) (infix_ls x15 x21)) true))))
+
+;; lt_bound
+(define-fun lt_bound ((x22 t) (l t3)) Bool
+ (ite ((_ is InfFinite) l) (let ((x23 (InfFinite_proj_1 l))
+
+ (x24 (InfFinite_proj_3 l))) (or
+ (infix_ls
+ x22
+ x23)
+ (lt_bound0
+ x22
+ x24)))
+ (ite ((_ is Finite) l) (let ((x25 (Finite_proj_1 l))) (lt_bound0 x22 x25)) true)))
+
+;; ordered0
+(define-fun-rec ordered0 ((l t0)) Bool
+ (ite ((_ is Singleton) l) (let ((x26 (Singleton_proj_1 l))
+ (x27 (Singleton_proj_2 l))) (and
+ (lt_bound0
+ x26
+ x27)
+ (ordered0 x27)))
+ (ite ((_ is Inter) l) (let ((x28 (Inter_proj_1 l))
+
+ (x29 (Inter_proj_3 l))
+
+ (x30 (Inter_proj_5 l))) (and
+ (infix_ls x28 x29)
+ (and
+ (lt_bound0 x29 x30)
+ (ordered0 x30))))
+ (ite ((_ is FiniteInf) l) true true))))
+
+;; ordered
+(define-fun ordered ((l t3)) Bool
+ (ite ((_ is InfFinite) l) (let ((x31 (InfFinite_proj_1 l))
+
+ (x32 (InfFinite_proj_3 l))) (and
+ (lt_bound0
+ x31
+ x32)
+ (ordered0 x32)))
+ (ite ((_ is Finite) l) (let ((x33 (Finite_proj_1 l))) (ordered0 x33)) true)))
+
+(declare-datatypes ((tuple1 1))
+ ((par (a11) ((Tuple1 (Tuple1_proj_1 a11))))))
+
+(declare-sort tqt 0)
+
+;; a
+(declare-fun a12 (tqt) t3)
+
+;; t''invariant
+(assert
+ (forall ((self tqt))
+ (! (and (ordered (a12 self)) (not (= (a12 self) (Finite End)))) :pattern (
+ (a12
+ self)) )))
+
+;; cmp
+(define-fun cmp ((x34 Real) (b1 t2) (y Real)) Bool
+ (ite ((_ is Large) b1) (<= x34 y) (< x34 y)))
+
+;; mem0
+(define-fun-rec mem0 ((x34 Real) (l t0)) Bool
+ (ite ((_ is Singleton) l) (let ((x35 (Singleton_proj_1 l))
+ (x36 (Singleton_proj_2 l))) (or
+ (= x34 (real x35))
+ (mem0 x34 x36)))
+ (ite ((_ is Inter) l) (let ((x37 (Inter_proj_1 l))
+ (x38 (Inter_proj_2 l))
+ (x39 (Inter_proj_3 l))
+ (x40 (Inter_proj_4 l))
+ (x41 (Inter_proj_5 l))) (or
+ (and
+ (cmp
+ (real x37)
+ x38
+ x34)
+ (cmp
+ x34
+ x40
+ (real x39)))
+ (mem0 x34 x41)))
+ (ite ((_ is FiniteInf) l) (let ((x42 (FiniteInf_proj_1 l))
+ (x43 (FiniteInf_proj_2 l))) (cmp
+ (real x42)
+ x43
+ x34)) false))))
+
+;; lt_bound0_is_not_mem0
+(assert
+ (forall ((q t) (r Real) (l t0))
+ (=> (lt_bound0 q l) (=> (<= r (real q)) (not (mem0 r l))))))
+
+;; mem
+(define-fun mem ((x44 Real) (l t3)) Bool
+ (ite ((_ is InfFinite) l) (let ((x45 (InfFinite_proj_1 l))
+ (x46 (InfFinite_proj_2 l))
+ (x47 (InfFinite_proj_3 l))) (or
+ (cmp
+ x44
+ x46
+ (real x45))
+ (mem0 x44 x47)))
+ (ite ((_ is Finite) l) (let ((x48 (Finite_proj_1 l))) (mem0 x44 x48)) true)))
+
+;; u
+(declare-fun u () tqt)
+
+;; v
+(declare-fun v () tqt)
+
+;; u
+(declare-fun u1 () t0)
+
+;; v
+(declare-fun v1 () t0)
+
+;; Requires
+(assert (ordered0 u1))
+
+;; Requires
+(assert (ordered0 v1))
+
+;; x
+(declare-fun x49 () t)
+
+;; x
+(declare-fun x50 () t2)
+
+;; x
+(declare-fun x51 () t)
+
+;; x
+(declare-fun x52 () t2)
+
+;; x
+(declare-fun x53 () t0)
+
+;; H
+(assert (= v1 (Inter x49 x50 x51 x52 x53)))
+
+;; x
+(declare-fun x54 () t)
+
+;; x
+(declare-fun x55 () t2)
+
+;; x
+(declare-fun x56 () t)
+
+;; x
+(declare-fun x57 () t2)
+
+;; x
+(declare-fun x58 () t0)
+
+;; H
+(assert (= u1 (Inter x54 x55 x56 x57 x58)))
+
+;; qu0
+(declare-fun qu0 () t)
+
+;; bu0
+(declare-fun bu0 () t2)
+
+;; qu1
+(declare-fun qu1 () t)
+
+;; bu1
+(declare-fun bu1 () t2)
+
+;; lu
+(declare-fun lu () t0)
+
+;; u
+(declare-fun u2 () t0)
+
+;; qv0
+(declare-fun qv0 () t)
+
+;; bv0
+(declare-fun bv0 () t2)
+
+;; qv1
+(declare-fun qv1 () t)
+
+;; v
+(declare-fun v2 () t0)
+
+;; Requires
+(assert (ordered0 u2))
+
+;; Requires
+(assert (ordered0 v2))
+
+;; Requires
+(assert (= u2 (Inter qu0 bu0 qu1 bu1 lu)))
+
+;; bv1
+(declare-fun bv1 () t2)
+
+;; lv
+(declare-fun lv () t0)
+
+;; Requires
+(assert (= v2 (Inter qv0 bv0 qv1 bv1 lv)))
+
+;; Requires
+(assert
+ (or
+ (and (= v2 v1) (= (+ (length0 lu) 2) (length0 u1)))
+ (and (= v2 u1) (= (+ (length0 lu) 2) (length0 v1)))))
+
+;; Requires
+(assert (infix_ls qu1 qv1))
+
+;; result
+(declare-fun result () t0)
+
+;; Ensures
+(assert (infix_ls qv0 qu1))
+
+;; o
+(declare-fun o () t0)
+
+;; v3
+(declare-fun v3 () t)
+
+;; b3
+(declare-fun b3 () t2)
+
+;; o
+(declare-fun o1 () t0)
+
+;; Ensures
+(assert
+ (forall ((q Real))
+ (=
+ (and (cmp (real qu0) bu0 q) (cmp (real qv0) bv0 q))
+ (cmp (real v3) b3 q))))
+
+;; Ensures
+(assert (infix_lseq qu0 v3))
+
+;; Ensures
+(assert (infix_lseq qv0 v3))
+
+;; Ensures
+(assert (or (= v3 qu0) (= v3 qv0)))
+
+;; Ensures
+(assert (=> (= bu0 Large) (=> (= bv0 Large) (= b3 Large))))
+
+;; Assert
+(assert (and (infix_lseq qv0 v3) (and (infix_ls v3 qu1) (infix_ls qu1 qv1))))
+
+;; Assert
+(assert (and (infix_lseq qu0 v3) (and (infix_ls v3 qu1) (infix_ls qu1 qv1))))
+
+;; Ensures
+(assert (ordered0 o1))
+
+;; Ensures
+(assert
+ (forall ((x59 Real)) (= (and (mem0 x59 lu) (mem0 x59 v2)) (mem0 x59 o1))))
+
+;; Ensures
+(assert (forall ((q t)) (=> (lt_bound0 q lu) (lt_bound0 q o1))))
+
+;; Ensures
+(assert (forall ((q t)) (=> (lt_bound0 q v2) (lt_bound0 q o1))))
+
+;; H
+(assert (= result (Inter v3 b3 qu1 bu1 o1)))
+
+;; Ensures
+(assert (ordered0 result))
+
+;; x
+(declare-fun x59 () Real)
+
+;; H
+(assert (mem0 x59 u2))
+
+;; H
+(assert (mem0 x59 v2))
+
+;; Goal inter'vc
+;; File "src_common/union.mlw", line 286, characters 8-13
+(assert
+ (not (mem0 x59 result)))
+
+(check-sat)
diff --git a/src_colibri2/tests/solve/dimacs/sat/dune.inc b/src_colibri2/tests/solve/dimacs/sat/dune.inc
index 5d40389aae1868d08563657cd4a2f3ce181d8f82..fc8c83dc543b19d02cc7b61cc3be879f5f7f6b23 100644
--- a/src_colibri2/tests/solve/dimacs/sat/dune.inc
+++ b/src_colibri2/tests/solve/dimacs/sat/dune.inc
@@ -1,33 +1,33 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:anomaly_agetooold.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:anomaly_agetooold.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:anomaly_agetooold.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:anomaly_agetooold2.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:anomaly_agetooold2.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:anomaly_agetooold2.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:assertion_fail.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:assertion_fail.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:assertion_fail.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:fuzzing1.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:fuzzing1.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:fuzzing1.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:fuzzing2.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:fuzzing2.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:fuzzing2.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:par8-1-c.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:par8-1-c.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:par8-1-c.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:pigeon-2.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:pigeon-2.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:pigeon-2.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:pigeon-3.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:pigeon-3.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:pigeon-3.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:pigeon-4.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:pigeon-4.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:pigeon-4.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:quinn.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:quinn.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:quinn.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:simple_v3_c2.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:simple_v3_c2.cnf})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:simple_v3_c2.cnf})))
diff --git a/src_colibri2/tests/solve/dimacs/unsat/dune.inc b/src_colibri2/tests/solve/dimacs/unsat/dune.inc
index 148c9a4ec88ff5c3b32f1ec773361a1d8ac10387..da2d93fa1f2ca854c6e6331cb9630b7380c2e764 100644
--- a/src_colibri2/tests/solve/dimacs/unsat/dune.inc
+++ b/src_colibri2/tests/solve/dimacs/unsat/dune.inc
@@ -1,18 +1,18 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:anomaly_agetooold.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:anomaly_agetooold.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:anomaly_agetooold.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:modus_ponens.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:modus_ponens.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:modus_ponens.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:pigeon-1.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:pigeon-1.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:pigeon-1.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:pigeon-2.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:pigeon-2.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:pigeon-2.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:pigeon-3.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:pigeon-3.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:pigeon-3.cnf})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:pigeon-4.cnf})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:pigeon-4.cnf})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:pigeon-4.cnf})))
diff --git a/src_colibri2/tests/solve/models/dune.inc b/src_colibri2/tests/solve/models/dune.inc
index 7b35329d06e34b17f8a94b92ffd2c693cfc8b257..0e2e72b0121a760a25b46721ab67f33c4a0435c9 100644
--- a/src_colibri2/tests/solve/models/dune.inc
+++ b/src_colibri2/tests/solve/models/dune.inc
@@ -1,4 +1,4 @@
-(rule (action (with-stdout-to abs_real.smt2.res (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 %{dep:abs_real.smt2}))))
+(rule (action (with-stdout-to abs_real.smt2.res (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 %{dep:abs_real.smt2}))))
(rule (alias runtest) (action (diff abs_real.smt2.oracle abs_real.smt2.res)))
-(rule (action (with-stdout-to get_value.smt2.res (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 %{dep:get_value.smt2}))))
+(rule (action (with-stdout-to get_value.smt2.res (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 %{dep:get_value.smt2}))))
(rule (alias runtest) (action (diff get_value.smt2.oracle get_value.smt2.res)))
diff --git a/src_colibri2/tests/solve/smt_adt/sat/dune.inc b/src_colibri2/tests/solve/smt_adt/sat/dune.inc
index 53f078718eca53ccc0c9ade8489e9a665c18b045..e92b98e60fdbb9ce4be340621581edf2a500418c 100644
--- a/src_colibri2/tests/solve/smt_adt/sat/dune.inc
+++ b/src_colibri2/tests/solve/smt_adt/sat/dune.inc
@@ -1,18 +1,18 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:enum.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:enum.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:enum.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:list0.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:list0.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:list0.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:list1.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:list1.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:list1.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:tree1.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:tree1.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:tree1.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:tree2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:tree2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:tree2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:tree3.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:tree3.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:tree3.smt2})))
diff --git a/src_colibri2/tests/solve/smt_adt/unsat/dune.inc b/src_colibri2/tests/solve/smt_adt/unsat/dune.inc
index f3f9ebb8725e8c2edf0ae69002dfc2fad92c9a4d..9390dce2577f855dff35f5b93a34177d70a697df 100644
--- a/src_colibri2/tests/solve/smt_adt/unsat/dune.inc
+++ b/src_colibri2/tests/solve/smt_adt/unsat/dune.inc
@@ -1,24 +1,24 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:enum.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:enum.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:enum.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:enum2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:enum2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:enum2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:list0.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:list0.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:list0.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:list1.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:list1.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:list1.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:list2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:list2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:list2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:list3.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:list3.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:list3.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:list4.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:list4.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:list4.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:parlist0.psmt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:parlist0.psmt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:parlist0.psmt2})))
diff --git a/src_colibri2/tests/solve/smt_fp/dune.inc b/src_colibri2/tests/solve/smt_fp/dune.inc
index 755fd7c18d1b59ad560a40cdd9ed2ab31af67723..db314f401427951c413aba483b5a8f3903d804b2 100644
--- a/src_colibri2/tests/solve/smt_fp/dune.inc
+++ b/src_colibri2/tests/solve/smt_fp/dune.inc
@@ -1,2 +1,2 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result %{dep:rm_universal.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result --learning %{dep:rm_universal.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result %{dep:rm_universal.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result --learning %{dep:rm_universal.smt2})))
diff --git a/src_colibri2/tests/solve/smt_fp/sat/dune.inc b/src_colibri2/tests/solve/smt_fp/sat/dune.inc
index cea27603ac70b52060d77c77333f6de8fe1d2ce2..2102d79009799a1e264db0b66c0510e0af3aa831 100644
--- a/src_colibri2/tests/solve/smt_fp/sat/dune.inc
+++ b/src_colibri2/tests/solve/smt_fp/sat/dune.inc
@@ -1,45 +1,45 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:exists_eq_not_fp_eq.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:exists_eq_not_fp_eq.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:exists_eq_not_fp_eq.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:inf_pos_neg_neq_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:inf_pos_neg_neq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:inf_pos_neg_neq_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:infm_eq_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:infm_eq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:infm_eq_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:infp_eq_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:infp_eq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:infp_eq_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:nan_neq_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:nan_neq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:nan_neq_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:recognize_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:recognize_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:recognize_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:recognize_rounding_mode.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:recognize_rounding_mode.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:recognize_rounding_mode.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:rm_instanciation.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:rm_instanciation.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:rm_instanciation.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:simple_add_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:simple_add_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:simple_add_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:simple_eq_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:simple_eq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:simple_eq_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:simple_mul_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:simple_mul_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:simple_mul_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:to_fp_eq_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:to_fp_eq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:to_fp_eq_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:zero_pos_neg_neq_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:zero_pos_neg_neq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:zero_pos_neg_neq_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:zerom_eq_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:zerom_eq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:zerom_eq_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:zerop_eq_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:zerop_eq_float32.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:zerop_eq_float32.smt2})))
diff --git a/src_colibri2/tests/solve/smt_fp/unsat/dune.inc b/src_colibri2/tests/solve/smt_fp/unsat/dune.inc
index 7e79bd0e4d2abc2828c55f16bf061474f3a71c43..84446c08b2146468454ca9d3be6233eed3f841c1 100644
--- a/src_colibri2/tests/solve/smt_fp/unsat/dune.inc
+++ b/src_colibri2/tests/solve/smt_fp/unsat/dune.inc
@@ -1,12 +1,12 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:eq_fp_eq.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:eq_fp_eq.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:eq_fp_eq.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:inf_pos_neg_neq.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:inf_pos_neg_neq.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:inf_pos_neg_neq.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:nan_neq_float32.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:nan_neq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:nan_neq_float32.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:propagate_le_ge.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:propagate_le_ge.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:propagate_le_ge.smt2})))
diff --git a/src_colibri2/tests/solve/smt_lra/sat/dune.inc b/src_colibri2/tests/solve/smt_lra/sat/dune.inc
index b7855698a5e71c020b300128ea800062e79f7f99..1527a3d5739f03c35ac62173033472e82c5b0d73 100644
--- a/src_colibri2/tests/solve/smt_lra/sat/dune.inc
+++ b/src_colibri2/tests/solve/smt_lra/sat/dune.inc
@@ -1,102 +1,102 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_CombiRepr_normalize.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_CombiRepr_normalize.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_CombiRepr_normalize.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_conflict_add_disequality.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_conflict_add_disequality.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_conflict_add_disequality.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_conpoly.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_conpoly.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_conpoly.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_decide_must_test_is_dis_equal.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_decide_must_test_is_dis_equal.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_decide_must_test_is_dis_equal.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_init_always_merge_itself.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_init_always_merge_itself.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_init_always_merge_itself.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_init_and_propa_must_be_ordered.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_init_and_propa_must_be_ordered.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_init_and_propa_must_be_ordered.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_merge_case1.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_case1.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_case1.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_merge_case_4.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_case_4.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_case_4.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_merge_case_4_bis.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_case_4_bis.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_case_4_bis.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_merge_itself_coef_of_repr_is_one.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_itself_coef_of_repr_is_one.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_itself_coef_of_repr_is_one.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_merge_itself_last_case.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_itself_last_case.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_itself_last_case.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_merge_itself_pivot_not_in_p12.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_itself_pivot_not_in_p12.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_itself_pivot_not_in_p12.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_merge_must_use_find.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_must_use_find.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_merge_must_use_find.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_mult_explication.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_mult_explication.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_mult_explication.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_mult_not_linear_in_conflict.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_mult_not_linear_in_conflict.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_mult_not_linear_in_conflict.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_normalize_use_find_def.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_normalize_use_find_def.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_normalize_use_find_def.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_own_repr.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_own_repr.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_own_repr.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_propacl.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_propacl.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_propacl.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_subst_and_conflict_add.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_subst_and_conflict_add.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_subst_and_conflict_add.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:arith_zero_dom.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_zero_dom.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:arith_zero_dom.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:attach_only_when_dom_present.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:attach_only_when_dom_present.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:attach_only_when_dom_present.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:init_not_repr.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:init_not_repr.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:init_not_repr.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:le.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:le.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:le.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:le2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:le2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:le2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:mul.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:mul.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:mul.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:sem_invariant_in_learnt_dec.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:sem_invariant_in_learnt_dec.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:sem_invariant_in_learnt_dec.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:solver_add_pexp_cl.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:solver_add_pexp_cl.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:solver_add_pexp_cl.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:solver_arith_homogeneous_dist_sign.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:solver_arith_homogeneous_dist_sign.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:solver_arith_homogeneous_dist_sign.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:solver_merge_itself_repr_inside.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:solver_merge_itself_repr_inside.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:solver_merge_itself_repr_inside.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:solver_set_pending_merge_expsameexp.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:solver_set_pending_merge_expsameexp.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:solver_set_pending_merge_expsameexp.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:solver_subst_eventdom_find.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:solver_subst_eventdom_find.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:solver_subst_eventdom_find.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:to_real.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:to_real.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:to_real.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:to_real2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:to_real2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:to_real2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:zero_should_not_be_simplified.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:zero_should_not_be_simplified.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:zero_should_not_be_simplified.smt2})))
diff --git a/src_colibri2/tests/solve/smt_lra/unsat/dune.inc b/src_colibri2/tests/solve/smt_lra/unsat/dune.inc
index 35fe81049402a61edd9e131d0ecd5e8abadfb549..4f683c3c6cf46f32d94e8ac0ac81a50d90655677 100644
--- a/src_colibri2/tests/solve/smt_lra/unsat/dune.inc
+++ b/src_colibri2/tests/solve/smt_lra/unsat/dune.inc
@@ -1,33 +1,33 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:arith_ExpMult_by_zero.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:arith_ExpMult_by_zero.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:arith_ExpMult_by_zero.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:arith_merge_case2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:arith_merge_case2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:arith_merge_case2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:le.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:le.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:le.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:le2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:le2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:le2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:mul.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:repr_and_poly.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:repr_and_poly.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:repr_and_poly.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:repr_fourier.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:repr_fourier.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:repr_fourier.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:solver_merge_itself_repr_empty.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:solver_merge_itself_repr_empty.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:solver_merge_itself_repr_empty.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:solver_set_sem_merge_sign.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:solver_set_sem_merge_sign.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:solver_set_sem_merge_sign.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:to_real.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:to_real.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:to_real.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:to_real2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:to_real2.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:to_real2.smt2})))
diff --git a/src_colibri2/tests/solve/smt_nra/sat/dune.inc b/src_colibri2/tests/solve/smt_nra/sat/dune.inc
index c2bb7f7b087bbcd64ea93469ee8989a82e93324b..56338fdbb45f8c26cdb548bca33fc947def3b9fc 100644
--- a/src_colibri2/tests/solve/smt_nra/sat/dune.inc
+++ b/src_colibri2/tests/solve/smt_nra/sat/dune.inc
@@ -1,21 +1,21 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:ceil.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:ceil.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:ceil.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:div_pos.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:div_pos.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:div_pos.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:div_pos_lt.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:div_pos_lt.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:div_pos_lt.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:mul_commut.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:mul_commut.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:mul_commut.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:mul_commut2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:mul_commut2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:mul_commut2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:mul_pos.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:mul_pos.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:mul_pos.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:mul_pos_lt.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:mul_pos_lt.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:mul_pos_lt.smt2})))
diff --git a/src_colibri2/tests/solve/smt_nra/unsat/dune.inc b/src_colibri2/tests/solve/smt_nra/unsat/dune.inc
index 02cd7cc165673b25a7a3506d2acf5520d9a59b3a..80285e3ef02e5a30c1320a21099c4105ece7c2d4 100644
--- a/src_colibri2/tests/solve/smt_nra/unsat/dune.inc
+++ b/src_colibri2/tests/solve/smt_nra/unsat/dune.inc
@@ -1,30 +1,30 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:ceil.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:ceil.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:ceil.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:div_pos.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:div_pos.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:div_pos.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:div_pos_lt.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:div_pos_lt.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:div_pos_lt.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:div_pos_lt_to_real.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:div_pos_lt_to_real.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:div_pos_lt_to_real.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:floor.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:floor.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:floor.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:mul_commut.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_commut.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_commut.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:mul_commut2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_commut2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_commut2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:mul_pos.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_pos.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_pos.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:mul_pos_lt.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_pos_lt.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_pos_lt.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:mul_pos_zero_le.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_pos_zero_le.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mul_pos_zero_le.smt2})))
diff --git a/src_colibri2/tests/solve/smt_quant/dune.inc b/src_colibri2/tests/solve/smt_quant/dune.inc
index 6d35d86dc60cd0c0419c3e722b69bcfb9842336c..064a16c22fcc9177f85e52d74d049028f5b3cfcd 100644
--- a/src_colibri2/tests/solve/smt_quant/dune.inc
+++ b/src_colibri2/tests/solve/smt_quant/dune.inc
@@ -1,8 +1,8 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result %{dep:forall0.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result --learning %{dep:forall0.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result %{dep:forall3.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result --learning %{dep:forall3.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result %{dep:forall4.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result --learning %{dep:forall4.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result %{dep:multitrigger.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result --learning %{dep:multitrigger.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result %{dep:forall0.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result --learning %{dep:forall0.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result %{dep:forall3.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result --learning %{dep:forall3.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result %{dep:forall4.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result --learning %{dep:forall4.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result %{dep:multitrigger.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 --dont-print-result --learning %{dep:multitrigger.smt2})))
diff --git a/src_colibri2/tests/solve/smt_quant/sat/dune.inc b/src_colibri2/tests/solve/smt_quant/sat/dune.inc
index 82ec2986da343c3b2354fdf4f9980161812d461b..f71fd565f12784a6b5b391d0879cbb8052a5307a 100644
--- a/src_colibri2/tests/solve/smt_quant/sat/dune.inc
+++ b/src_colibri2/tests/solve/smt_quant/sat/dune.inc
@@ -1,3 +1,3 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:exists.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:exists.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:exists.smt2})))
diff --git a/src_colibri2/tests/solve/smt_quant/unsat/dune.inc b/src_colibri2/tests/solve/smt_quant/unsat/dune.inc
index 3ca854bdf577fd786339cf4c24edd0ec0c1ee40f..af3b030e00fc3b2e509f1dd4992fd11b00f9c801 100644
--- a/src_colibri2/tests/solve/smt_quant/unsat/dune.inc
+++ b/src_colibri2/tests/solve/smt_quant/unsat/dune.inc
@@ -1,33 +1,33 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:exists.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:exists.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:exists.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:exists2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:exists2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:exists2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:forall0.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall0.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall0.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:forall1.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall1.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall1.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:forall2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:forall3.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall3.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall3.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:forall4.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall4.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall4.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:forall5.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall5.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall5.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:forall6.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall6.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall6.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:forall7.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall7.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall7.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:forall8.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall8.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:forall8.smt2})))
diff --git a/src_colibri2/tests/solve/smt_uf/sat/dune.inc b/src_colibri2/tests/solve/smt_uf/sat/dune.inc
index e39fff7d19c008c68e39859cf93914c86f524624..c67d488f0d33e2e5822add2822283e6fccab057c 100644
--- a/src_colibri2/tests/solve/smt_uf/sat/dune.inc
+++ b/src_colibri2/tests/solve/smt_uf/sat/dune.inc
@@ -1,63 +1,63 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:bad_conflict.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:bad_conflict.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:bad_conflict.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:bcp_dont_like_duplicate.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:bcp_dont_like_duplicate.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:bcp_dont_like_duplicate.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:bool_not_propa.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:bool_not_propa.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:bool_not_propa.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:boolexpup.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:boolexpup.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:boolexpup.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:clause_normalization.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:clause_normalization.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:clause_normalization.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:clmerge.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:clmerge.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:clmerge.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:conflict_complete_needed_cl.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:conflict_complete_needed_cl.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:conflict_complete_needed_cl.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:directdom_not.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:directdom_not.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:directdom_not.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:dis_dom_before_first_age.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:dis_dom_before_first_age.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:dis_dom_before_first_age.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:dom_merge_equality.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:dom_merge_equality.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:dom_merge_equality.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:equality.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:equality.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:equality.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:equality_condis.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:equality_condis.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:equality_condis.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:equality_get_sem.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:equality_get_sem.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:equality_get_sem.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:exp_sem_equality.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:exp_sem_equality.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:exp_sem_equality.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:explimit_cl_equality.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:explimit_cl_equality.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:explimit_cl_equality.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:implication.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:implication.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:implication.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:intmap_set_disjoint.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:intmap_set_disjoint.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:intmap_set_disjoint.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:is_equal_not_propagated.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:is_equal_not_propagated.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:is_equal_not_propagated.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:ite_sem_bool.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:ite_sem_bool.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:ite_sem_bool.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:polyeq_genequality.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:polyeq_genequality.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:polyeq_genequality.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat
--dont-print-result %{dep:substupfalse_equality.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:substupfalse_equality.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat --learning --dont-print-result %{dep:substupfalse_equality.smt2})))
diff --git a/src_colibri2/tests/solve/smt_uf/unsat/dune.inc b/src_colibri2/tests/solve/smt_uf/unsat/dune.inc
index 941a3d34d0c5e8e910af801db33e7f04871a36f8..85a1faaf196b1809fc8cc16127a53d9cda625424 100644
--- a/src_colibri2/tests/solve/smt_uf/unsat/dune.inc
+++ b/src_colibri2/tests/solve/smt_uf/unsat/dune.inc
@@ -1,39 +1,39 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:NEQ004_size4__decide_eq_us.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:NEQ004_size4__decide_eq_us.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:NEQ004_size4__decide_eq_us.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:deltaed0.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:deltaed0.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:deltaed0.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:diff_to_value_for_bool.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:diff_to_value_for_bool.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:diff_to_value_for_bool.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:diff_value_substupfalse.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:diff_value_substupfalse.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:diff_value_substupfalse.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:distinct.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:distinct.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:distinct.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:eq_diamond2.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:eq_diamond2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:eq_diamond2.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:equality_norm_set.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:equality_norm_set.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:equality_norm_set.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:fundef.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:fundef.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:fundef.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:get_repr_at__instead_of__equal_CRepr.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:get_repr_at__instead_of__equal_CRepr.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:get_repr_at__instead_of__equal_CRepr.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:many_distinct.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:many_distinct.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:many_distinct.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:polyeq_genequality.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:polyeq_genequality.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:polyeq_genequality.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:polyeq_genequality_deltaed.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:polyeq_genequality_deltaed.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:polyeq_genequality_deltaed.smt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat
--dont-print-result %{dep:xor.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:xor.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:xor.smt2})))
diff --git a/src_colibri2/tests/tests_LRA.ml b/src_colibri2/tests/tests_LRA.ml
index 61f2a60cece3d8958c4df5403dbef45249833b8a..957dfff4bf374fa168a73f0ef0020468cbe9d818 100644
--- a/src_colibri2/tests/tests_LRA.ml
+++ b/src_colibri2/tests/tests_LRA.ml
@@ -27,12 +27,19 @@ open Colibri2_core
open Colibri2_stdlib.Std
open Colibri2_stdlib
-let theories = [Boolean.th_register; Equality.th_register;
- Colibri2_theories_quantifiers.Uninterp.th_register; LRA.th_register]
+let theories =
+ [
+ Boolean.th_register;
+ Equality.th_register;
+ Colibri2_theories_quantifiers.Uninterp.th_register;
+ LRA.th_register;
+ ]
-let run = Scheduler.run_exn ~limit:3000 ~nodec:() ~theories
-let run_dec = Scheduler.run_exn ~limit:3000 ?nodec:None ~theories
-let ($$) f x = f x
+let run f = Scheduler.run_exn ~limit:3000 ~nodec:() ~theories f
+
+let run_dec f = Scheduler.run_exn ~limit:3000 ?nodec:None ~theories f
+
+let ( $$ ) f x = f x
(* The tests with rundec check only the result on a model satisfying
the hypothesis *)
@@ -40,210 +47,193 @@ let ($$) f x = f x
open Expr
let solve0a _ =
- let a = fresh Ty.real "ar" in
+ run @@ fun env ->
+ let a = fresh env Ty.real "ar" in
let _1 = LRA.RealValue.cst Q.one in
- let a1 = LRA.add a _1 in
- let env = run $$ fun env ->
- register env a1; register env _1;
- merge env a1 _1
- in
- assert_bool "a+1 = 1 => a = 0" (is_equal env a LRA.RealValue.zero)
+ let a1 = LRA.add env a _1 in
+ register env a1;
+ register env _1;
+ merge env a1 _1;
+ fun env -> assert_bool "a+1 = 1 => a = 0" (is_equal env a LRA.RealValue.zero)
let solve0b _ =
- let a = fresh Ty.real "ar" in
+ run @@ fun env ->
+ let a = fresh env Ty.real "ar" in
let _1 = LRA.RealValue.cst Q.one in
let _2 = LRA.RealValue.cst Q.two in
let _4 = LRA.RealValue.cst (Q.of_int 4) in
- let a1 = LRA.add a _1 in
- let _2a2 = LRA.add' Q.two a Q.one _2 in
- let env = run $$ fun env ->
- List.iter (register env) [a1;_1;_2;_4;_2a2];
- merge env a1 _2
- in
- assert_bool "a+1 = 2 => 2*a+2 = 4" (is_equal env _2a2 _4)
+ let a1 = LRA.add env a _1 in
+ let _2a2 = LRA.add' env Q.two a Q.one _2 in
+ List.iter (register env) [ a1; _1; _2; _4; _2a2 ];
+ merge env a1 _2;
+ fun env -> assert_bool "a+1 = 2 => 2*a+2 = 4" (is_equal env _2a2 _4)
let solve0c _ =
- let a = fresh Ty.real "ar" in
- let b = fresh Ty.real "br" in
+ run @@ fun env ->
+ let a = fresh env Ty.real "ar" in
+ let b = fresh env Ty.real "br" in
let _1 = LRA.RealValue.cst Q.one in
- let a1 = LRA.add a _1 in
- let b1 = LRA.add b _1 in
- let env = run_dec $$ fun env ->
- register env a1; register env b1;
- merge env a1 b1
- in
- assert_bool "a+1 = b+1 => a = b" (is_equal env a b)
+ let a1 = LRA.add env a _1 in
+ let b1 = LRA.add env b _1 in
+ register env a1;
+ register env b1;
+ merge env a1 b1;
+ fun env -> assert_bool "a+1 = b+1 => a = b" (is_equal env a b)
let solve1 _ =
- let a,b = Shuffle.seq2 (fresh Ty.real) ("ar","br") in
+ run @@ fun env ->
+ let a, b = Shuffle.seq2 (fresh env Ty.real) ("ar", "br") in
let _1 = LRA.RealValue.cst Q.one in
- let a1 = LRA.add a _1 in
- let b1 = LRA.add b _1 in
+ let a1 = LRA.add env a _1 in
+ let b1 = LRA.add env b _1 in
let _2 = LRA.RealValue.cst (Q.of_int 2) in
- let a2 = LRA.add a _2 in
- let b2 = LRA.add b _2 in
- let env = run_dec $$ fun env ->
- Shuffle.seql' (register env) [a1; b1; a2; b2];
- merge env a1 b1
- in
- assert_bool "a+1 = b+1 => a+2 = b+2" (is_equal env a2 b2)
+ let a2 = LRA.add env a _2 in
+ let b2 = LRA.add env b _2 in
+ Shuffle.seql' (register env) [ a1; b1; a2; b2 ];
+ merge env a1 b1;
+ fun env -> assert_bool "a+1 = b+1 => a+2 = b+2" (is_equal env a2 b2)
let solve2 _ =
- let a,b = Shuffle.seq2 (fresh Ty.real) ("ar","br") in
+ run @@ fun env ->
+ let a, b = Shuffle.seq2 (fresh env Ty.real) ("ar", "br") in
let _1 = LRA.RealValue.cst Q.one in
- let a1 = LRA.add a _1 in
- let b1 = LRA.add b _1 in
+ let a1 = LRA.add env a _1 in
+ let b1 = LRA.add env b _1 in
let _2 = LRA.RealValue.cst (Q.of_int 2) in
- let a2 = LRA.add a _2 in
- let b2 = LRA.add b _2 in
- let env = run_dec $$ fun env ->
- Shuffle.seql' (register env) [a1; b1; a2; b2];
- merge env a2 b1
- in
- assert_bool "a+2 = b+1 => a+1 = b" (is_equal env a1 b)
+ let a2 = LRA.add env a _2 in
+ let b2 = LRA.add env b _2 in
+ Shuffle.seql' (register env) [ a1; b1; a2; b2 ];
+ merge env a2 b1;
+ fun env -> assert_bool "a+2 = b+1 => a+1 = b" (is_equal env a1 b)
let solve3 _ =
- let a,b = Shuffle.seq2 (fresh Ty.real) ("ar","br") in
+ run @@ fun env ->
+ let a, b = Shuffle.seq2 (fresh env Ty.real) ("ar", "br") in
let _1 = LRA.RealValue.cst Q.one in
- let b1 = LRA.add b _1 in
+ let b1 = LRA.add env b _1 in
let _2 = LRA.RealValue.cst (Q.of_int 2) in
- let a2 = LRA.add a _2 in
+ let a2 = LRA.add env a _2 in
let _3 = LRA.RealValue.cst (Q.of_int 3) in
- let env = run $$ fun env ->
- Shuffle.seql [
- (fun () ->
- Shuffle.seql' (register env) [b1;a2];
- merge env a2 b1;
- );
- (fun () ->
- Shuffle.seql' (register env) [a;_2];
- merge env a _2;
- );
- (fun () ->
- register env _3;
- );
- ]
- in
- assert_bool "" (not (is_equal env b _2));
- assert_bool "a+2 = b+1 => a = 2 => b = 3" (is_equal env b _3)
-
+ Shuffle.seql
+ [
+ (fun () ->
+ Shuffle.seql' (register env) [ b1; a2 ];
+ merge env a2 b1);
+ (fun () ->
+ Shuffle.seql' (register env) [ a; _2 ];
+ merge env a _2);
+ (fun () -> register env _3);
+ ];
+ fun env ->
+ assert_bool "" (not (is_equal env b _2));
+ assert_bool "a+2 = b+1 => a = 2 => b = 3" (is_equal env b _3)
let solve4 _ =
- let a,b,c =
- Shuffle.seq3 (fresh Ty.real) ("ar","br","cr") in
+ run @@ fun env ->
+ let a, b, c = Shuffle.seq3 (fresh env Ty.real) ("ar", "br", "cr") in
let t1 = LRA.RealValue.cst (Q.of_int 2) in
- let t1 = LRA.add t1 c in
- let t1 = LRA.add a t1 in
- let t1' = (LRA.RealValue.cst (Q.of_int 1)) in
- let t1' = LRA.add b t1' in
- let t2 = a in
+ let t1 = LRA.add env t1 c in
+ let t1 = LRA.add env a t1 in
+ let t1' = LRA.RealValue.cst (Q.of_int 1) in
+ let t1' = LRA.add env b t1' in
+ let t2 = a in
let t2' = LRA.RealValue.cst (Q.of_int 2) in
- let t2' = LRA.add t2' b in
+ let t2' = LRA.add env t2' b in
let t3' = LRA.RealValue.cst (Q.of_int (-3)) in
- let env = run_dec $$ fun env ->
- Shuffle.seql [
- (fun () ->
- Shuffle.seql' (register env) [t1;t1'];
- merge env t1 t1');
- (fun () ->
- Shuffle.seql' (register env) [t2;t2'];
- merge env t2 t2');
- (fun () -> register env t3');
- ]
- in
- assert_bool "a+(2+c) = b+1 => a = 2 + b => c = -3" (is_equal env c t3')
-
+ Shuffle.seql
+ [
+ (fun () ->
+ Shuffle.seql' (register env) [ t1; t1' ];
+ merge env t1 t1');
+ (fun () ->
+ Shuffle.seql' (register env) [ t2; t2' ];
+ merge env t2 t2');
+ (fun () -> register env t3');
+ ];
+ fun env ->
+ assert_bool "a+(2+c) = b+1 => a = 2 + b => c = -3" (is_equal env c t3')
let solve5 _ =
- let a = fresh Ty.real "ar" in
- let b = fresh Ty.real "br" in
- let c = fresh Ty.real "cr" in
- let t1 = LRA.sub b c in
- let t1 = LRA.add a t1 in
- let t1' = (LRA.RealValue.cst (Q.of_int 2)) in
- let t2 = a in
+ run @@ fun env ->
+ let a = fresh env Ty.real "ar" in
+ let b = fresh env Ty.real "br" in
+ let c = fresh env Ty.real "cr" in
+ let t1 = LRA.sub env b c in
+ let t1 = LRA.add env a t1 in
+ let t1' = LRA.RealValue.cst (Q.of_int 2) in
+ let t2 = a in
let t2' = LRA.RealValue.cst (Q.of_int 2) in
- let t3 = LRA.add b c in
- let t3' = LRA.add b b in
- let env = run_dec $$ fun env ->
- Shuffle.seql [
- (fun () ->
- Shuffle.seql' (register env) [t1;t1'];
- merge env t1 t1');
- (fun () ->
- Shuffle.seql' (register env) [t2;t2'];
- merge env t2 t2');
- (fun () ->
- Shuffle.seql' (register env) [t3;t3'];)
- ]
- in
- assert_bool "a+(b-c) = 2 => a = 2 => b + c = b + b" (is_equal env t3 t3')
-
-
-let basic = "LRA.Basic" &:
- [solve0a;
- (* solve0b; *)
- solve0c;
- solve1;
- solve2;
- solve3;
- solve4;
- solve5
- ]
+ let t3 = LRA.add env b c in
+ let t3' = LRA.add env b b in
+ Shuffle.seql
+ [
+ (fun () ->
+ Shuffle.seql' (register env) [ t1; t1' ];
+ merge env t1 t1');
+ (fun () ->
+ Shuffle.seql' (register env) [ t2; t2' ];
+ merge env t2 t2');
+ (fun () -> Shuffle.seql' (register env) [ t3; t3' ]);
+ ];
+ fun env ->
+ assert_bool "a+(b-c) = 2 => a = 2 => b + c = b + b" (is_equal env t3 t3')
+
+let basic =
+ "LRA.Basic"
+ &: [ solve0a; (* solve0b; *) solve0c; solve1; solve2; solve3; solve4; solve5 ]
let mult0 _ =
- let a = fresh Ty.real "ar" in
- let b = fresh Ty.real "br" in
- let t1 = LRA.sub a b in
- let t1' = LRA.mult a b in
- let t2 = a in
+ run @@ fun env ->
+ let a = fresh env Ty.real "ar" in
+ let b = fresh env Ty.real "br" in
+ let t1 = LRA.sub env a b in
+ let t1' = LRA.mult env a b in
+ let t2 = a in
let t2' = LRA.RealValue.cst (Q.of_int 1) in
- let t3 = LRA.mult_cst (Q.of_int 2) b in
+ let t3 = LRA.mult_cst env (Q.of_int 2) b in
let t3' = LRA.RealValue.cst (Q.of_int 1) in
- let env = run $$ fun env ->
- Shuffle.seql [
- (fun () ->
- Shuffle.seql' (register env) [t1;t1'];
- merge env t1 t1');
- (fun () ->
- Shuffle.seql' (register env) [t2;t2'];
- merge env t2 t2');
- (fun () ->
- Shuffle.seql' (register env) [t3;t3'];)
- ]
- in
- assert_bool "a - b = a * b -> a = 1 -> 1 = 2b" (is_equal env t3 t3')
+ Shuffle.seql
+ [
+ (fun () ->
+ Shuffle.seql' (register env) [ t1; t1' ];
+ merge env t1 t1');
+ (fun () ->
+ Shuffle.seql' (register env) [ t2; t2' ];
+ merge env t2 t2');
+ (fun () -> Shuffle.seql' (register env) [ t3; t3' ]);
+ ];
+ fun env ->
+ assert_bool "a - b = a * b -> a = 1 -> 1 = 2b" (is_equal env t3 t3')
(** test that mult normalization trigger the needed solve *)
let mult1 _ =
- let a = fresh Ty.real "ar" in
- let b = fresh Ty.real "br" in
- let c = fresh Ty.real "cr" in
- let t1 = LRA.mult a b in
- let t1 = LRA.add a t1 in
- let t1' = LRA.add b c in
- let t1' = LRA.mult t1' a in
- let t2 = a in
+ run @@ fun env ->
+ let a = fresh env Ty.real "ar" in
+ let b = fresh env Ty.real "br" in
+ let c = fresh env Ty.real "cr" in
+ let t1 = LRA.mult env a b in
+ let t1 = LRA.add env a t1 in
+ let t1' = LRA.add env b c in
+ let t1' = LRA.mult env t1' a in
+ let t2 = a in
let t2' = LRA.RealValue.cst (Q.of_int 2) in
let t3 = c in
let t3' = LRA.RealValue.cst (Q.of_int 1) in
- let env = run $$ fun env ->
- Shuffle.seql [
- (fun () ->
- Shuffle.seql' (register env) [t1;t1'];
- merge env t1 t1');
- (fun () ->
- Shuffle.seql' (register env) [t2;t2'];
- merge env t2 t2');
- (fun () ->
- Shuffle.seql' (register env) [t3;t3'];)
- ]
- in
- assert_bool "a + (a * b) = (b + c) * a -> a = 2 -> c = 1"
- (is_equal env t3 t3')
-
-let mult = "LRA.Mult" &: [mult0;mult1]
-
+ Shuffle.seql
+ [
+ (fun () ->
+ Shuffle.seql' (register env) [ t1; t1' ];
+ merge env t1 t1');
+ (fun () ->
+ Shuffle.seql' (register env) [ t2; t2' ];
+ merge env t2 t2');
+ (fun () -> Shuffle.seql' (register env) [ t3; t3' ]);
+ ];
+ fun env ->
+ assert_bool "a + (a * b) = (b + c) * a -> a = 2 -> c = 1"
+ (is_equal env t3 t3')
+
+let mult = "LRA.Mult" &: [ mult0; mult1 ]
(* let files = ["tests/tests_altergo_arith.split";
* "tests/tests_popop.split";
@@ -252,4 +242,11 @@ let mult = "LRA.Mult" &: [mult0;mult1]
*
* let altergo = TestList (List.map Tests_lib.test_split files) *)
-let tests = test_list [basic;mult; (* altergo;*) (* smtlib2sat; smtlib2unsat *)]
+let tests =
+ test_list
+ [
+ basic;
+ mult
+ (* altergo;*)
+ (* smtlib2sat; smtlib2unsat *);
+ ]
diff --git a/src_colibri2/tests/tests_bool.ml b/src_colibri2/tests/tests_bool.ml
index 6be56a2d5fda3dcea9bb95b9393ddec74e3939d2..e172b317dd9c24099075b9ed9698762685e0ec6c 100644
--- a/src_colibri2/tests/tests_bool.ml
+++ b/src_colibri2/tests/tests_bool.ml
@@ -24,13 +24,15 @@ open Colibri2_core
open Tests_lib
open Colibri2_theories_bool
-let theories = [Colibri2_theories_quantifiers.Uninterp.th_register; Boolean.th_register]
+let theories =
+ [ Colibri2_theories_quantifiers.Uninterp.th_register; Boolean.th_register ]
-let ($$) f x = f x
+let ( $$ ) f x = f x
-let run = Tests_lib.run_exn ~theories
+let run f = Tests_lib.run_exn ~theories f
open Expr
+
(*
let bool_interp _ =
let ta = fresht Ty.bool "a" in
@@ -67,71 +69,75 @@ let bool_interp _ =
List.iter test l
*)
let true_is_true _ =
- let env = run (fun _ -> ()) in
- assert_bool "" (Boolean.is_true env Boolean._true);
- assert_bool "" (not (Boolean.is_false env Boolean._true))
+ run (fun _ env ->
+ assert_bool "" (Boolean.is_true env Boolean._true);
+ assert_bool "" (not (Boolean.is_false env Boolean._true)))
let not_true_is_false _ =
- let not_true = Boolean._not Boolean._true in
- let env = run $$ fun env -> Egraph.register env not_true in
- assert_bool "" (Boolean.is_false env not_true);
- assert_bool "" (not (Boolean.is_true env not_true))
+ run (fun env ->
+ let not_true = Boolean._not env Boolean._true in
+ Egraph.register env not_true;
+ fun env ->
+ assert_bool "" (Boolean.is_false env not_true);
+ assert_bool "" (not (Boolean.is_true env not_true)))
let and_true_is_true _ =
- let _t = Boolean._true in
- let _and = Boolean._and [_t;_t;_t] in
- let env = run $$ fun env -> Egraph.register env _and in
- assert_bool "" (Boolean.is_true env _and);
- assert_bool "" (not (Boolean.is_false env _and))
+ run (fun env ->
+ let _t = Boolean._true in
+ let _and = Boolean._and env [ _t; _t; _t ] in
+ Egraph.register env _and;
+ fun env ->
+ assert_bool "" (Boolean.is_true env _and);
+ assert_bool "" (not (Boolean.is_false env _and)))
let or_not_true_is_false _ =
- let _f = (Boolean._not Boolean._true) in
- let _or = Boolean._and [_f;_f;_f] in
- let env = run $$ fun env -> Egraph.register env _or in
- assert_bool "" (Boolean.is_false env _or);
- assert_bool "" (not (Boolean.is_true env _or))
+ run (fun env ->
+ let _f = Boolean._not env Boolean._true in
+ let _or = Boolean._and env [ _f; _f; _f ] in
+ Egraph.register env _or;
+ fun env ->
+ assert_bool "" (Boolean.is_false env _or);
+ assert_bool "" (not (Boolean.is_true env _or)))
let merge_true _ =
- let a = fresh Ty.bool "a" in
- let b = fresh Ty.bool "b" in
- let c = fresh Ty.bool "c" in
- let d = fresh Ty.bool "d" in
- let _and = Boolean._and [a;b;c] in
- let env = run $$ fun env ->
- Egraph.register env _and;
- List.iter (Egraph.register env) [a;b;c;d];
- Shuffle.seql
- [(fun () -> merge env a b);
- (fun () -> merge env a c);
- ];
- merge env a d;
- Boolean.set_true env d;
- in
- assert_bool "" (Boolean.is_true env _and)
+ run @@ fun env ->
+ let a = fresh env Ty.bool "a" in
+ let b = fresh env Ty.bool "b" in
+ let c = fresh env Ty.bool "c" in
+ let d = fresh env Ty.bool "d" in
+ let _and = Boolean._and env [ a; b; c ] in
+
+ Egraph.register env _and;
+ List.iter (Egraph.register env) [ a; b; c; d ];
+ Shuffle.seql [ (fun () -> merge env a b); (fun () -> merge env a c) ];
+ merge env a d;
+ Boolean.set_true env d;
+ fun env -> assert_bool "" (Boolean.is_true env _and)
let imply_implies _ =
+ run @@ fun env ->
let a = fresht Ty.bool "a" in
let b = fresht Ty.bool "b" in
let t = Term.imply a b in
- let an = Ground.convert a in
- let bn = Ground.convert b in
- let tn = Ground.convert t in
- let env = run $$ fun env ->
- Egraph.register env tn;
- Boolean.set_true env tn;
- Egraph.register env an;
- Boolean.set_true env an;
- in
- assert_bool "" (Boolean.is_true env bn)
+ let an = Ground.convert env a in
+ let bn = Ground.convert env b in
+ let tn = Ground.convert env t in
+ Egraph.register env tn;
+ Boolean.set_true env tn;
+ Egraph.register env an;
+ Boolean.set_true env an;
+ fun env -> assert_bool "" (Boolean.is_true env bn)
-let basic = "Boolean.Basic" >::: [ (* "bool_interp" >:: bool_interp; *)
- "true_is_true" >:: true_is_true;
- "not_true_is_false" >:: not_true_is_false;
- "and_true_is_true" >:: and_true_is_true;
- "or_not_true_is_false" >:: or_not_true_is_false;
- "merge_true" >:: merge_true;
- "imply_implies" >:: imply_implies;
- (* "modus_ponens" >:: modus_ponens; *)
- ]
+let basic =
+ "Boolean.Basic"
+ >::: [
+ (* "bool_interp" >:: bool_interp; *) "true_is_true" >:: true_is_true;
+ "not_true_is_false" >:: not_true_is_false;
+ "and_true_is_true" >:: and_true_is_true;
+ "or_not_true_is_false" >:: or_not_true_is_false;
+ "merge_true" >:: merge_true;
+ "imply_implies" >:: imply_implies
+ (* "modus_ponens" >:: modus_ponens; *);
+ ]
-let tests = test_list [basic]
+let tests = test_list [ basic ]
diff --git a/src_colibri2/tests/tests_fp.ml b/src_colibri2/tests/tests_fp.ml
index 1c5c0a907056409c60f8e6e2aea3c4a1a747e8b3..3dc6f9b673f9978c0fd52592f52bee3904dc65b8 100644
--- a/src_colibri2/tests/tests_fp.ml
+++ b/src_colibri2/tests/tests_fp.ml
@@ -22,45 +22,43 @@ open OUnit2
open Colibri2_core
open Tests_lib
open Colibri2_solver
-
open Colibri2_theories_bool
open Colibri2_theories_fp
let theories = [ Boolean.th_register; Equality.th_register; Fp.th_register ]
-let ($$) f x = f x
+let ( $$ ) f x = f x
-let run = Scheduler.run_exn ~limit:3000 ~nodec:() ~theories
+let run f = Scheduler.run_exn ~limit:3000 ~nodec:() ~theories f
let recognize_float32 _ =
+ run @@ fun env ->
let a = fresht (Expr.Ty.float 8 24) "a" in
let b = fresht (Expr.Ty.float 8 24) "b" in
let t = Expr.Term.eq a b in
- let an = Ground.convert a in
- let bn = Ground.convert b in
- let tn = Ground.convert t in
- let env = run $$ fun env ->
- Egraph.register env an;
- Egraph.register env bn;
- Egraph.register env tn;
- Boolean.set_true env tn;
- in
- assert_bool "a = b" (is_equal env an bn)
+ let an = Ground.convert env a in
+ let bn = Ground.convert env b in
+ let tn = Ground.convert env t in
+ Egraph.register env an;
+ Egraph.register env bn;
+ Egraph.register env tn;
+ Boolean.set_true env tn;
+ fun env -> assert_bool "a = b" (is_equal env an bn)
let recognize_float64 _ =
+ run @@ fun env ->
let a = fresht (Expr.Ty.float 11 53) "a" in
let b = fresht (Expr.Ty.float 11 53) "b" in
let t = Expr.Term.eq a b in
- let an = Ground.convert a in
- let bn = Ground.convert b in
- let tn = Ground.convert t in
- let env = run $$ fun env ->
- Egraph.register env an;
- Egraph.register env bn;
- Egraph.register env tn;
- Boolean.set_true env tn;
- in
- assert_bool "a = b" (is_equal env an bn)
+ let an = Ground.convert env a in
+ let bn = Ground.convert env b in
+ let tn = Ground.convert env t in
+ Egraph.register env an;
+ Egraph.register env bn;
+ Egraph.register env tn;
+ Boolean.set_true env tn;
+ fun env -> assert_bool "a = b" (is_equal env an bn)
+
let basic = "FP.Basic" &: [ recognize_float32; recognize_float64 ]
-let tests = test_list [basic]
+let tests = test_list [ basic ]
diff --git a/src_colibri2/tests/tests_lib.ml b/src_colibri2/tests/tests_lib.ml
index cbc395a26e5f7ce67a3bdb914f5db69d0ca8b6f2..4e2cccfd7d152139fb988a90b848ff502e6eb75c 100644
--- a/src_colibri2/tests/tests_lib.ml
+++ b/src_colibri2/tests/tests_lib.ml
@@ -21,13 +21,18 @@
open OUnit2
open Colibri2_core
-let debug = Debug.register_flag
- ~desc:" Run the test in verbose mode." "ounit"
+let debug = Debug.register_flag ~desc:" Run the test in verbose mode." "ounit"
-let fresht ty s = Expr.Term.apply_cst (Expr.Term.Const.mk (Dolmen_std.Path.global s) ty) [] []
-let fresh ty s = Ground.convert (Expr.Term.apply_cst (Expr.Term.Const.mk (Dolmen_std.Path.global s) ty) [] [])
+let fresht ty s =
+ Expr.Term.apply_cst (Expr.Term.Const.mk (Dolmen_std.Path.global s) ty) [] []
-let (&:) s l = s >::: (List.map (fun f -> OUnit2.test_case f) l)
+let fresh env ty s =
+ Ground.convert env
+ (Expr.Term.apply_cst
+ (Expr.Term.Const.mk (Dolmen_std.Path.global s) ty)
+ [] [])
+
+let ( &: ) s l = s >::: List.map (fun f -> OUnit2.test_case f) l
let register d cl =
Egraph.register d cl;
@@ -39,41 +44,40 @@ let merge d cl1 cl2 =
let is_equal = Egraph.is_equal
+type t = {
+ wakeup_daemons : Events.daemon_key Queue.t;
+ solver_state : ForSchedulers.Backtrackable.t;
+ context : Colibri2_stdlib.Context.context;
+}
(** without decisions *)
-type t =
- { wakeup_daemons : Events.daemon_key Queue.t;
- solver_state : ForSchedulers.Backtrackable.t;
- context : Colibri2_stdlib.Context.context;
- }
-
let new_solver () =
let context = Colibri2_stdlib.Context.create () in
{
wakeup_daemons = Queue.create ();
- solver_state = ForSchedulers.Backtrackable.new_t (Colibri2_stdlib.Context.creator context);
+ solver_state =
+ ForSchedulers.Backtrackable.new_t
+ (Colibri2_stdlib.Context.creator context);
context;
}
exception ReachStepLimit
+
exception Contradiction
let run_exn = Colibri2_solver.Scheduler.run_exn ~limit:3000
let check_file ?limit ~theories filename =
let st =
- Colibri2_solver.Input.mk_state
- ~input:(`File filename)
- theories
- ~bt:false
+ Colibri2_solver.Input.mk_state ~input:(`File filename) theories ~bt:false
?step_limit:limit
in
- Colibri2_solver.Input.read
- ~show_check_sat_result:false
+ Colibri2_solver.Input.read ~show_check_sat_result:false
~set_true:Colibri2_theories_bool.Boolean.set_true
- ~handle_exn:Colibri2_solver.Input.handle_exn_with_error
- st;
- let r = st.Colibri2_solver.Input.State.solve_state.Colibri2_solver.Input.state in
+ ~handle_exn:Colibri2_solver.Input.handle_exn_with_error st;
+ let r =
+ st.Colibri2_solver.Input.State.solve_state.Colibri2_solver.Input.state
+ in
match r with
| `Sat _ -> `Sat
| `Unsat -> `Unsat
@@ -81,34 +85,32 @@ let check_file ?limit ~theories filename =
| `Unknown _ -> `Unknown
| `StepLimitReached -> `StepLimitReached
-
let tests_file ?limit ~theories expected dir =
- if Sys.file_exists dir then
+ if Sys.file_exists dir then (
let files = Sys.readdir dir in
Array.sort String.compare files;
let files = Array.to_list files in
List.map
(fun s ->
- s >: test_case (fun _ ->
- begin match check_file ?limit ~theories (Filename.concat dir s) with
+ s
+ >: test_case (fun _ ->
+ match check_file ?limit ~theories (Filename.concat dir s) with
| `Sat ->
- Colibri2_popop_lib.Debug.dprintf1 debug "@[%s: Sat@]" s;
- assert_bool s (`Sat = expected)
+ Colibri2_popop_lib.Debug.dprintf1 debug "@[%s: Sat@]" s;
+ assert_bool s (`Sat = expected)
| `Unsat ->
- Colibri2_popop_lib.Debug.dprintf1 debug "@[%s: Unsat@]" s;
- assert_bool s (`Unsat = expected)
+ Colibri2_popop_lib.Debug.dprintf1 debug "@[%s: Unsat@]" s;
+ assert_bool s (`Unsat = expected)
| `Unknown ->
- Colibri2_popop_lib.Debug.dprintf1 debug "@[%s: Unknown@]" s;
- assert_bool s (`Unknown = expected)
+ Colibri2_popop_lib.Debug.dprintf1 debug "@[%s: Unknown@]" s;
+ assert_bool s (`Unknown = expected)
| `StepLimitReached ->
- Colibri2_popop_lib.Debug.dprintf0 debug "StepLimit Reached@.";
- assert_bool s false
+ Colibri2_popop_lib.Debug.dprintf0 debug "StepLimit Reached@.";
+ assert_bool s false
| exception exn ->
- Colibri2_popop_lib.Debug.dprintf2 debug "@.Error: %s@.%s@."
- (Printexc.to_string exn)
- (Printexc.get_backtrace ());
- assert_bool s false;
- end;
- )) files
- else
- []
+ Colibri2_popop_lib.Debug.dprintf2 debug "@.Error: %s@.%s@."
+ (Printexc.to_string exn)
+ (Printexc.get_backtrace ());
+ assert_bool s false))
+ files)
+ else []
diff --git a/src_colibri2/tests/tests_uf.ml b/src_colibri2/tests/tests_uf.ml
index 3cc921045f89ac8021062f4b6c1a9dc1929ea897..20d6f728658dd5212f3901499aada22d3036b4a4 100644
--- a/src_colibri2/tests/tests_uf.ml
+++ b/src_colibri2/tests/tests_uf.ml
@@ -18,267 +18,323 @@
(* for more details (enclosed in the file licenses/LGPLv2.1). *)
(*************************************************************************)
-
open OUnit2
open Colibri2_core
open Tests_lib
open Colibri2_theories_bool
-let theories = [Boolean.th_register; Equality.th_register;
- Colibri2_theories_quantifiers.Uninterp.th_register;
- Colibri2_theories_quantifiers.Quantifier.th_register ]
-let run = Tests_lib.run_exn ~theories ~nodec:()
-let ($$) f x = f x
+let theories =
+ [
+ Boolean.th_register;
+ Equality.th_register;
+ Colibri2_theories_quantifiers.Uninterp.th_register;
+ Colibri2_theories_quantifiers.Quantifier.th_register;
+ ]
+
+let run f = Tests_lib.run_exn ~theories ~nodec:() f
+
+let ( $$ ) f x = f x
open Expr
let ta = fresht Ty.bool "a"
+
let tb = fresht Ty.bool "b"
+
let tc = fresht Ty.bool "c"
-let a = Ground.convert ta
-let b = Ground.convert tb
-let c = Ground.convert tc
+
+let f =
+ Expr.Term.Const.mk
+ (Dolmen_std.Path.global "f")
+ (Expr.Ty.arrow [ Ty.bool ] Ty.bool)
+
+let g =
+ Expr.Term.Const.mk
+ (Dolmen_std.Path.global "g")
+ (Expr.Ty.arrow [ Ty.bool; Ty.bool ] Ty.bool)
+
+let h =
+ Expr.Term.Const.mk
+ (Dolmen_std.Path.global "h")
+ (Expr.Ty.arrow [ Ty.bool; Ty.bool ] Ty.bool)
+
+let rec gen_calls i s =
+ let i = i + 1 in
+ match s.[i] with
+ | 'a' -> (ta, i)
+ | 'b' -> (tb, i)
+ | 'c' -> (tc, i)
+ | 'f' ->
+ let x, i = gen_calls i s in
+ (Expr.Term.apply_cst f [] [ x ], i)
+ | 'g' ->
+ let x, i = gen_calls i s in
+ let y, i = gen_calls i s in
+ (Expr.Term.apply_cst g [] [ x; y ], i)
+ | 'h' ->
+ let x, i = gen_calls i s in
+ let y, i = gen_calls i s in
+ (Expr.Term.apply_cst h [] [ x; y ], i)
+ | _ -> assert false
+
+let gen_calls env s = Ground.convert env (fst (gen_calls (-1) s))
let empty _ =
- let env = run $$ fun env ->
- register env a; register env b;
- in
- assert_bool "⊬ a == b" (not (is_equal env a b))
+ run @@ fun env ->
+ let a = gen_calls env "a" in
+ let b = gen_calls env "b" in
+ register env a;
+ register env b;
+ fun env -> assert_bool "⊬ a == b" (not (is_equal env a b))
let tauto _ =
- let env = run $$ fun env ->
- register env a; register env b;
- merge env a b;
- in
- assert_bool "a = b => a = b"
- (is_equal env a b)
+ run @@ fun env ->
+ let a = gen_calls env "a" in
+ let b = gen_calls env "b" in
+ register env a;
+ register env b;
+ merge env a b;
+ fun env -> assert_bool "a = b => a = b" (is_equal env a b)
let tauto_equal _ =
- let env = run $$ fun env ->
- register env a; register env b;
- merge env a b;
- in
- assert_bool "a = b => a = b"
- (is_equal env a b)
+ run @@ fun env ->
+ let a = gen_calls env "a" in
+ let b = gen_calls env "b" in
+ register env a;
+ register env b;
+ merge env a b;
+ fun env -> assert_bool "a = b => a = b" (is_equal env a b)
let trans _ =
- let env = run $$ fun env ->
- register env a; register env b; register env c;
- merge env a b; merge env b c;
- in
- assert_bool "a = b => b = c => a = c" (is_equal env a c);
- assert_bool "a = b => b = c => a = b" (is_equal env a b);
- assert_bool "a = b => b = c => b = c" (is_equal env b c)
+ run @@ fun env ->
+ let a = gen_calls env "a" in
+ let b = gen_calls env "b" in
+ let c = gen_calls env "c" in
+ register env a;
+ register env b;
+ register env c;
+ merge env a b;
+ merge env b c;
+ fun env ->
+ assert_bool "a = b => b = c => a = c" (is_equal env a c);
+ assert_bool "a = b => b = c => a = b" (is_equal env a b);
+ assert_bool "a = b => b = c => b = c" (is_equal env b c)
let noteq _ =
- let env = run $$ fun env ->
- register env a; register env b; register env c;
- merge env b c;
- in
- assert_bool "b = c => a != c" (not (is_equal env a c))
-
-let basic = "Uf.Basic" >::: ["empty" >:: empty; "tauto" >:: tauto;
- "trans" >:: trans; "noteq" >:: noteq]
-
-let f = Expr.Term.Const.mk (Dolmen_std.Path.global "f") (Expr.Ty.arrow [Ty.bool] Ty.bool)
-let f x = Expr.Term.apply_cst f [] [x]
-let fa = Ground.convert @@ f ta
-let fb = Ground.convert @@ f tb
-let ffa = Ground.convert @@ f (f ta)
-let ffb = Ground.convert @@ f (f tb)
+ run @@ fun env ->
+ let a = gen_calls env "a" in
+ let b = gen_calls env "b" in
+ let c = gen_calls env "c" in
+ register env a;
+ register env b;
+ register env c;
+ merge env b c;
+ fun env -> assert_bool "b = c => a != c" (not (is_equal env a c))
+
+let basic =
+ "Uf.Basic"
+ >::: [
+ "empty" >:: empty;
+ "tauto" >:: tauto;
+ "trans" >:: trans;
+ "noteq" >:: noteq;
+ ]
let refl _ =
- let env = run $$ fun env ->
- register env fa;
- in
- assert_bool "f(a) = f(a)" (is_equal env fa fa)
+ run @@ fun env ->
+ let fa = gen_calls env "fa" in
+ register env fa;
+ fun env -> assert_bool "f(a) = f(a)" (is_equal env fa fa)
let empty _ =
- let env = run $$ fun env ->
- register env fa; register env fb;
- in
- assert_bool "f(a) != f(b)" (not (is_equal env fa fb))
+ run @@ fun env ->
+ let fa = gen_calls env "fa" in
+ let fb = gen_calls env "fb" in
+ register env fa;
+ register env fb;
+ fun env -> assert_bool "f(a) != f(b)" (not (is_equal env fa fb))
let congru _ =
- let env = run $$ fun env ->
- Colibri2_stdlib.Shuffle.seql [
- (fun () -> register env fa);
- (fun () -> register env fb);
- (fun () -> register env a);
- (fun () -> register env b);
- ];
- merge env a b;
- in
- assert_bool "a = b => f(a) = f(b)"
- (is_equal env fa fb)
+ run @@ fun env ->
+ let a = gen_calls env "a" in
+ let b = gen_calls env "b" in
+ let fa = gen_calls env "fa" in
+ let fb = gen_calls env "fb" in
+ Colibri2_stdlib.Shuffle.seql
+ [
+ (fun () -> register env fa);
+ (fun () -> register env fb);
+ (fun () -> register env a);
+ (fun () -> register env b);
+ ];
+ merge env a b;
+ fun env -> assert_bool "a = b => f(a) = f(b)" (is_equal env fa fb)
let _2level _ =
- let env = run $$ fun env ->
- Colibri2_stdlib.Shuffle.seql [
- (fun () -> register env ffa);
- (fun () -> register env ffb);
- (fun () -> register env a);
- (fun () -> register env b);
- ];
- merge env a b;
- in
- assert_bool "a = b => f(f(a)) = f(f(b))"
- (is_equal env ffa ffb)
+ run @@ fun env ->
+ let a = gen_calls env "a" in
+ let b = gen_calls env "b" in
+ let ffa = gen_calls env "ffa" in
+ let ffb = gen_calls env "ffb" in
+ Colibri2_stdlib.Shuffle.seql
+ [
+ (fun () -> register env ffa);
+ (fun () -> register env ffb);
+ (fun () -> register env a);
+ (fun () -> register env b);
+ ];
+ merge env a b;
+ fun env -> assert_bool "a = b => f(f(a)) = f(f(b))" (is_equal env ffa ffb)
let _2level' _ =
- let env = run $$ fun env ->
- register env a; register env b;
- merge env a b;
- register env ffa; register env ffb;
- in
- assert_bool "a = b => f(f(a)) = f(f(b))" (is_equal env ffa ffb)
-
+ run @@ fun env ->
+ let a = gen_calls env "a" in
+ let b = gen_calls env "b" in
+ let ffa = gen_calls env "ffa" in
+ let ffb = gen_calls env "ffb" in
+ register env a;
+ register env b;
+ merge env a b;
+ register env ffa;
+ register env ffb;
+ fun env -> assert_bool "a = b => f(f(a)) = f(f(b))" (is_equal env ffa ffb)
let bigger _ =
- let rec bf n = if n < 1 then ta else f (bf(n-1)) in
- let fa = Ground.convert @@ bf 1 in
- let fffa = Ground.convert @@ bf 3 in
- let fffffa = Ground.convert @@ bf 5 in
- let env = run $$ fun env ->
- Colibri2_stdlib.Shuffle.seql
- [(fun () -> register env a);
- (fun () -> register env fa);
- (fun () -> register env fffa);
- (fun () -> register env fffffa);
- ];
- Colibri2_stdlib.Shuffle.seql
- [(fun () -> merge env a fffa);
- (fun () -> merge env fffffa a)];
- in
- assert_bool "a = f(f(f(a))) => f(f(f(f(f(a))))) = a => f(a) = a"
- (is_equal env fa a)
-
-let congru1 = "Uf.Congru 1 arg" >::: ["refl" >:: refl;"congru" >:: congru;
- "2level" >:: _2level; "2level'" >:: _2level';
- "bigger" >:: bigger]
-let (!!) = Ground.convert
-let g = Expr.Term.Const.mk (Dolmen_std.Path.global "g") (Expr.Ty.arrow [Ty.bool;Ty.bool] Ty.bool)
-let g a b = Expr.Term.apply_cst g [] [a;b]
-let gab = g ta tb
-let gaa = g ta ta
-let ggabb = g gab tb
-let gab = !!gab
-let gaa = !!gaa
-let ggabb = !!ggabb
+ run @@ fun env ->
+ let a = gen_calls env "a" in
+ let fa = gen_calls env "fa" in
+ let fffa = gen_calls env "fffa" in
+ let fffffa = gen_calls env "fffffa" in
+ Colibri2_stdlib.Shuffle.seql
+ [
+ (fun () -> register env a);
+ (fun () -> register env fa);
+ (fun () -> register env fffa);
+ (fun () -> register env fffffa);
+ ];
+ Colibri2_stdlib.Shuffle.seql
+ [ (fun () -> merge env a fffa); (fun () -> merge env fffffa a) ];
+ fun env ->
+ assert_bool "a = f(f(f(a))) => f(f(f(f(f(a))))) = a => f(a) = a"
+ (is_equal env fa a)
+
+let congru1 =
+ "Uf.Congru 1 arg"
+ >::: [
+ "refl" >:: refl;
+ "congru" >:: congru;
+ "2level" >:: _2level;
+ "2level'" >:: _2level';
+ "bigger" >:: bigger;
+ ]
let refl _ =
- let env = run $$ fun env -> register env gab in
- assert_bool "g(a,b) = g(a,b)" (is_equal env gab gab)
+ run @@ fun env ->
+ let gab = gen_calls env "gab" in
+ register env gab;
+ fun env -> assert_bool "g(a,b) = g(a,b)" (is_equal env gab gab)
let congru _ =
- let env = run $$ fun env ->
- Colibri2_stdlib.Shuffle.seql [
- (fun () -> register env gab);
- (fun () -> register env gaa);
- (fun () -> register env a);
- (fun () -> register env b);
- ];
- merge env a b;
- in
- assert_bool "a = b => g(a,b) = g(a,a)"
- (is_equal env gab gaa)
+ run @@ fun env ->
+ let gab = gen_calls env "gab" in
+ let gaa = gen_calls env "gaa" in
+ let a = gen_calls env "a" in
+ let b = gen_calls env "b" in
+ Colibri2_stdlib.Shuffle.seql
+ [
+ (fun () -> register env gab);
+ (fun () -> register env gaa);
+ (fun () -> register env a);
+ (fun () -> register env b);
+ ];
+ merge env a b;
+ fun env -> assert_bool "a = b => g(a,b) = g(a,a)" (is_equal env gab gaa)
let notcongru _ =
- let env = run $$ fun env ->
- register env a; register env gab; register env gaa;
- merge env a gab;
- in
- assert_bool "a = g(a,b) => g(a,b) != g(a,a)"
- (not (is_equal env gab gaa))
+ run @@ fun env ->
+ let gab = gen_calls env "gab" in
+ let gaa = gen_calls env "gaa" in
+ let a = gen_calls env "a" in
+ register env a;
+ register env gab;
+ register env gaa;
+ merge env a gab;
+ fun env ->
+ assert_bool "a = g(a,b) => g(a,b) != g(a,a)" (not (is_equal env gab gaa))
let _2level _ =
- let env = run $$ fun env ->
- Colibri2_stdlib.Shuffle.seql [
- (fun () -> register env a);
- (fun () -> register env gab);
- ];
- Colibri2_stdlib.Shuffle.seql [
- (fun () -> merge env gab a;);
- (fun () -> register env ggabb);
- ];
- in
- assert_bool "g(a,b) = a => g(g(a,b),b) = a"
- (is_equal env ggabb a)
-
-let congru2 = "Uf.congru 2 args" >::: ["refl" >:: refl; "congru" >:: congru;
- "2level" >:: _2level;]
+ run @@ fun env ->
+ let gab = gen_calls env "gab" in
+ let ggabb = gen_calls env "ggabb" in
+ let a = gen_calls env "a" in
+ Colibri2_stdlib.Shuffle.seql
+ [ (fun () -> register env a); (fun () -> register env gab) ];
+ Colibri2_stdlib.Shuffle.seql
+ [ (fun () -> merge env gab a); (fun () -> register env ggabb) ];
+ fun env -> assert_bool "g(a,b) = a => g(g(a,b),b) = a" (is_equal env ggabb a)
+
+let congru2 =
+ "Uf.congru 2 args"
+ >::: [ "refl" >:: refl; "congru" >:: congru; "2level" >:: _2level ]
let merge env x y =
register env x;
register env y;
merge env x y
-let x = fresht Ty.bool "x"
-let y = fresht Ty.bool "y"
-
let altergo0 _ =
- let h = Expr.Term.Const.mk (Dolmen_std.Path.global "h") (Expr.Ty.arrow [Ty.bool] Ty.bool) in
- let h x = Expr.Term.apply_cst h [] [x] in
- let g = Expr.Term.Const.mk (Dolmen_std.Path.global "g") (Expr.Ty.arrow [Ty.bool;Ty.bool] Ty.bool) in
- let g x y = Expr.Term.apply_cst g [] [x;y] in
- let gax = g ta x in
- let hx = h x in
- let gahx = g ta hx in
- let ggahxx = g gahx x in
- let env = run $$ fun env ->
- Colibri2_stdlib.Shuffle.seql
- [(fun () -> merge env !!hx !!x);
- (fun () -> merge env !!gax a)];
- register env !!ggahxx
- in
- assert_bool "h(x)=x and g(a,x)=a -> g(g(a,h(x)),x)=a"
- (is_equal env !!ggahxx a)
+ run @@ fun env ->
+ let gab = gen_calls env "gab" in
+ let b = gen_calls env "b" in
+ let a = gen_calls env "a" in
+ let fb = gen_calls env "fb" in
+ let ggafbb = gen_calls env "ggafbb" in
+ Colibri2_stdlib.Shuffle.seql
+ [ (fun () -> merge env fb b); (fun () -> merge env gab a) ];
+ register env ggafbb;
+ fun env ->
+ assert_bool "f(b)=b and g(a,b)=a -> g(g(a,f(b)),b)=a"
+ (is_equal env ggafbb a)
let altergo1 _ =
- let h = Expr.Term.Const.mk (Dolmen_std.Path.global "h") (Expr.Ty.arrow [Ty.bool;Ty.bool] Ty.bool) in
- let h x y = Expr.Term.apply_cst h [] [x;y] in
- let rec bf n = if n < 1 then ta else f (bf (n-1)) in
- let fffa = bf 3 in
- let fffffa = bf 5 in
- let gxy = g x y in
- let ggxyy = g gxy y in
- let hggxyya = h ggxyy ta in
- let fa = f ta in
- let hxfa = h x fa in
- let env = run $$ fun env ->
- Colibri2_stdlib.Shuffle.seql
- [(fun () -> merge env !!fffa a);
- (fun () -> merge env !!fffffa a);
- (fun () -> merge env !!gxy !!x)];
- register env !!hggxyya;
- register env !!hxfa;
- in
- assert_bool
- "f(f(f(a)))=a and f(f(f(f(f(a)))))=a and g(x,y)=x -> \
- h(g(g(x,y),y),a)=h(x,f(a))"
- (is_equal env !!hggxyya !!hxfa)
+ run @@ fun env ->
+ let b = gen_calls env "b" in
+ let a = gen_calls env "a" in
+ let fffa = gen_calls env "fffa" in
+ let fffffa = gen_calls env "fffffa" in
+ let gbc = gen_calls env "gbc" in
+ let hggbcca = gen_calls env "hggbcca" in
+ let hbfa = gen_calls env "hbfa" in
+ Colibri2_stdlib.Shuffle.seql
+ [
+ (fun () -> merge env fffa a);
+ (fun () -> merge env fffffa a);
+ (fun () -> merge env gbc b);
+ ];
+ register env hggbcca;
+ register env hbfa;
+ fun env ->
+ assert_bool
+ "f(f(f(a)))=a and f(f(f(f(f(a)))))=a and g(b,c)=b -> \
+ h(g(g(b,c),c),a)=h(b,f(a))"
+ (is_equal env hggbcca hbfa)
let altergo2 _ =
- let h = Expr.Term.Const.mk (Dolmen_std.Path.global "h") (Expr.Ty.arrow [Ty.bool;Ty.bool] Ty.bool) in
- let h x y = Expr.Term.apply_cst h [] [x;y] in
- let gxy = g x y in
- let fa = f ta in
- let ggxyy = g gxy y in
- let hggxyya = h ggxyy ta in
- let hxfa = h x fa in
- let env = run $$ fun env ->
- Colibri2_stdlib.Shuffle.seql
- [(fun () -> merge env !!fa a);
- (fun () -> merge env !!gxy !!x)];
- register env !!hggxyya;
- register env !!hxfa;
- in
- assert_bool
- "f(a) = a -> g(x,y)=x -> h(g(g(x,y),y),a)=h(x,f(a))"
- (is_equal env !!hggxyya !!hxfa)
-
-
-
-let altergo = "Uf.altergo tests" &: [altergo0; altergo1; altergo2]
-
-let tests = OUnit2.test_list [basic; congru1;congru2;altergo]
+ run @@ fun env ->
+ let b = gen_calls env "b" in
+ let a = gen_calls env "a" in
+ let gbc = gen_calls env "gbc" in
+ let fa = gen_calls env "fa" in
+ let hggbcca = gen_calls env "hggbcca" in
+ let hbfa = gen_calls env "hbfa" in
+ Colibri2_stdlib.Shuffle.seql
+ [ (fun () -> merge env fa a); (fun () -> merge env gbc b) ];
+ register env hggbcca;
+ register env hbfa;
+ fun env ->
+ assert_bool "f(a) = a -> g(b,c)=b -> h(g(g(b,c),c),a)=h(b,f(a))"
+ (is_equal env hggbcca hbfa)
+
+let altergo = "Uf.altergo tests" &: [ altergo0; altergo1; altergo2 ]
+
+let tests = OUnit2.test_list [ basic; congru1; congru2; altergo ]
diff --git a/src_colibri2/theories/ADT/adt.ml b/src_colibri2/theories/ADT/adt.ml
index c67d29427d3935fbcae18c546c09f63ddc83912a..3180773f6a05bc3fc432c0742aa43e93c23f2482 100644
--- a/src_colibri2/theories/ADT/adt.ml
+++ b/src_colibri2/theories/ADT/adt.ml
@@ -158,7 +158,7 @@ let converter d (f : Ground.t) =
let adt = Option.value_exn (Adt_value.MonoAdt.index adt tyargs) in
let e = IArray.extract1_exn args in
reg e;
- Choice.register d (Decide.new_decision e adt case);
+ Choice.register d f (Decide.new_decision e adt case);
attach d
(set e
(let+ vr = getb r in
@@ -204,7 +204,7 @@ let converter d (f : Ground.t) =
let adt = Option.value_exn (Adt_value.MonoAdt.index adt tyargs) in
let e = IArray.extract1_exn args in
reg e;
- Choice.register d (Decide.new_decision e adt case);
+ Choice.register d f (Decide.new_decision e adt case);
attach d
(set e
(let* ve = get e in
diff --git a/src_colibri2/theories/LRA/LRA.ml b/src_colibri2/theories/LRA/LRA.ml
index d92e352e1e1bba6b6ce9f01d65f8124ea0d5f6a6..e2cd8c57cdbc46ce13dbb5e49822d0c0f4ad372f 100644
--- a/src_colibri2/theories/LRA/LRA.ml
+++ b/src_colibri2/theories/LRA/LRA.ml
@@ -36,79 +36,125 @@ let th_register env =
let () = Init.add_default_theory th_register
-
(** Helpers to remove *)
let a = Expr.Term.Var.mk "a" Expr.Ty.real
+
let b = Expr.Term.Var.mk "b" Expr.Ty.real
+
let ta = Expr.Term.of_var a
+
let tb = Expr.Term.of_var b
let c = Expr.Term.Var.mk "c" Expr.Ty.real
+
let d = Expr.Term.Var.mk "d" Expr.Ty.real
+
let tc = Expr.Term.of_var c
+
let td = Expr.Term.of_var d
-let add =
- let e = Expr.Term.Real.add ta tb in
- fun na nb ->
- let subst = { Ground.Subst.empty with
- term = Expr.Term.Var.M.of_list [a,na;b,nb] } in
- Ground.convert ~subst e
-
-let add' =
- let e = Expr.Term.Real.(add (mul tc ta) (mul td tb)) in
- fun qa na qb nb ->
- let qa = RealValue.cst qa in
- let qb = RealValue.cst qb in
- let subst = { Ground.Subst.empty with
- term = Expr.Term.Var.M.of_list [a,na;b,nb;c,qa;d,qb] } in
- Ground.convert ~subst e
-
-let sub =
- let e = Expr.Term.Real.sub ta tb in
- fun na nb ->
- let subst = { Ground.Subst.empty with
- term = Expr.Term.Var.M.of_list [a,na;b,nb] } in
- Ground.convert ~subst e
-
-let mult_cst =
- let e = Expr.Term.Real.(mul tc ta) in
- fun qa na ->
- let qa = RealValue.cst qa in
- let subst = { Ground.Subst.empty with
- term = Expr.Term.Var.M.of_list [a,na;c,qa] } in
- Ground.convert ~subst e
-
-let mult =
- let e = Expr.Term.Real.(mul ta tb) in
- fun na nb ->
- let subst = { Ground.Subst.empty with
- term = Expr.Term.Var.M.of_list [a,na;b,nb] } in
- Ground.convert ~subst e
-
-let gt_zero =
- let e = Expr.Term.Real.(gt ta tb) in
- fun na ->
- let subst = { Ground.Subst.empty with
- term = Expr.Term.Var.M.of_list [a,na;b,RealValue.zero] } in
- Ground.convert ~subst e
-
-let ge_zero =
- let e = Expr.Term.Real.(ge ta tb) in
- fun na ->
- let subst = { Ground.Subst.empty with
- term = Expr.Term.Var.M.of_list [a,na;b,RealValue.zero] } in
- Ground.convert ~subst e
-
-let cmp cmp =
- let e = cmp ta tb in
- fun na nb ->
- let subst = { Ground.Subst.empty with
- term = Expr.Term.Var.M.of_list [a,na;b,nb] } in
- Ground.convert ~subst e
-
-let lt = cmp Expr.Term.Real.lt
-let le = cmp Expr.Term.Real.le
-let gt = cmp Expr.Term.Real.gt
-let ge = cmp Expr.Term.Real.ge
+let tadd = Expr.Term.Real.add ta tb
+
+let add d na nb =
+ let subst =
+ {
+ Ground.Subst.empty with
+ term = Expr.Term.Var.M.of_list [ (a, na); (b, nb) ];
+ }
+ in
+ Ground.convert ~subst d tadd
+
+let tadd' = Expr.Term.Real.(add (mul tc ta) (mul td tb))
+
+let add' env qa na qb nb =
+ let qa = RealValue.cst qa in
+ let qb = RealValue.cst qb in
+ let subst =
+ {
+ Ground.Subst.empty with
+ term = Expr.Term.Var.M.of_list [ (a, na); (b, nb); (c, qa); (d, qb) ];
+ }
+ in
+ Ground.convert ~subst env tadd'
+
+let tsub = Expr.Term.Real.sub ta tb
+
+let sub env na nb =
+ let subst =
+ {
+ Ground.Subst.empty with
+ term = Expr.Term.Var.M.of_list [ (a, na); (b, nb) ];
+ }
+ in
+ Ground.convert ~subst env tsub
+
+let tmult_cst = Expr.Term.Real.(mul tc ta)
+
+let mult_cst env qa na =
+ let qa = RealValue.cst qa in
+ let subst =
+ {
+ Ground.Subst.empty with
+ term = Expr.Term.Var.M.of_list [ (a, na); (c, qa) ];
+ }
+ in
+ Ground.convert ~subst env tmult_cst
+
+let tmult = Expr.Term.Real.(mul ta tb)
+
+let mult env na nb =
+ let subst =
+ {
+ Ground.Subst.empty with
+ term = Expr.Term.Var.M.of_list [ (a, na); (b, nb) ];
+ }
+ in
+ Ground.convert ~subst env tmult
+
+let tgt_zero = Expr.Term.Real.(gt ta tb)
+
+let gt_zero env na =
+ let subst =
+ {
+ Ground.Subst.empty with
+ term = Expr.Term.Var.M.of_list [ (a, na); (b, RealValue.zero) ];
+ }
+ in
+ Ground.convert ~subst env tgt_zero
+
+let tge_zero = Expr.Term.Real.(ge ta tb)
+
+let ge_zero env na =
+ let subst =
+ {
+ Ground.Subst.empty with
+ term = Expr.Term.Var.M.of_list [ (a, na); (b, RealValue.zero) ];
+ }
+ in
+ Ground.convert ~subst env tge_zero
+
+let cmp tcmp env na nb =
+ let subst =
+ {
+ Ground.Subst.empty with
+ term = Expr.Term.Var.M.of_list [ (a, na); (b, nb) ];
+ }
+ in
+ Ground.convert ~subst env tcmp
+
+let tlt = Expr.Term.Real.lt ta tb
+
+let tle = Expr.Term.Real.le ta tb
+
+let tgt = Expr.Term.Real.gt ta tb
+
+let tge = Expr.Term.Real.ge ta tb
+
+let lt env na nb = cmp tlt env na nb
+
+let le env na nb = cmp tle env na nb
+
+let gt env na nb = cmp tgt env na nb
+
+let ge env na nb = cmp tge env na nb
diff --git a/src_colibri2/theories/LRA/LRA.mli b/src_colibri2/theories/LRA/LRA.mli
index 35f2008aef8efa725ec15e01383d11bdb61ac24e..5c4bcd55d4a7bc319fb1d2b25c54ccf4a4547e7d 100644
--- a/src_colibri2/theories/LRA/LRA.mli
+++ b/src_colibri2/theories/LRA/LRA.mli
@@ -21,28 +21,35 @@
module RealValue : sig
include Value.S with type s = Q.t
- val cst': Q.t -> t
- val cst: Q.t -> Node.t
- val zero: Node.t
+ val cst' : Q.t -> t
+ val cst : Q.t -> Node.t
+
+ val zero : Node.t
end
-val th_register: Egraph.wt -> unit
+val th_register : Egraph.wt -> unit
(** helpers to remove *)
-val add' : Q.t -> Node.t -> Q.t -> Node.t -> Node.t
-val add : Node.t -> Node.t -> Node.t
-val sub : Node.t -> Node.t -> Node.t
+val add' : _ Egraph.t -> Q.t -> Node.t -> Q.t -> Node.t -> Node.t
+
+val add : _ Egraph.t -> Node.t -> Node.t -> Node.t
+
+val sub : _ Egraph.t -> Node.t -> Node.t -> Node.t
+
+val mult_cst : _ Egraph.t -> Q.t -> Node.t -> Node.t
+
+val mult : _ Egraph.t -> Node.t -> Node.t -> Node.t
+
+val gt_zero : _ Egraph.t -> Node.t -> Node.t
+
+val ge_zero : _ Egraph.t -> Node.t -> Node.t
-val mult_cst : Q.t -> Node.t -> Node.t
+val lt : _ Egraph.t -> Node.t -> Node.t -> Node.t
+val le : _ Egraph.t -> Node.t -> Node.t -> Node.t
-val mult : Node.t -> Node.t -> Node.t
+val gt : _ Egraph.t -> Node.t -> Node.t -> Node.t
-val gt_zero: Node.t -> Node.t
-val ge_zero: Node.t -> Node.t
-val lt: Node.t -> Node.t -> Node.t
-val le: Node.t -> Node.t -> Node.t
-val gt: Node.t -> Node.t -> Node.t
-val ge: Node.t -> Node.t -> Node.t
+val ge : _ Egraph.t -> Node.t -> Node.t -> Node.t
diff --git a/src_colibri2/theories/LRA/fourier.ml b/src_colibri2/theories/LRA/fourier.ml
index 311f557d44dc168c0b6750453c40371c05958330..9b6e77df831e9f2a6b8023c1bf3f2c941c1d8664 100644
--- a/src_colibri2/theories/LRA/fourier.ml
+++ b/src_colibri2/theories/LRA/fourier.ml
@@ -285,7 +285,7 @@ let converter d (f : Ground.t) =
Daemon.enqueue d n);
Datastructure.Push.push comparisons d f;
Events.new_pending_daemon d Daemon.key ();
- Choice.register d (Boolean.chobool (Ground.node f))
+ Choice.register d f (Boolean.chobool (Ground.node f))
| _ -> ()
let init env = Ground.register_converter env converter
diff --git a/src_colibri2/theories/bool/boolean.ml b/src_colibri2/theories/bool/boolean.ml
index 22f67b8a5ae030c2f355112ea2555b9654247eb5..c3a153e4a5978081328c44c8d58e0357e200c793 100644
--- a/src_colibri2/theories/bool/boolean.ml
+++ b/src_colibri2/theories/bool/boolean.ml
@@ -78,23 +78,22 @@ let set_false env node = set_bool env node false
let a = Expr.Term.Var.mk "a" Expr.Ty.bool
let ta = Expr.Term.of_var a
+let _not_ta = Expr.Term.neg ta
-let _not =
- let e = Expr.Term.neg ta in
- fun na ->
+let _not d na =
let subst = { Ground.Subst.empty with
term = Expr.Term.Var.M.of_list [a,na] } in
- Ground.convert ~subst e
+ Ground.convert ~subst d _not_ta
-let _gen mk l =
+let _gen mk d l =
let v = List.map (fun _ -> Expr.Term.Var.mk "b" Expr.Ty.bool) l in
let t = List.map Expr.Term.of_var v in
let subst = { Ground.Subst.empty with
term = Expr.Term.Var.M.of_list (List.combine v l) } in
- Ground.convert ~subst (mk t)
+ Ground.convert ~subst d (mk t)
-let _and = _gen Expr.Term._and
-let _or = _gen Expr.Term._or
+let _and d l = _gen Expr.Term._and d l
+let _or d l = _gen Expr.Term._or d l
(** {2 Choice on bool} *)
@@ -274,7 +273,7 @@ let converter d (f:Ground.t) =
match Ground.sem f with
| { app = {builtin = Expr.Base; _ }; ty; _ }
when Ground.Ty.equal ty Ground.Ty.bool ->
- Choice.register d (chobool res)
+ Choice.register d f (chobool res)
| { app = {builtin = Expr.Or}; tyargs = []; args; _ } ->
reg_args args;
TwoWatchLiteral.create d values_true f
diff --git a/src_colibri2/theories/bool/boolean.mli b/src_colibri2/theories/bool/boolean.mli
index f34fa775fe66351b832a81e91c42719e2837131d..0042be667b59eabc6046ab7991732c4e945c17ed 100644
--- a/src_colibri2/theories/bool/boolean.mli
+++ b/src_colibri2/theories/bool/boolean.mli
@@ -20,9 +20,9 @@
val _true : Node.t
val _false : Node.t
-val _and : Node.t list -> Node.t
-val _or : Node.t list -> Node.t
-val _not : Node.t -> Node.t
+val _and : _ Egraph.t -> Node.t list -> Node.t
+val _or : _ Egraph.t -> Node.t list -> Node.t
+val _not : _ Egraph.t -> Node.t -> Node.t
val set_true : Egraph.wt -> Node.t -> unit
val set_false : Egraph.wt -> Node.t -> unit
diff --git a/src_colibri2/theories/bool/equality.ml b/src_colibri2/theories/bool/equality.ml
index 1310ca976aafc42f062972990f36d55bd11edcbd..43567cacdf6b383bfcbc689dff64b91939f70df0 100644
--- a/src_colibri2/theories/bool/equality.ml
+++ b/src_colibri2/theories/bool/equality.ml
@@ -207,14 +207,20 @@ let check_sem v cl =
(** API *)
-let equality cll =
+let equality_iter f _ cll =
try
let fold acc e = Node.S.add_new Exit e acc in
let s = List.fold_left fold Node.S.empty cll in
- ThE.node (ThE.index s)
+ let v = ThE.index s in
+ f v;
+ ThE.node v
with Exit -> Boolean._true
-let disequality cll = Boolean._not (equality cll)
+let equality d cl1 = equality_iter (fun _ -> ()) d cl1
+
+let disequality d cll = Boolean._not d (equality d cll)
+
+let disequality_iter f d cll = Boolean._not d (equality_iter f d cll)
let is_equal t cl1 cl2 = Egraph.is_equal t cl1 cl2
@@ -303,8 +309,8 @@ module ChoEquals = struct
let make_disequal the (cl1, cl2) d =
Debug.dprintf6 Debug.decision
- "[Equality] @[decide on merge of %a and %a in %a@]" Node.pp cl1 Node.pp
- cl2 ThE.pp the;
+ "[Equality] @[decide on disequality of %a and %a in %a@]" Node.pp cl1
+ Node.pp cl2 ThE.pp the;
Egraph.register d cl1;
Egraph.register d cl2;
let _dis, stag = new_tag the in
@@ -396,7 +402,8 @@ let attach_new_equalities d =
if true (* GenEquality.dodec (Th.get_ty v) *) then (
Debug.dprintf4 debug "[Equality] @[ask_dec on %a for %a@]" Node.pp
own Th.pp v;
- Choice.register d (ChoEquals.mk_choice clsem))
+ Choice.register_thterm d (ThE.thterm clsem)
+ (ChoEquals.mk_choice clsem))
| _ -> ())
(** ITE *)
@@ -510,22 +517,25 @@ let converter d (t : Ground.t) =
Egraph.register d n;
Egraph.merge d res n
in
+ let mark th =
+ Choice.Group.add_to_group_of d (ThE.thterm th) (Ground.thterm t)
+ in
match Ground.sem t with
| { app = { builtin = Expr.Equal }; tyargs = [ _ ]; args = l; _ } ->
IArray.iter ~f:reg l;
- reg_and_merge (equality (IArray.to_list l))
+ reg_and_merge (equality_iter mark d (IArray.to_list l))
| { app = { builtin = Expr.Equiv }; tyargs = [ _ ]; args; _ } ->
let a, b = IArray.extract2_exn args in
- reg_and_merge (equality [ of_term a; of_term b ])
+ reg_and_merge (equality_iter mark d [ of_term a; of_term b ])
| { app = { builtin = Expr.Distinct }; tyargs = [ _ ]; args; _ } ->
IArray.iter ~f:reg args;
- reg_and_merge (disequality (IArray.to_list args))
+ reg_and_merge (disequality d (IArray.to_list args))
| { app = { builtin = Expr.Ite }; tyargs = [ _ ]; args; _ } ->
let c, a, b = IArray.extract3_exn args in
new_ite d res (of_term c) a b
| { app = { builtin = Expr.Xor }; tyargs = []; args; _ } ->
let a, b = IArray.extract2_exn args in
- reg_and_merge (disequality [ of_term a; of_term b ])
+ reg_and_merge (disequality_iter mark d [ of_term a; of_term b ])
| _ -> ()
let th_register env =
diff --git a/src_colibri2/theories/bool/equality.mli b/src_colibri2/theories/bool/equality.mli
index 22cbbe59d6f8db75b69e19f77f99078033c3451e..6179b4e1130d0b1f1b307d4fc87262ce1757d561 100644
--- a/src_colibri2/theories/bool/equality.mli
+++ b/src_colibri2/theories/bool/equality.mli
@@ -18,9 +18,9 @@
(* for more details (enclosed in the file licenses/LGPLv2.1). *)
(*************************************************************************)
-val equality : Node.t list -> Node.t
+val equality : _ Egraph.t -> Node.t list -> Node.t
-val disequality : Node.t list -> Node.t
+val disequality : _ Egraph.t -> Node.t list -> Node.t
val is_equal : _ Egraph.t -> Node.t -> Node.t -> bool
diff --git a/src_colibri2/theories/quantifier/pattern.ml b/src_colibri2/theories/quantifier/pattern.ml
index 09b13883b056469d4944a469bc1eb72f3e5e0074..3f9dd5ba2b2fc067e2b5ee43f3e96b09014efe22 100644
--- a/src_colibri2/theories/quantifier/pattern.ml
+++ b/src_colibri2/theories/quantifier/pattern.ml
@@ -218,7 +218,7 @@ let rec check_term_exists_exn d (subst : Ground.Subst.t) (p : t) : Node.S.t =
else raise Not_found)
| App (pf, ptyl, pargs) when IArray.is_empty pargs ->
let g =
- Ground.apply pf
+ Ground.apply d pf
(List.map (Ground.Ty.convert subst.ty) ptyl)
IArray.empty
|> Ground.index |> Ground.node
diff --git a/src_colibri2/theories/quantifier/quantifier.ml b/src_colibri2/theories/quantifier/quantifier.ml
index 56ca5a13e3c43fb94615918488ee1cdea502e2c8..f6162222809ea3d09a561e4459e176c2e5e6a2fb 100644
--- a/src_colibri2/theories/quantifier/quantifier.ml
+++ b/src_colibri2/theories/quantifier/quantifier.ml
@@ -79,7 +79,7 @@ let find_new_event d n (info : Info.t) n' (info' : Info.t) =
in
symmetric aux acc n info n' info'
in
- (** parent node *)
+ (* parent node *)
let do_pn pn ip acc =
let aux acc n info1 n' _ =
if Egraph.is_equal d n' pn.PN.node then
@@ -201,11 +201,11 @@ let skolemize d (e : Ground.ClosedQuantifier.s) =
(fun acc v ->
let id = Expr.Term.Const.mk v.Expr.path v.id_ty in
let t = Expr.Term.apply_cst id [] [] in
- Expr.Term.Var.M.add v (Ground.convert ~subst:e.subst t) acc)
+ Expr.Term.Var.M.add v (Ground.convert ~subst:e.subst d t) acc)
e.subst.term e.term_vars
in
let subst = { Ground.Subst.ty = e.subst.ty; term = subst_term } in
- let n = Ground.convert ~subst e.body in
+ let n = Ground.convert ~subst d e.body in
Egraph.register d n;
n
@@ -237,7 +237,10 @@ let attach d th =
let quantifier_registered d th =
let n = Ground.ClosedQuantifier.node th in
- if Boolean.is_unknown d n then Choice.register d (Boolean.chobool n);
+ if Boolean.is_unknown d n then
+ Choice.register_thterm d
+ (Ground.ClosedQuantifier.thterm th)
+ (Boolean.chobool n);
attach d th
(** Verify that this term is congruent closure to another already existing term
diff --git a/src_colibri2/theories/quantifier/trigger.ml b/src_colibri2/theories/quantifier/trigger.ml
index 7c1e0f27e255f403ccc4b7d96a13f77c8cd34b8f..3824b33389597682a9972a060fa2c707434815c2 100644
--- a/src_colibri2/theories/quantifier/trigger.ml
+++ b/src_colibri2/theories/quantifier/trigger.ml
@@ -314,7 +314,7 @@ let instantiate_aux d tri subst =
let form = Ground.ClosedQuantifier.sem tri.form in
Debug.incr nb_instantiation;
let subst = Ground.Subst.distinct_union subst form.subst in
- let n = Ground.convert ~subst form.body in
+ let n = Ground.convert ~subst d form.body in
if Debug.test_flag Debug.stats && not (Egraph.is_registered d n) then
Debug.incr nb_new_instantiation;
Egraph.register d n;
diff --git a/src_common/union.mlw b/src_common/union.mlw
index a93a1c00dd31f8dadb1150d55c3bd9a12d2876f1..fd6ed106c234fcba341870f82a927e08afec9607 100644
--- a/src_common/union.mlw
+++ b/src_common/union.mlw
@@ -101,40 +101,49 @@ module Union
Q.make 0 1
end
- predicate ordered0 (a:t0) =
- forall i j [nth0 i a,nth0 j a]. 0 <= i < j < length0 a -> Q.(nth0 i a < nth0 j a)
-
- let lemma ordered0_is_ordered (a:t0)
- requires { ordered0 a }
- ensures { match a with
- | End -> true
- | FiniteInf _ _ -> true
- | Singleton _ a0
- | Inter _ _ _ _ a0 -> ordered0 a0
- end } =
- match a with
- | End -> ()
- | FiniteInf _ _ -> ()
- | Singleton _ a0 -> assert { forall i. 0 <= i < length0 a0 -> nth0 i a0 = nth0 (i+1) a }; ()
- | Inter _ _ _ _ a0 -> assert { forall i. 0 <= i < length0 a0 -> nth0 i a0 = nth0 (i+2) a }; ()
- end
+ predicate lt_bound0 (x:Q.t) (l:t0) =
+ match l with
+ | Singleton q l ->
+ Q.(x < q) /\ lt_bound0 x l
+ | Inter q _ q' _ l ->
+ Q.(x < q) /\ Q.(x < q') /\ lt_bound0 x l
+ | FiniteInf q _ ->
+ Q.(x < q)
+ | End -> true
+ end
- predicate ordered (a:t) =
- forall i j [nth i a,nth j a]. 0 <= i < j < length a -> Q.(nth i a < nth j a)
+ predicate lt_bound (x:Q.t) (l:t) =
+ match l with
+ | InfFinite q _ l ->
+ Q.(x < q) \/ lt_bound0 x l
+ | Finite l ->
+ lt_bound0 x l
+ | Inf ->
+ true
+ end
- let lemma ordered_is_ordered (a:t)
- requires { ordered a }
- ensures { match a with
- | InfFinite _ _ a0
- | Finite a0 -> ordered0 a0
- | Inf -> true
- end } =
- match a with
- | InfFinite _ _ a0 -> assert { forall i. 0 <= i < length0 a0 -> nth0 i a0 = nth (i+1) a }; ()
- | Finite a0 -> assert { forall i. 0 <= i < length0 a0 -> nth0 i a0 = nth i a }; ()
- | Inf -> ()
- end
+ predicate ordered0 (l:t0) =
+ match l with
+ | Singleton q l ->
+ lt_bound0 q l /\
+ ordered0 l
+ | Inter q _ q' _ l ->
+ Q.(q < q') /\
+ lt_bound0 q' l /\
+ ordered0 l
+ | FiniteInf _ _ -> true
+ | End -> true
+ end
+ predicate ordered (l:t) =
+ match l with
+ | InfFinite q _ l ->
+ lt_bound0 q l /\
+ ordered0 l
+ | Finite l ->
+ ordered0 l
+ | Inf -> true
+ end
type t' = { a: t }
invariant { ordered a }
@@ -160,6 +169,19 @@ module Union
| End -> false
end
+ let rec lemma lt_bound0_is_not_mem0 (q:Q.t) (r:real) (l:t0)
+ requires { lt_bound0 q l }
+ requires { r <=. q }
+ ensures { not (mem0 r l) }
+ =
+ match l with
+ | Singleton _ l -> lt_bound0_is_not_mem0 q r l
+ | Inter _ _ _ _ l ->
+ lt_bound0_is_not_mem0 q r l
+ | FiniteInf _ _ -> ()
+ | End -> ()
+ end
+
predicate mem (x:real) (l:t) =
match l with
| InfFinite q b l ->
@@ -189,20 +211,20 @@ module Union
| Finite (Singleton q End) -> (Some q,0., 1.)
| Finite End -> absurd
| Finite (Inter q _ q' _ _) ->
- assert { nth 0 u.a = q };
- assert { nth 1 u.a = q' };
- assert { (Q.real q) <. (Q.real q') };
+ (* assert { nth 0 u.a = q }; *)
+ (* assert { nth 1 u.a = q' }; *)
+ (* assert { (Q.real q) <. (Q.real q') }; *)
(None, ghost (Q.real q)*.0.75+.(Q.real q')*.0.25, ghost (Q.real q)*.0.25+.(Q.real q')*.0.75)
| Finite (FiniteInf q _) -> (None,ghost (Q.real q)+.1.,ghost (Q.real q)+.2.)
| Finite (Singleton q (Singleton q' _)) ->
- assert { nth 0 u.a = q };
- assert { nth 1 u.a = q' };
- assert { (Q.real q) <. (Q.real q') };
+ (* assert { nth 0 u.a = q }; *)
+ (* assert { nth 1 u.a = q' }; *)
+ (* assert { (Q.real q) <. (Q.real q') }; *)
(None,ghost (Q.real q), ghost (Q.real q'))
| Finite (Singleton _ (Inter q _ q' _ _)) ->
- assert { nth 1 u.a = q };
- assert { nth 2 u.a = q' };
- assert { (Q.real q) <. (Q.real q') };
+ (* assert { nth 1 u.a = q }; *)
+ (* assert { nth 2 u.a = q' }; *)
+ (* assert { (Q.real q) <. (Q.real q') }; *)
(None, ghost (Q.real q)*.0.75+.(Q.real q')*.0.25, ghost (Q.real q)*.0.25+.(Q.real q')*.0.75)
| Finite (Singleton _ (FiniteInf q _)) -> (None,ghost (Q.real q)+.1.,ghost (Q.real q)+.2.)
end
@@ -212,6 +234,7 @@ module Union
let min_bound_sup v1 b1 v2 b2: (v3:Q.t,b3:Bound.t)
ensures { forall q. (cmp q b1 v1 /\ cmp q b2 v2) <-> cmp q b3 v3 }
ensures { Q.(v3 <= v1) } ensures { Q.(v3 <= v2) }
+ ensures { v3 = v1 || v3 = v2 }
ensures { b1 = Large -> b2 = Large -> b3 = Large }
=
match Q.compare v1 v2, b1, b2 with
@@ -224,6 +247,7 @@ module Union
let min_bound_inf v1 b1 v2 b2: (v3:Q.t,b3:Bound.t)
ensures { forall q. (cmp v1 b1 q \/ cmp v2 b2 q) <-> cmp v3 b3 q }
ensures { Q.(v3 <= v1) } ensures { Q.(v3 <= v2) }
+ ensures { v3 = v1 || v3 = v2 }
ensures { b1 = Large -> b2 = Large -> b3 = Large }
=
match Q.compare v1 v2, b1, b2 with
@@ -236,6 +260,7 @@ module Union
let max_bound_sup v1 b1 v2 b2: (v3:Q.t,b3:Bound.t)
ensures { forall q. (cmp q b1 v1 \/ cmp q b2 v2) <-> cmp q b3 v3 }
ensures { Q.(v1 <= v3) } ensures { Q.(v2 <= v3) }
+ ensures { v3 = v1 || v3 = v2 }
ensures { b1 = Large -> b2 = Large -> b3 = Large }
=
match Q.compare v1 v2, b1, b2 with
@@ -248,6 +273,7 @@ module Union
let max_bound_inf v1 b1 v2 b2: (v3:Q.t,b3:Bound.t)
ensures { forall q. (cmp v1 b1 q /\ cmp v2 b2 q) <-> cmp v3 b3 q }
ensures { Q.(v1 <= v3) } ensures { Q.(v2 <= v3) }
+ ensures { v3 = v1 || v3 = v2 }
ensures { b1 = Large -> b2 = Large -> b3 = Large }
=
match Q.compare v1 v2, b1, b2 with
@@ -268,9 +294,20 @@ module Union
let rec aux (u:t0) (v:t0) : t0
requires { ordered0 u }
requires { ordered0 v }
+ ensures { ordered0 result }
ensures {
forall x:real. (mem0 x u /\ mem0 x v) <-> mem0 x result
}
+ ensures {
+ forall q.
+ (lt_bound0 q u) ->
+ (lt_bound0 q result )
+ }
+ ensures {
+ forall q.
+ (lt_bound0 q v) ->
+ (lt_bound0 q result )
+ }
variant { length0 u + length0 v } =
match u, v with
| End, _ | _, End -> End
@@ -303,19 +340,40 @@ module Union
end
| Inter qu0 bu0 qu1 bu1 lu, Inter qv0 bv0 qv1 bv1 lv ->
let v' = v in let u' = u in
- let small_big qu0 bu0 qu1 bu1 lu qv0 bv0 (qv1:Q.t) bv1 (lv:t0) v
+ let small_big qu0 bu0 qu1 bu1 (lu:t0) (u:t0) qv0 bv0 (qv1:Q.t) (bv1:Bound.t) (lv:t0) v
+ requires { ordered0 u }
+ requires { ordered0 v }
+ requires { u = Inter qu0 bu0 qu1 bu1 lu }
requires { v = Inter qv0 bv0 qv1 bv1 lv }
requires { (v = v' /\ length0 lu + 2 = length0 u') || (v = u' /\ length0 lu + 2 = length0 v') }
+ requires { Q.( qu1 < qv1 ) }
+ ensures { ordered0 result }
+ ensures {
+ forall x:real. (mem0 x u /\ mem0 x v) <-> mem0 x result
+ }
+ ensures {
+ forall q.
+ (lt_bound0 q u) ->
+ (lt_bound0 q result )
+ }
+ ensures {
+ forall q.
+ (lt_bound0 q v) ->
+ (lt_bound0 q result )
+ }
=
match Q.compare qu1 qv0 with
| Ord.Eq ->
- match bu1, bv1 with
+ match bu1, bv0 with
| Large, Large -> Singleton qu1 (aux lu v)
- | _ -> aux lu v
+ | _ ->
+ aux lu v
end
| Ord.Lt -> aux lu v
| Ord.Gt ->
let (qw0,bw0) = max_bound_inf qu0 bu0 qv0 bv0 in
+ assert { Q.(qv0 <= qw0 < qu1 < qv1) };
+ assert { Q.(qu0 <= qw0 < qu1 < qv1) };
Inter qw0 bw0 qu1 bu1 (aux lu v)
end
in
@@ -328,13 +386,16 @@ module Union
end
in
Inter qw0 bw0 qv1 b (aux lu lv)
- | Ord.Lt -> small_big qu0 bu0 qu1 bu1 lu qv0 bv0 qv1 bv1 lv v
- | Ord.Gt -> small_big qv0 bv0 qv1 bv1 lv qu0 bu0 qu1 bu1 lu u
+ | Ord.Lt -> small_big qu0 bu0 qu1 bu1 lu u qv0 bv0 qv1 bv1 lv v
+ | Ord.Gt -> small_big qv0 bv0 qv1 bv1 lv v qu0 bu0 qu1 bu1 lu u
end
| _ -> absurd
end
in
- let aux_option lu lv =
+ let aux_option lu lv
+ requires { ordered0 lu }
+ requires { ordered0 lv }
+ =
match aux lu lv with
| End -> None
| lw -> Some { a = Finite lw }
@@ -367,10 +428,14 @@ module Union
match Q.compare qu0 qv1 with
| Ord.Eq ->
match bu0, bv1 with
- | Large, Large -> aux_option lu (Singleton qv1 lv)
+ | Large, Large ->
+ assert { length (InfFinite qv1 bv1 lv) = length0 (Singleton qv1 lv) };
+ assert { forall i. nth i (InfFinite qv1 bv1 lv) = nth0 i (Singleton qv1 lv) };
+ aux_option lu (Singleton qv1 lv)
| _ -> aux_option lu lv
end
- | Ord.Lt -> aux_option lu (Inter qu0 bu0 qv1 bv1 lv)
+ | Ord.Lt ->
+ aux_option lu (Inter qu0 bu0 qv1 bv1 lv)
| Ord.Gt -> aux_option lu lv
end
end
diff --git a/src_common/union/why3session.xml b/src_common/union/why3session.xml
index f245d7829ec07a7bbe2f303381144f380dfede5d..fda794dfabf50f6725c6e611d69d48c3eb3e92b2 100644
--- a/src_common/union/why3session.xml
+++ b/src_common/union/why3session.xml
@@ -15,32 +15,6 @@
<goal name="nth0_singleton" proved="true">
<proof prover="3"><result status="valid" time="0.00"/></proof>
</goal>
- <goal name="ordered0_is_ordered'vc" expl="VC for ordered0_is_ordered" proved="true">
- <transf name="split_vc" proved="true" >
- <goal name="ordered0_is_ordered'vc.0" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.01"/></proof>
- </goal>
- <goal name="ordered0_is_ordered'vc.1" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.02"/></proof>
- </goal>
- <goal name="ordered0_is_ordered'vc.2" expl="postcondition" proved="true">
- <proof prover="3"><result status="valid" time="2.82"/></proof>
- </goal>
- </transf>
- </goal>
- <goal name="ordered_is_ordered'vc" expl="VC for ordered_is_ordered" proved="true">
- <transf name="split_vc" proved="true" >
- <goal name="ordered_is_ordered'vc.0" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.01"/></proof>
- </goal>
- <goal name="ordered_is_ordered'vc.1" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.01"/></proof>
- </goal>
- <goal name="ordered_is_ordered'vc.2" expl="postcondition" proved="true">
- <proof prover="3"><result status="valid" time="3.04"/></proof>
- </goal>
- </transf>
- </goal>
<goal name="t''vc" expl="VC for t'" proved="true">
<transf name="split_vc" proved="true" >
<goal name="t''vc.0" expl="type invariant" proved="true">
@@ -51,43 +25,19 @@
</goal>
</transf>
</goal>
- <goal name="singleton'vc" expl="VC for singleton" proved="true">
+ <goal name="lt_bound0_is_not_mem0'vc" expl="VC for lt_bound0_is_not_mem0" proved="true">
<proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
+ <goal name="singleton'vc" expl="VC for singleton" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
<goal name="is_singleton'vc" expl="VC for is_singleton" proved="true">
<transf name="split_vc" proved="true" >
- <goal name="is_singleton'vc.0" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.01"/></proof>
- </goal>
- <goal name="is_singleton'vc.1" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.02"/></proof>
- </goal>
- <goal name="is_singleton'vc.2" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.03"/></proof>
- </goal>
- <goal name="is_singleton'vc.3" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.02"/></proof>
- </goal>
- <goal name="is_singleton'vc.4" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.01"/></proof>
- </goal>
- <goal name="is_singleton'vc.5" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.02"/></proof>
- </goal>
- <goal name="is_singleton'vc.6" expl="unreachable point" proved="true">
+ <goal name="is_singleton'vc.0" expl="unreachable point" proved="true">
<proof prover="3"><result status="valid" time="0.00"/></proof>
</goal>
- <goal name="is_singleton'vc.7" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.01"/></proof>
- </goal>
- <goal name="is_singleton'vc.8" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.02"/></proof>
- </goal>
- <goal name="is_singleton'vc.9" expl="assertion" proved="true">
- <proof prover="3"><result status="valid" time="0.02"/></proof>
- </goal>
- <goal name="is_singleton'vc.10" expl="postcondition" proved="true">
- <proof prover="3"><result status="valid" time="0.89"/></proof>
+ <goal name="is_singleton'vc.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.40"/></proof>
</goal>
</transf>
</goal>
@@ -109,16 +59,16 @@
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.1" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.15"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.2" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.16"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.3" expl="variant decrease" proved="true">
<proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
<goal name="inter'vc.4" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.15"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.5" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
@@ -130,13 +80,13 @@
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.8" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.16"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.9" expl="variant decrease" proved="true">
<proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
<goal name="inter'vc.10" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.16"/></proof>
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
<goal name="inter'vc.11" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.00"/></proof>
@@ -145,7 +95,7 @@
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.13" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.16"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.14" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
@@ -154,7 +104,7 @@
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.16" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.15"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.17" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
@@ -163,18 +113,24 @@
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.19" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.15"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.20" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.00"/></proof>
</goal>
<goal name="inter'vc.21" expl="unreachable point">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.21.0" expl="unreachable point">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
</goal>
<goal name="inter'vc.22" expl="variant decrease" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.23" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.15"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.24" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
@@ -183,7 +139,7 @@
<proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
<goal name="inter'vc.26" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.15"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.27" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.00"/></proof>
@@ -192,7 +148,7 @@
<proof prover="3"><result status="valid" time="0.00"/></proof>
</goal>
<goal name="inter'vc.29" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.15"/></proof>
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
<goal name="inter'vc.30" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
@@ -201,126 +157,942 @@
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.32" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.15"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.33" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.34" expl="unreachable point">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.34.0" expl="unreachable point">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
</goal>
<goal name="inter'vc.35" expl="variant decrease" proved="true">
- <proof prover="3"><result status="valid" time="0.02"/></proof>
- </goal>
- <goal name="inter'vc.36" expl="precondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.35.0" expl="variant decrease" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.35.1" expl="variant decrease" proved="true">
+ <proof prover="3"><result status="valid" time="0.03"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.36" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.03"/></proof>
</goal>
<goal name="inter'vc.37" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.03"/></proof>
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
</goal>
<goal name="inter'vc.38" expl="variant decrease" proved="true">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.38.0" expl="variant decrease" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.38.1" expl="variant decrease" proved="true">
+ <proof prover="3"><result status="valid" time="0.03"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.39" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
- <goal name="inter'vc.39" expl="precondition">
- </goal>
<goal name="inter'vc.40" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.03"/></proof>
</goal>
<goal name="inter'vc.41" expl="variant decrease" proved="true">
- <proof prover="3"><result status="valid" time="0.02"/></proof>
- </goal>
- <goal name="inter'vc.42" expl="precondition">
- <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.41.0" expl="variant decrease" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.41.1" expl="variant decrease" proved="true">
+ <proof prover="3"><result status="valid" time="0.03"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.42" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.43" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.03"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.44" expl="variant decrease" proved="true">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.44.0" expl="variant decrease" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.44.1" expl="variant decrease" proved="true">
+ <proof prover="3"><result status="valid" time="0.04"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.45" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
- <goal name="inter'vc.45" expl="precondition">
- </goal>
<goal name="inter'vc.46" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
- <goal name="inter'vc.47" expl="variant decrease" proved="true">
- <proof prover="3"><result status="valid" time="0.03"/></proof>
+ <goal name="inter'vc.47" expl="assertion" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
- <goal name="inter'vc.48" expl="precondition">
+ <goal name="inter'vc.48" expl="assertion" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
- <goal name="inter'vc.49" expl="precondition" proved="true">
+ <goal name="inter'vc.49" expl="variant decrease" proved="true">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.49.0" expl="variant decrease" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.49.1" expl="variant decrease" proved="true">
+ <proof prover="3"><result status="valid" time="0.06"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.50" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.03"/></proof>
</goal>
- <goal name="inter'vc.50" expl="variant decrease" proved="true">
- <proof prover="3"><result status="valid" time="0.02"/></proof>
- </goal>
<goal name="inter'vc.51" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.18"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
- <goal name="inter'vc.52" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.18"/></proof>
+ <goal name="inter'vc.52" expl="postcondition" proved="true">
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.52.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.51"/></proof>
+ </goal>
+ <goal name="inter'vc.52.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.52.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.52.3" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.52.4" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.66"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.53" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.53.0" expl="postcondition" proved="true">
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.53.0.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="3.42"/></proof>
+ </goal>
+ <goal name="inter'vc.53.0.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="2.26"/></proof>
+ </goal>
+ <goal name="inter'vc.53.0.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="2.37"/></proof>
+ </goal>
+ <goal name="inter'vc.53.0.3" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="2.99"/></proof>
+ </goal>
+ <goal name="inter'vc.53.0.4" expl="postcondition" proved="true">
+ <proof prover="3" timelimit="100"><undone/></proof>
+ <transf name="case" proved="true" arg1="(mem0 x lu)">
+ <goal name="inter'vc.53.0.4.0" expl="true case (postcondition)" proved="true">
+ <proof prover="3"><result status="valid" time="1.23"/></proof>
+ </goal>
+ <goal name="inter'vc.53.0.4.1" expl="false case (postcondition)" proved="true">
+ <transf name="case" proved="true" arg1="(mem0 x lv)">
+ <goal name="inter'vc.53.0.4.1.0" expl="false case (true case. postcondition)" proved="true">
+ <proof prover="3"><result status="valid" time="3.38"/></proof>
+ </goal>
+ <goal name="inter'vc.53.0.4.1.1" expl="false case (postcondition)" proved="true">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ <transf name="cut" proved="true" arg1="(cmp v3 b3 x)">
+ <goal name="inter'vc.53.0.4.1.1.0" expl="false case (postcondition)" proved="true">
+ <proof prover="3"><result status="valid" time="0.03"/></proof>
+ </goal>
+ <goal name="inter'vc.53.0.4.1.1.1" expl="asserted formula" proved="true">
+ <proof prover="3"><result status="valid" time="3.04"/></proof>
+ </goal>
+ </transf>
+ <transf name="instantiate" proved="true" arg1="Ensures9" arg2="x">
+ <goal name="inter'vc.53.0.4.1.1.0" expl="false case (postcondition)" proved="true">
+ <proof prover="3"><result status="valid" time="0.04"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
+ <transf name="case" arg1="(cmp v3 b3 x)">
+ <goal name="inter'vc.53.0.4.0" expl="true case (postcondition)" proved="true">
+ <proof prover="3"><result status="valid" time="1.16"/></proof>
+ </goal>
+ <goal name="inter'vc.53.0.4.1" expl="false case (postcondition)">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.53.1" expl="postcondition">
+ <transf name="split_vc" >
+ <goal name="inter'vc.53.1.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="1.38"/></proof>
+ </goal>
+ <goal name="inter'vc.53.1.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.63"/></proof>
+ </goal>
+ <goal name="inter'vc.53.1.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.70"/></proof>
+ </goal>
+ <goal name="inter'vc.53.1.3" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.71"/></proof>
+ </goal>
+ <goal name="inter'vc.53.1.4" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.53.2" expl="postcondition">
+ <transf name="split_vc" >
+ <goal name="inter'vc.53.2.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.64"/></proof>
+ </goal>
+ <goal name="inter'vc.53.2.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.35"/></proof>
+ </goal>
+ <goal name="inter'vc.53.2.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.42"/></proof>
+ </goal>
+ <goal name="inter'vc.53.2.3" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.44"/></proof>
+ </goal>
+ <goal name="inter'vc.53.2.4" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.54" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.54.0" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.54.1" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.54.2" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.54.3" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.54.4" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.55" expl="postcondition" proved="true">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.55.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.32"/></proof>
+ </goal>
+ <goal name="inter'vc.55.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.31"/></proof>
+ </goal>
+ <goal name="inter'vc.55.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.30"/></proof>
+ </goal>
+ <goal name="inter'vc.55.3" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.30"/></proof>
+ </goal>
+ <goal name="inter'vc.55.4" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.42"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.56" expl="variant decrease" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
- <goal name="inter'vc.53" expl="precondition" proved="true">
+ <goal name="inter'vc.57" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
- <goal name="inter'vc.54" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.01"/></proof>
+ <goal name="inter'vc.58" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
- <goal name="inter'vc.55" expl="precondition" proved="true">
+ <goal name="inter'vc.59" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
- <goal name="inter'vc.56" expl="precondition" proved="true">
+ <goal name="inter'vc.60" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
- <goal name="inter'vc.57" expl="unreachable point">
- </goal>
- <goal name="inter'vc.58" expl="postcondition">
- </goal>
- <goal name="inter'vc.59" expl="precondition">
- </goal>
- <goal name="inter'vc.60" expl="precondition">
- </goal>
- <goal name="inter'vc.61" expl="precondition">
+ <goal name="inter'vc.61" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.62" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.63" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.21"/></proof>
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
<goal name="inter'vc.64" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.22"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
- <goal name="inter'vc.65" expl="precondition">
+ <goal name="inter'vc.65" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.66" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
<goal name="inter'vc.67" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.21"/></proof>
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
</goal>
- <goal name="inter'vc.68" expl="precondition">
+ <goal name="inter'vc.68" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
</goal>
- <goal name="inter'vc.69" expl="precondition">
+ <goal name="inter'vc.69" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
<goal name="inter'vc.70" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.00"/></proof>
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.71" expl="unreachable point">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.71.0" expl="unreachable point">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.72" expl="postcondition" proved="true">
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.72.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.72.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.72.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.72.3" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.21"/></proof>
+ </goal>
+ <goal name="inter'vc.72.4" expl="postcondition" proved="true">
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.72.4.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.72.4.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.23"/></proof>
+ </goal>
+ <goal name="inter'vc.72.4.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.30"/></proof>
+ </goal>
+ <goal name="inter'vc.72.4.3" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.72.5" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ <goal name="inter'vc.72.6" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.72.7" expl="postcondition" proved="true">
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.72.7.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.72.7.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.24"/></proof>
+ </goal>
+ <goal name="inter'vc.72.7.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.30"/></proof>
+ </goal>
+ <goal name="inter'vc.72.7.3" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.72.8" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.72.9" expl="postcondition" proved="true">
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.72.9.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.44"/></proof>
+ </goal>
+ <goal name="inter'vc.72.9.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.72.9.2" expl="postcondition" proved="true">
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.72.9.2.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.68.9.0.1" expl="postcondition">
+ <proof prover="3"><result status="valid" time="0.35"/></proof>
+ </goal>
+ <goal name="inter'vc.68.9.0.2" expl="postcondition">
+ <proof prover="3"><result status="valid" time="0.38"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.73" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.73.0" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.73.0.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.3" expl="postcondition" proved="true">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.73.0.3.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="1.69"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.3.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="1.26"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.3.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="1.27"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.73.0.4" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.5" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.6" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.20"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.7" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.8" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.9" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.73.0.9.0" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.9.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.20"/></proof>
+ </goal>
+ <goal name="inter'vc.73.0.9.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.26"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.73.1" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.73.1.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.3" expl="postcondition" proved="true">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.73.1.3.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.72"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.3.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.43"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.3.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.17"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.73.1.4" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="3.69"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.5" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.6" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.29"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.7" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.8" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.9" expl="postcondition" proved="true">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.73.1.9.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="6.33"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.9.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.19"/></proof>
+ </goal>
+ <goal name="inter'vc.73.1.9.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.26"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.73.2" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.73.2.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.3" expl="postcondition" proved="true">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.73.2.3.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.75"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.3.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.17"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.3.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.30"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.73.2.4" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.5" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.6" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.20"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.7" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="3.35"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.8" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.9" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.73.2.9.0" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.9.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.23"/></proof>
+ </goal>
+ <goal name="inter'vc.73.2.9.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.23"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.74" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.74.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.74.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.74.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.74.3" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.74.4" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="1.72"/></proof>
+ </goal>
+ <goal name="inter'vc.74.5" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.74.6" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.74.7" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="2.08"/></proof>
+ </goal>
+ <goal name="inter'vc.74.8" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.74.9" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.75" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.75.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.75.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.75.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.75.3" expl="postcondition" proved="true">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.75.3.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.26"/></proof>
+ </goal>
+ <goal name="inter'vc.75.3.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.18"/></proof>
+ </goal>
+ <goal name="inter'vc.75.3.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.20"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.75.4" expl="postcondition" proved="true">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" proved="true" >
+ <goal name="inter'vc.75.4.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.17"/></proof>
+ </goal>
+ <goal name="inter'vc.75.4.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.27"/></proof>
+ </goal>
+ <goal name="inter'vc.75.4.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.19"/></proof>
+ </goal>
+ <goal name="inter'vc.75.4.3" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.16"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.75.5" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.75.6" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ <goal name="inter'vc.75.7" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="1.77"/></proof>
+ </goal>
+ <goal name="inter'vc.75.8" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.75.9" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.75.9.0" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.75.9.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.19"/></proof>
+ </goal>
+ <goal name="inter'vc.75.9.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.18"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.76" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
- <goal name="inter'vc.71" expl="precondition">
+ <goal name="inter'vc.77" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
- <goal name="inter'vc.72" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.21"/></proof>
+ <goal name="inter'vc.78" expl="precondition" proved="true">
+ <transf name="unfold" proved="true" arg1="ordered">
+ <goal name="inter'vc.78.0" expl="VC for inter" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ </transf>
</goal>
- <goal name="inter'vc.73" expl="precondition">
+ <goal name="inter'vc.79" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
</goal>
- <goal name="inter'vc.74" expl="precondition" proved="true">
- <proof prover="3"><result status="valid" time="0.00"/></proof>
+ <goal name="inter'vc.80" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.81" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.82" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.26"/></proof>
+ </goal>
+ <goal name="inter'vc.83" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.84" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.85" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
</goal>
- <goal name="inter'vc.75" expl="unreachable point" proved="true">
+ <goal name="inter'vc.86" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.28"/></proof>
+ </goal>
+ <goal name="inter'vc.87" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.00"/></proof>
</goal>
- <goal name="inter'vc.76" expl="unreachable point" proved="true">
+ <goal name="inter'vc.88" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ <goal name="inter'vc.89" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.90" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.23"/></proof>
+ </goal>
+ <goal name="inter'vc.91" expl="precondition" proved="true">
<proof prover="3"><result status="valid" time="0.00"/></proof>
</goal>
- <goal name="inter'vc.77" expl="postcondition">
+ <goal name="inter'vc.92" expl="unreachable point" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.93" expl="assertion" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.94" expl="assertion" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ <goal name="inter'vc.95" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ <goal name="inter'vc.96" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ <goal name="inter'vc.97" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ <goal name="inter'vc.98" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.99" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.100" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.101" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ <goal name="inter'vc.102" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.103" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.104" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.105" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.106" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.107" expl="unreachable point" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.108" expl="assertion" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.109" expl="assertion" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ <goal name="inter'vc.110" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ <goal name="inter'vc.111" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.112" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ <goal name="inter'vc.113" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.114" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.115" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.116" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.117" expl="precondition" proved="true">
+ <transf name="unfold" proved="true" arg1="ordered0">
+ <goal name="inter'vc.117.0" expl="VC for inter" proved="true">
+ <proof prover="3"><result status="valid" time="0.02"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.118" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.119" expl="precondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.120.0" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.120.0.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.0.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.0.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.0.3" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.06"/></proof>
+ </goal>
+ <goal name="inter'vc.120.0.4" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.0.5" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.0.6" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.0.7" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.120.1" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.120.1.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.1.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.1.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.1.3" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.1.4" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.1.5" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.1.6" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.1.7" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.120.2" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.120.2.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.2.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.2.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.2.3" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.2.4" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.2.5" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.2.6" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.2.7" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ <goal name="inter'vc.120.3" expl="postcondition">
+ <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+ <transf name="split_vc" >
+ <goal name="inter'vc.120.3.0" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.3.1" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.3.2" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </goal>
+ <goal name="inter'vc.120.3.3" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.3.4" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.3.5" expl="postcondition" proved="true">
+ <proof prover="3"><result status="valid" time="0.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.3.6" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ <goal name="inter'vc.120.3.7" expl="postcondition">
+ <proof prover="3"><result status="timeout" time="5.00"/></proof>
+ </goal>
+ </transf>
+ </goal>
+ </transf>
</goal>
</transf>
</goal>