From 89966f2822d44642298d0f6c5a0d848fc95f11ae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Bobot?= <francois.bobot@cea.fr>
Date: Sat, 30 Oct 2021 11:35:15 +0200
Subject: [PATCH] Replace Fourier-Motskin by Simplex (ocplib-simplex)

  Memorylimit with 20G reached on exemple of union.mlw
---
 colibri2.opam                                 |    1 +
 dune-project                                  |    3 +-
 src_colibri2/core/colibri2_core.ml            |    3 +-
 src_colibri2/solver/scheduler.ml              |    3 +-
 .../generate_tests/generate_dune_tests.ml     |    2 +-
 src_colibri2/tests/solve/all/sat/dune.inc     |   12 +-
 src_colibri2/tests/solve/all/unsat/dune.inc   |   52 +-
 src_colibri2/tests/solve/dimacs/sat/dune.inc  |   44 +-
 .../tests/solve/dimacs/unsat/dune.inc         |   24 +-
 src_colibri2/tests/solve/models/dune.inc      |    6 +-
 src_colibri2/tests/solve/smt_adt/sat/dune.inc |   24 +-
 .../tests/solve/smt_adt/unsat/dune.inc        |   32 +-
 src_colibri2/tests/solve/smt_fp/dune.inc      |    4 +-
 src_colibri2/tests/solve/smt_fp/sat/dune.inc  |   60 +-
 .../tests/solve/smt_fp/unsat/dune.inc         |   16 +-
 src_colibri2/tests/solve/smt_lra/sat/dune.inc |  136 +-
 .../tests/solve/smt_lra/unsat/dune.inc        |   44 +-
 src_colibri2/tests/solve/smt_nra/sat/dune.inc |   28 +-
 .../tests/solve/smt_nra/unsat/dune.inc        |   44 +-
 src_colibri2/tests/solve/smt_quant/dune.inc   |   16 +-
 .../tests/solve/smt_quant/sat/dune.inc        |    4 +-
 .../tests/solve/smt_quant/unsat/dune.inc      |   44 +-
 src_colibri2/tests/solve/smt_uf/sat/dune.inc  |   84 +-
 .../tests/solve/smt_uf/unsat/dune.inc         |   52 +-
 src_colibri2/theories/LRA/LRA.ml              |    2 +-
 src_colibri2/theories/LRA/dom_interval.ml     |    2 +
 src_colibri2/theories/LRA/dom_interval.mli    |   10 +-
 src_colibri2/theories/LRA/dom_polynome.ml     |    3 +
 src_colibri2/theories/LRA/dune                |    4 +-
 src_colibri2/theories/LRA/fourier.ml          |   17 +-
 src_colibri2/theories/LRA/polynome.ml         |   11 +
 src_colibri2/theories/LRA/polynome.mli        |   69 +-
 src_colibri2/theories/LRA/simplex.ml          |  500 +++++
 src_colibri2/theories/LRA/simplex.mli         |   21 +
 .../theories/LRA/stages/interval_sig.ml       |    7 +-
 src_colibri2/theories/LRA/stages/stage0/dune  |    2 +-
 .../LRA/stages/stage0/integer_sign_domain.ml  |   13 +
 .../theories/LRA/stages/stage0/sign_domain.ml |   42 +
 src_colibri2/theories/quantifier/common.ml    |    6 +
 src_colibri2/theories/quantifier/trigger.ml   |    5 +-
 src_common/union.mlw                          |  889 ++++----
 src_common/union/why3session.xml              | 1863 ++++++++---------
 src_common/union__Union.ml                    |  391 ++--
 43 files changed, 2611 insertions(+), 1984 deletions(-)
 create mode 100644 src_colibri2/theories/LRA/simplex.ml
 create mode 100644 src_colibri2/theories/LRA/simplex.mli

diff --git a/colibri2.opam b/colibri2.opam
index 8f2a0a981..689bf16d7 100644
--- a/colibri2.opam
+++ b/colibri2.opam
@@ -29,6 +29,7 @@ depends: [
   "ocamlgraph"
   "ounit2" {with-test}
   "ocaml" {>= "4.08"}
+  "ocplib-simplex"
   "odoc" {with-doc}
 ]
 build: [
diff --git a/dune-project b/dune-project
index 5bab04d8b..338e65f6c 100644
--- a/dune-project
+++ b/dune-project
@@ -51,7 +51,8 @@
            "ppx_hash"
            "ocamlgraph"
            ("ounit2" :with-test)
-           ("ocaml" (>= "4.08"))
+          ("ocaml" (>= "4.08"))
+           "ocplib-simplex"
          )
 )
 
diff --git a/src_colibri2/core/colibri2_core.ml b/src_colibri2/core/colibri2_core.ml
index afc77d49c..95cca039e 100644
--- a/src_colibri2/core/colibri2_core.ml
+++ b/src_colibri2/core/colibri2_core.ml
@@ -211,7 +211,8 @@ module Events = struct
     | 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
+    | DaemonKey (dem, run, _) ->
+        Fmt.pf fmt "%a-%a" Dem.pp dem (Wait.print_dem_runable dem) run
 
   module type T = Egraph.Wait.Dem
   (** Basic daemons *)
diff --git a/src_colibri2/solver/scheduler.ml b/src_colibri2/solver/scheduler.ml
index 083669326..22a4e8e8b 100644
--- a/src_colibri2/solver/scheduler.ml
+++ b/src_colibri2/solver/scheduler.ml
@@ -265,7 +265,8 @@ let new_solver ~learning ?last_effort_limit () =
   in
   let sched_daemon att =
     incr daemon_count;
-    (* Debug.dprintf0 debug "[Scheduler] New waiting daemon"; *)
+    (* Debug.dprintf2 debug "[Scheduler] New waiting daemon: %a"
+     *   Events.pp_daemon_key att; *)
     match get_event_priority att with
     | Immediate -> assert false (* absurd *)
     | Delayed_by offset -> Context.TimeWheel.add t.daemons att offset
diff --git a/src_colibri2/tests/generate_tests/generate_dune_tests.ml b/src_colibri2/tests/generate_tests/generate_dune_tests.ml
index ed68c9afa..7a3261dd8 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=100M --time=30s --max-steps 3500"
+let cmd = "%{bin:colibri2} --size=20M --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 d13402ca1..c126645af 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=100M --time=30s --max-steps 3500 --check-status sat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat 
 --dont-print-result %{dep:div_abs.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:div_abs2.smt2})))
-(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 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/all/unsat/dune.inc b/src_colibri2/tests/solve/all/unsat/dune.inc
index 15fa7cb3c..a2a7ebd96 100644
--- a/src_colibri2/tests/solve/all/unsat/dune.inc
+++ b/src_colibri2/tests/solve/all/unsat/dune.inc
@@ -1,39 +1,39 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --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=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 
+(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 
 --dont-print-result %{dep:div_abs.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:fact-FactRecursive-fact_recqtvc.psmt2})))
-(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 
+(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 
 --dont-print-result %{dep:interval-Convexe-exists_memqtvc_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:interval-Convexe-exists_memqtvc_1.psmt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --dont-print-result %{dep:interval-Convexe-exists_memqtvc_2.psmt2})))
-(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 
+(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 
 --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 
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --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=20M --time=30s --max-steps 3500 --check-status unsat 
 --dont-print-result %{dep:mul_abs.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_abs.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --dont-print-result %{dep:ordered_is_ordered.psmt2})))
-(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 
+(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 
 --dont-print-result %{dep:union-Union-interqtvc_5.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-interqtvc_5.psmt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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-interqtvc_5.psmt2})))
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --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=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 
+(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 
 --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 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 
+(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 
 --dont-print-result %{dep:union-Union-is_singletonqtvc_5.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-is_singletonqtvc_5.psmt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/dimacs/sat/dune.inc b/src_colibri2/tests/solve/dimacs/sat/dune.inc
index fc8c83dc5..5d40389aa 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=100M --time=30s --max-steps 3500 --check-status sat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat 
 --dont-print-result %{dep:anomaly_agetooold.cnf})))
-(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 
+(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 
 --dont-print-result %{dep:anomaly_agetooold2.cnf})))
-(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 
+(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 
 --dont-print-result %{dep:assertion_fail.cnf})))
-(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 
+(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 
 --dont-print-result %{dep:fuzzing1.cnf})))
-(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 
+(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 
 --dont-print-result %{dep:fuzzing2.cnf})))
-(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 
+(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 
 --dont-print-result %{dep:par8-1-c.cnf})))
-(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 
+(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 
 --dont-print-result %{dep:pigeon-2.cnf})))
-(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 
+(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 
 --dont-print-result %{dep:pigeon-3.cnf})))
-(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 
+(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 
 --dont-print-result %{dep:pigeon-4.cnf})))
-(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 
+(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 
 --dont-print-result %{dep:quinn.cnf})))
-(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 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/dimacs/unsat/dune.inc b/src_colibri2/tests/solve/dimacs/unsat/dune.inc
index da2d93fa1..148c9a4ec 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=100M --time=30s --max-steps 3500 --check-status unsat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat 
 --dont-print-result %{dep:anomaly_agetooold.cnf})))
-(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 
+(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 
 --dont-print-result %{dep:modus_ponens.cnf})))
-(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 
+(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 
 --dont-print-result %{dep:pigeon-1.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-1.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --dont-print-result %{dep:pigeon-2.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-2.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --dont-print-result %{dep:pigeon-3.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-3.cnf})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/models/dune.inc b/src_colibri2/tests/solve/models/dune.inc
index d381eb29b..72a595836 100644
--- a/src_colibri2/tests/solve/models/dune.inc
+++ b/src_colibri2/tests/solve/models/dune.inc
@@ -1,6 +1,6 @@
-(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 (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 (alias runtest) (action (diff abs_real.smt2.oracle abs_real.smt2.res)))
-(rule (action (with-stdout-to function.smt2.res (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status colibri2 %{dep:function.smt2}))))
+(rule (action (with-stdout-to function.smt2.res (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status colibri2 %{dep:function.smt2}))))
 (rule (alias runtest) (action (diff function.smt2.oracle function.smt2.res)))
-(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 (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 (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 e92b98e60..53f078718 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=100M --time=30s --max-steps 3500 --check-status sat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat 
 --dont-print-result %{dep:enum.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:list0.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:list1.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:tree1.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:tree2.smt2})))
-(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 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_adt/unsat/dune.inc b/src_colibri2/tests/solve/smt_adt/unsat/dune.inc
index 9390dce25..f3f9ebb87 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=100M --time=30s --max-steps 3500 --check-status unsat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat 
 --dont-print-result %{dep:enum.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:enum2.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:list0.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:list1.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:list2.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:list3.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:list4.smt2})))
-(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 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_fp/dune.inc b/src_colibri2/tests/solve/smt_fp/dune.inc
index db314f401..755fd7c18 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=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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_fp/sat/dune.inc b/src_colibri2/tests/solve/smt_fp/sat/dune.inc
index 2102d7900..cea27603a 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=100M --time=30s --max-steps 3500 --check-status sat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --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=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 
+(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 
 --dont-print-result %{dep:inf_pos_neg_neq_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:inf_pos_neg_neq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:infm_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:infm_eq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:infp_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:infp_eq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:nan_neq_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:nan_neq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:recognize_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:recognize_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:recognize_rounding_mode.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:rm_instanciation.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:simple_add_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:simple_add_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:simple_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:simple_eq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:simple_mul_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:simple_mul_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:to_fp_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:to_fp_eq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:zero_pos_neg_neq_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:zero_pos_neg_neq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:zerom_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:zerom_eq_float32.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_fp/unsat/dune.inc b/src_colibri2/tests/solve/smt_fp/unsat/dune.inc
index 84446c08b..7e79bd0e4 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=100M --time=30s --max-steps 3500 --check-status unsat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --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=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 
+(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 
 --dont-print-result %{dep:inf_pos_neg_neq.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:nan_neq_float32.smt2})))
-(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 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_lra/sat/dune.inc b/src_colibri2/tests/solve/smt_lra/sat/dune.inc
index 1527a3d57..b7855698a 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=100M --time=30s --max-steps 3500 --check-status sat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --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=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 
+(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 
 --dont-print-result %{dep:arith_conflict_add_disequality.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_conpoly.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_decide_must_test_is_dis_equal.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_init_always_merge_itself.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_init_and_propa_must_be_ordered.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_merge_case1.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_merge_case_4.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_merge_case_4_bis.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_merge_itself_coef_of_repr_is_one.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_merge_itself_last_case.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_merge_itself_pivot_not_in_p12.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_merge_must_use_find.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_mult_explication.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_mult_not_linear_in_conflict.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_normalize_use_find_def.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_own_repr.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_propacl.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_subst_and_conflict_add.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:arith_zero_dom.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:attach_only_when_dom_present.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:init_not_repr.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:le.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:le2.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:mul.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.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:sem_invariant_in_learnt_dec.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:solver_add_pexp_cl.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:solver_arith_homogeneous_dist_sign.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:solver_merge_itself_repr_inside.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:solver_set_pending_merge_expsameexp.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:solver_subst_eventdom_find.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:to_real.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:to_real2.smt2})))
-(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 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_lra/unsat/dune.inc b/src_colibri2/tests/solve/smt_lra/unsat/dune.inc
index 4f683c3c6..35fe81049 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=100M --time=30s --max-steps 3500 --check-status unsat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --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=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 
+(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 
 --dont-print-result %{dep:arith_merge_case2.smt2})))
-(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 
+(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 
 --dont-print-result %{dep: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:le.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --dont-print-result %{dep:le2.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:mul.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.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --dont-print-result %{dep:repr_and_poly.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:repr_fourier.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:solver_merge_itself_repr_empty.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:solver_set_sem_merge_sign.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:to_real.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_real.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_nra/sat/dune.inc b/src_colibri2/tests/solve/smt_nra/sat/dune.inc
index 56338fdbb..c2bb7f7b0 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=100M --time=30s --max-steps 3500 --check-status sat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat 
 --dont-print-result %{dep:ceil.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:div_pos.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:div_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:div_pos_lt.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:mul_commut.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_commut.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:mul_commut2.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_commut2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:mul_pos.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.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_nra/unsat/dune.inc b/src_colibri2/tests/solve/smt_nra/unsat/dune.inc
index 3504cfb71..1c6866c5d 100644
--- a/src_colibri2/tests/solve/smt_nra/unsat/dune.inc
+++ b/src_colibri2/tests/solve/smt_nra/unsat/dune.inc
@@ -1,33 +1,33 @@
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat 
 --dont-print-result %{dep:ceil.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:div_pos.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:div_pos_lt.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:div_pos_lt_to_real.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:floor.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:mul_commut.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_commut.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --dont-print-result %{dep:mul_commut2.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_commut2.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --dont-print-result %{dep:mul_pos.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.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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 
 --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 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 
+(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 
 --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})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat 
+(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) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat 
 --dont-print-result %{dep:mult_hard.smt2})))
-(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mult_hard.smt2})))
+(rule (alias runtest-learning) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat --learning --dont-print-result %{dep:mult_hard.smt2})))
diff --git a/src_colibri2/tests/solve/smt_quant/dune.inc b/src_colibri2/tests/solve/smt_quant/dune.inc
index 064a16c22..6d35d86dc 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=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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_quant/sat/dune.inc b/src_colibri2/tests/solve/smt_quant/sat/dune.inc
index f71fd565f..82ec2986d 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=100M --time=30s --max-steps 3500 --check-status sat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_quant/unsat/dune.inc b/src_colibri2/tests/solve/smt_quant/unsat/dune.inc
index af3b030e0..3ca854bdf 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=100M --time=30s --max-steps 3500 --check-status unsat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status unsat 
 --dont-print-result %{dep:exists.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:exists2.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:forall0.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:forall1.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:forall2.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:forall3.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:forall4.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:forall5.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:forall6.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:forall7.smt2})))
-(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 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_uf/sat/dune.inc b/src_colibri2/tests/solve/smt_uf/sat/dune.inc
index c67d488f0..e39fff7d1 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=100M --time=30s --max-steps 3500 --check-status sat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --time=30s --max-steps 3500 --check-status sat 
 --dont-print-result %{dep:bad_conflict.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:bcp_dont_like_duplicate.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:bool_not_propa.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:boolexpup.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:clause_normalization.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:clmerge.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:conflict_complete_needed_cl.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:directdom_not.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:dis_dom_before_first_age.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:dom_merge_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:dom_merge_equality.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep: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:equality.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:equality_condis.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:equality_get_sem.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:exp_sem_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:exp_sem_equality.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:explimit_cl_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:explimit_cl_equality.smt2})))
-(rule (alias runtest) (action (run %{bin:colibri2} --size=100M --time=30s --max-steps 3500 --check-status sat 
+(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 
 --dont-print-result %{dep:implication.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:intmap_set_disjoint.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:is_equal_not_propagated.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:ite_sem_bool.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:polyeq_genequality.smt2})))
-(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 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/tests/solve/smt_uf/unsat/dune.inc b/src_colibri2/tests/solve/smt_uf/unsat/dune.inc
index 85a1faaf1..941a3d34d 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=100M --time=30s --max-steps 3500 --check-status unsat 
+(rule (alias runtest) (action (run %{bin:colibri2} --size=20M --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=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 
+(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 
 --dont-print-result %{dep:deltaed0.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:diff_to_value_for_bool.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:diff_value_substupfalse.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:distinct.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:eq_diamond2.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:equality_norm_set.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:fundef.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:get_repr_at__instead_of__equal_CRepr.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:many_distinct.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:polyeq_genequality.smt2})))
-(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 
+(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 
 --dont-print-result %{dep:polyeq_genequality_deltaed.smt2})))
-(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 
+(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 
 --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})))
+(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})))
diff --git a/src_colibri2/theories/LRA/LRA.ml b/src_colibri2/theories/LRA/LRA.ml
index e2cd8c57c..11a6c011f 100644
--- a/src_colibri2/theories/LRA/LRA.ml
+++ b/src_colibri2/theories/LRA/LRA.ml
@@ -29,7 +29,7 @@ let th_register env =
   Dom_interval.init env;
   Dom_polynome.init env;
   RealValue.init env;
-  Fourier.init env;
+  Simplex.init env;
   Mul.init env;
   Dom_product.init env;
   ()
diff --git a/src_colibri2/theories/LRA/dom_interval.ml b/src_colibri2/theories/LRA/dom_interval.ml
index 8d400b089..47b52e036 100644
--- a/src_colibri2/theories/LRA/dom_interval.ml
+++ b/src_colibri2/theories/LRA/dom_interval.ml
@@ -49,6 +49,8 @@ include Dom.Lattice (struct
       (is_singleton d)
 end)
 
+let get_dom d = Egraph.get_dom d dom
+
 let is_zero_or_positive d n =
   match Egraph.get_dom d dom n with
   | None -> false
diff --git a/src_colibri2/theories/LRA/dom_interval.mli b/src_colibri2/theories/LRA/dom_interval.mli
index fa4cd42d3..b5391c834 100644
--- a/src_colibri2/theories/LRA/dom_interval.mli
+++ b/src_colibri2/theories/LRA/dom_interval.mli
@@ -21,13 +21,19 @@
 val init : Egraph.wt -> unit
 
 module D : sig
-  type t
+  include Colibri2_theories_LRA_stages_def.Interval_sig.S
 
-  type is_comparable = Gt | Lt | Ge | Le | Eq | Uncomparable
+  val get_convexe_hull : t -> (Q.t * Bound.t) option * (Q.t * Bound.t) option
+
+  val from_convexe_hull : (Q.t * Bound.t) option * (Q.t * Bound.t) option -> t
 end
 
 val dom : D.t Dom.Kind.t
 
+val get_dom : _ Egraph.t -> Node.t -> D.t option
+
+val upd_dom : Egraph.wt -> Node.t -> D.t -> unit
+
 val is_zero_or_positive : _ Egraph.t -> Node.t -> bool
 
 val is_not_zero : _ Egraph.t -> Node.t -> bool
diff --git a/src_colibri2/theories/LRA/dom_polynome.ml b/src_colibri2/theories/LRA/dom_polynome.ml
index 9217b9591..f1e7db95b 100644
--- a/src_colibri2/theories/LRA/dom_polynome.ml
+++ b/src_colibri2/theories/LRA/dom_polynome.ml
@@ -47,6 +47,9 @@ module Table = struct
       (function
         | None -> Some n
         | Some n' as s ->
+            (* Should not have to register here *)
+            Egraph.register d n;
+            Egraph.register d n';
             Egraph.merge d n n';
             s)
       h d new_
diff --git a/src_colibri2/theories/LRA/dune b/src_colibri2/theories/LRA/dune
index 4b7875743..48a002de3 100644
--- a/src_colibri2/theories/LRA/dune
+++ b/src_colibri2/theories/LRA/dune
@@ -5,7 +5,9 @@
  (libraries containers ocamlgraph colibri2.stdlib colibri2.popop_lib
             colibri2.core colibri2.theories.bool
             colibri2.theories.quantifiers
-            colibri2.theories.LRA.stages )
+            colibri2.theories.LRA.stages
+            ocplib-simplex
+ )
  (preprocess
   (pps ppx_deriving.std ppx_hash))
  (flags :standard -w +a-4-42-44-48-50-58-32-60-40-9@8 -color always
diff --git a/src_colibri2/theories/LRA/fourier.ml b/src_colibri2/theories/LRA/fourier.ml
index 9b6e77df8..78d1d1833 100644
--- a/src_colibri2/theories/LRA/fourier.ml
+++ b/src_colibri2/theories/LRA/fourier.ml
@@ -235,9 +235,24 @@ let fm (d : Egraph.wt) =
                     | Large, Large -> Bound.Large
                     | _ -> Bound.Strict
                   in
-                  add_eq d eqs p bound (Ground.S.union peq.origins neq.origins))
+                  let s = Ground.S.union peq.origins neq.origins in
+                  add_eq d eqs p bound s)
                 absent positive negative
             in
+            (* let eqs =
+             *   List.rev_map
+             *     (fun { p; bound; origins = _ } ->
+             *       { p = Polynome.normalize p; bound; origins = Ground.S.empty })
+             *     eqs
+             * in
+             * let eqs =
+             *   List.sort_uniq
+             *     (fun eqs1 eqs2 -> Polynome.compare eqs1.p eqs2.p)
+             *     eqs
+             * in *)
+            if Colibri2_popop_lib.Debug.test_flag debug then
+              Debug.dprintf2 debug "vars: %i, eqs: %i" (Node.S.cardinal vars)
+                (List.length eqs);
             aux eqs vars)
   in
   aux eqs vars
diff --git a/src_colibri2/theories/LRA/polynome.ml b/src_colibri2/theories/LRA/polynome.ml
index fcec24d72..27a7dccab 100644
--- a/src_colibri2/theories/LRA/polynome.ml
+++ b/src_colibri2/theories/LRA/polynome.ml
@@ -195,3 +195,14 @@ let get_tree p =
   (ClM.view
     (Node.M.fold_left (fun acc node q ->  ClM.add node q acc) ClM.empty p.poly))
 , p.cst
+
+let normalize p =
+  if Node.M.is_empty p.poly then cst (Q.of_int (Q.sign p.cst)) else
+    let init = if Q.equal Q.zero p.cst then snd (Node.M.choose p.poly) else p.cst in
+    let (num,den) = Node.M.fold_left (fun (num,den) _ q -> Z.gcd num q.Q.num, Z.gcd den q.Q.den)
+        (init.Q.num,init.Q.den) p.poly in
+    if Z.equal Z.one num && Z.equal Z.one den then p
+    else
+      let conv q = Q.make (Z.divexact q.Q.num num) (Z.divexact q.Q.den den) in
+      { poly = Node.M.map conv p.poly;
+        cst = conv p.cst }
diff --git a/src_colibri2/theories/LRA/polynome.mli b/src_colibri2/theories/LRA/polynome.mli
index 48ac39203..b2cb3e993 100644
--- a/src_colibri2/theories/LRA/polynome.mli
+++ b/src_colibri2/theories/LRA/polynome.mli
@@ -19,53 +19,66 @@
 (*************************************************************************)
 
 open Colibri2_popop_lib
+
 open Colibri2_core
 (** Polynome *)
 
-type t = private { cst : Q.t; poly : Q.t Node.M.t}
+type t = private { cst : Q.t; poly : Q.t Node.M.t }
+
 include Popop_stdlib.Datatype with type t := t
 
-val invariant: t -> bool
+val invariant : t -> bool
+
+val zero : t
+
+val is_zero : t -> bool
 
-val zero: t
-val is_zero: t -> bool
+val cst : Q.t -> t
 
-val cst: Q.t -> t
-val is_cst: t -> Q.t option
-val monome: Q.t -> Node.t  -> t
-val is_one_node: t -> Node.t option
+val is_cst : t -> Q.t option
+
+val monome : Q.t -> Node.t -> t
+
+val is_one_node : t -> Node.t option
 
 type extract =
-  | Zero            (** p = 0 *)
-  | Cst of Q.t      (** p = q *)
-  | Var of Q.t * Node.t * t (** p = qx + p' *)
+  | Zero  (** p = 0 *)
+  | Cst of Q.t  (** p = q *)
+  | Var of Q.t * Node.t * t  (** p = qx + p' *)
 
 val extract : t -> extract
 
-type kind = | ZERO | CST | VAR
+type kind = ZERO | CST | VAR
+
 val classify : t -> kind
 
-val sub_cst: t -> Q.t -> t
-val add_cst: t -> Q.t -> t
-val mult_cst: Q.t -> t -> t
+val sub_cst : t -> Q.t -> t
+
+val add_cst : t -> Q.t -> t
+
+val mult_cst : Q.t -> t -> t
+
+val add : t -> t -> t
+
+val sub : t -> t -> t
+
+val of_list : Q.t -> (Node.t * Q.t) list -> t
+
+val x_p_cy : t -> Q.t -> t -> t
 
-val add: t -> t -> t
-val sub: t -> t -> t
+val cx_p_cy : Q.t -> t -> Q.t -> t -> t
 
-val of_list: Q.t -> (Node.t * Q.t) list -> t
+val subst : t -> Node.t -> t -> t * Q.t
 
-val x_p_cy: t -> Q.t -> t -> t
+val subst_node : t -> Node.t -> Node.t -> t * Q.t
 
-val cx_p_cy: Q.t -> t -> Q.t -> t -> t
+val fold : ('a -> Node.t -> Q.t -> 'a) -> 'a -> t -> 'a
 
-val subst: t -> Node.t -> t -> t * Q.t
-val subst_node: t -> Node.t -> Node.t -> t * Q.t
+val iter : (Node.t -> Q.t -> unit) -> t -> unit
 
-val fold: ('a -> Node.t -> Q.t -> 'a) -> 'a -> t -> 'a
-val iter: (Node.t -> Q.t -> unit) -> t -> unit
+type 'a tree = Empty | Node of 'a tree * Node.t * 'a * 'a tree * int
 
-type 'a tree =
-  | Empty
-  | Node of 'a tree * Node.t * 'a * 'a tree * int
+val get_tree : t -> Q.t tree * Q.t
 
-val get_tree: t -> Q.t tree * Q.t
+val normalize : t -> t
+(** divide by the pgcd *)
diff --git a/src_colibri2/theories/LRA/simplex.ml b/src_colibri2/theories/LRA/simplex.ml
new file mode 100644
index 000000000..b0e874054
--- /dev/null
+++ b/src_colibri2/theories/LRA/simplex.ml
@@ -0,0 +1,500 @@
+(*************************************************************************)
+(*  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 Colibri2_popop_lib
+open Colibri2_core
+
+let comparisons = Datastructure.Push.create Ground.pp "LRA.simplex.comparisons"
+
+let scheduled =
+  Datastructure.Ref.create Base.Bool.pp "LRA.simplex.scheduled" false
+
+let debug =
+  Debug.register_info_flag ~desc:"Reasoning about <= < in LRA" "simplex"
+
+let stats_run = Debug.register_stats_int ~name:"Simplex.run" ~init:0
+
+module Var = struct
+  include Node
+
+  let is_int _ = false
+
+  let print = pp
+end
+
+module Ex = struct
+  type t = unit
+
+  let print fmt () = Format.fprintf fmt "()"
+
+  let empty = ()
+
+  let union () () = ()
+end
+
+module Rat = struct
+  include Q
+
+  let m_one = Q.of_int (-1)
+
+  let print fmt t = Format.fprintf fmt "%s" (Q.to_string t)
+
+  let is_int x = Z.equal Z.one x.Q.den
+
+  let is_zero v = Q.equal v Q.zero
+
+  let is_one v = Q.equal v Q.one
+
+  let mult = Q.mul
+
+  let minus = Q.neg
+
+  let is_m_one v = Q.equal v m_one
+end
+
+module Sim = OcplibSimplex.Basic.Make (Var) (Rat) (Ex)
+
+type eq = { p : Polynome.t; bound : Bound.t; origins : Ground.S.t }
+[@@deriving show]
+(** p <= 0 or p < 0 *)
+
+let divide d (p : Polynome.t) =
+  try
+    (match Polynome.is_cst p with None -> () | Some _ -> raise Exit);
+    if Q.sign p.cst <> 0 then raise Exit;
+    let l = Node.M.bindings p.poly in
+    let l =
+      List.fold_left
+        (fun acc (e, q) ->
+          match
+            ( Dom_product.SolveAbs.get_repr d e,
+              Dom_product.SolveSign.get_repr d e )
+          with
+          | None, _ when Egraph.is_equal d RealValue.zero e -> acc
+          | None, _ | _, None -> raise Exit
+          | Some abs, Some sign -> (abs, sign, q) :: acc)
+        [] l
+    in
+    (* Debug.dprintf4 debug "@[eq:%a@ %a@]" Polynome.pp p
+     *   Fmt.(list ~sep:(any "+") (using CCPair.swap (pair Q.pp Product.pp)))
+     *   l; *)
+    match l with
+    | [] -> raise Exit
+    | (hd, __, _) :: _ ->
+        let common =
+          List.fold_left
+            (fun acc (abs, _, _) ->
+              Node.M.inter
+                (fun _ a b -> if Q.equal a b then Some a else None)
+                acc abs.Product.poly)
+            hd.Product.poly l
+        in
+        let common =
+          Node.M.fold_left
+            (fun acc abs v ->
+              if Dom_interval.is_not_zero d abs then Node.M.add abs v acc
+              else acc)
+            Node.M.empty common
+        in
+        if Node.M.is_empty common then raise Exit;
+        let common = Product.of_map common in
+        Debug.dprintf4 debug "[Simplex] found possible division: %a / |%a|"
+          Polynome.pp p Product.pp common;
+        let cst, l =
+          List.fold_left
+            (fun (cst, acc) (abs, sign, v) ->
+              let abs = Product.div abs common in
+              let pos, sign = Sign_product.extract_cst sign in
+              let v =
+                match pos with Zero -> Q.zero | Pos -> v | Neg -> Q.neg v
+              in
+              match (Product.classify abs, Sign_product.classify sign) with
+              | _, MINUS_ONE -> assert false
+              | ONE, PLUS_ONE -> (Q.add v cst, acc)
+              | NODE n, NODE n' when Egraph.is_equal d n n' ->
+                  (cst, (n, v) :: acc)
+              | _ ->
+                  let n = Dom_product.node_of_product d abs sign in
+                  (cst, (n, v) :: acc))
+            (Q.zero, []) l
+        in
+        Some (Polynome.of_list cst l, common)
+  with Exit -> None
+
+let delta d eq =
+  (* add info to delta *)
+  if Node.M.is_num_elt 2 eq.p.poly then
+    match Node.M.bindings eq.p.poly with
+    | [ (src, a); (dst, b) ] when Q.equal Q.one a && Q.equal Q.minus_one b ->
+        Delta.add d src (Q.neg eq.p.cst) eq.bound dst
+    | [ (dst, b); (src, a) ] when Q.equal Q.one a && Q.equal Q.minus_one b ->
+        Delta.add d src (Q.neg eq.p.cst) eq.bound dst
+    | _ -> ()
+
+let apply d ~f truth g =
+  let aux d bound a b =
+    let bound =
+      if truth then bound
+      else match bound with Bound.Large -> Strict | Strict -> Large
+    in
+    let a, b = if truth then (a, b) else (b, a) in
+    f d bound a b
+  in
+  match Ground.sem g with
+  | { app = { builtin = Expr.Lt }; tyargs = []; args; _ } ->
+      let a, b = IArray.extract2_exn args in
+      aux d Bound.Strict a b
+  | { app = { builtin = Expr.Leq }; tyargs = []; args; _ } ->
+      let a, b = IArray.extract2_exn args in
+      aux d Large a b
+  | { app = { builtin = Expr.Geq }; tyargs = []; args; _ } ->
+      let a, b = IArray.extract2_exn args in
+      aux d Large b a
+  | { app = { builtin = Expr.Gt }; tyargs = []; args; _ } ->
+      let a, b = IArray.extract2_exn args in
+      aux d Strict b a
+  | _ -> assert false
+
+let add_eq d eqs p bound origins =
+  match (Polynome.is_cst p, bound) with
+  | None, _ ->
+      let eq = { p; bound; origins } in
+      delta d eq;
+      eq :: eqs
+  | Some p, Bound.Large when Q.sign p = 0 ->
+      Ground.S.iter
+        (fun g ->
+          let truth = Base.Option.value_exn (Boolean.is d (Ground.node g)) in
+          apply d truth g ~f:(fun d bound a b ->
+              match bound with
+              | Strict
+                when Dom_interval.is_integer d a && Dom_interval.is_integer d b
+                ->
+                  Dom_polynome.assume_equality d a
+                    (Polynome.of_list Q.minus_one [ (b, Q.one) ])
+              | Large ->
+                  Dom_polynome.assume_equality d a (Polynome.monome Q.one b)
+              | Strict -> assert false))
+        origins;
+      eqs
+  | Some p, _ when Q.sign p < 0 ->
+      Debug.dprintf2 debug "[Simplex] discard %a" Ground.S.pp origins;
+      eqs
+  | Some p, bound ->
+      Debug.dprintf4 Debug.contradiction "[LRA/Simplex] Found %a%a0" Q.pp p
+        Bound.pp bound;
+      Egraph.contradiction d
+
+let mk_eq d bound a b =
+  let ( ! ) n =
+    match Dom_polynome.get_repr d n with
+    | None -> Polynome.monome Q.one (Egraph.find_def d n)
+    | Some p -> p
+  in
+  let p, bound' =
+    match bound with
+    | Bound.Strict
+      when Dom_interval.is_integer d a && Dom_interval.is_integer d b ->
+        (Polynome.add_cst (Polynome.sub !a !b) Q.one, Bound.Large)
+    | _ -> (Polynome.sub !a !b, bound)
+  in
+  ( p,
+    bound',
+    Polynome.sub (Polynome.monome Q.one a) (Polynome.monome Q.one b),
+    bound )
+
+let make_equations d (eqs, vars) g =
+  Debug.dprintf2 debug "[Simplex] %a" Ground.pp g;
+  match Boolean.is d (Ground.node g) with
+  | None -> (eqs, vars)
+  | Some truth -> (
+      let p, bound, p_non_norm, bound_non_norm = apply d ~f:mk_eq truth g in
+      Debug.dprintf6 debug "[Simplex] %a(%a)%a0" Polynome.pp p Polynome.pp
+        p_non_norm Bound.pp bound;
+      let eqs, vars =
+        ( add_eq d eqs p bound (Ground.S.singleton g),
+          Node.M.union_merge (fun _ _ _ -> Some ()) vars p.Polynome.poly )
+      in
+      match divide d p_non_norm with
+      | Some (p', _) ->
+          let p' = Dom_polynome.normalize d p' in
+          ( add_eq d eqs p' bound_non_norm Ground.S.empty,
+            Node.M.union_merge (fun _ _ _ -> Some ()) vars p'.Polynome.poly )
+      | None -> (eqs, vars))
+
+let find_equalities d vars (env : Sim.Core.t) (s : Sim.Core.solution Lazy.t) =
+  (* Env must be sat *)
+  let val_of_sol s =
+    let s = Lazy.force s in
+    let h = Node.H.create 10 in
+    Base.List.iter ~f:(fun (n, q) -> Node.H.replace h n q) s.Sim.Core.main_vars;
+    h
+  in
+  let partition l s =
+    let h = val_of_sol s in
+    let aux l =
+      let l =
+        Base.List.stable_sort
+          ~compare:(fun n1 n2 ->
+            Q.compare (Node.H.find h n1) (Node.H.find h n2))
+          l
+      in
+      let l =
+        Base.List.group
+          ~break:(fun n1 n2 ->
+            not (Q.equal (Node.H.find h n1) (Node.H.find h n2)))
+          l
+      in
+
+      let l =
+        Base.List.filter ~f:(function [] | [ _ ] -> false | _ -> true) l
+      in
+      l
+    in
+    let l = Base.List.concat_map ~f:aux l in
+    (* Debug.dprintf1 debug "partition %s" ([%show: Node.t list list] l); *)
+    l
+  in
+  let pair_seen = Node.H.create 10 in
+  let add_pair_seen a b =
+    let h = Node.H.memo (fun _ -> Node.H.create 10) pair_seen a in
+    Node.H.add_new Impossible h b ()
+  in
+  let one_dist env a b =
+    (* Debug.dprintf4 debug "one_dist %a %a" Node.pp a Node.pp b; *)
+    let p = Sim.Core.P.from_list [ (a, Q.one); (b, Q.minus_one) ] in
+    let env, opt = Sim.Solve.maximize env p in
+    match Sim.Result.get opt env with
+    | Sim.Core.Unknown -> assert false
+    | Sim.Core.Unsat _ -> assert false
+    | Sim.Core.Sat _ -> assert false
+    | Sim.Core.Unbounded s ->
+        let s' = Lazy.force s in
+        let qa = Base.List.Assoc.find_exn ~equal:Node.equal s'.main_vars a in
+        let qb = Base.List.Assoc.find_exn ~equal:Node.equal s'.main_vars b in
+        (if Q.equal qa qb then
+         let a, b = if Node.compare a b < 0 then (a, b) else (b, a) in
+         (* Debug.dprintf4 debug "pair_seen %a %a" Node.pp a Node.pp b; *)
+         add_pair_seen a b);
+        (`Distinct, env, s)
+    | Sim.Core.Max (m, s) ->
+        Debug.dprintf2 debug "Max %a" Q.pp (Lazy.force m).max_v;
+        let s' = Lazy.force s in
+        let qa = Base.List.Assoc.find_exn ~equal:Node.equal s'.main_vars a in
+        let qb = Base.List.Assoc.find_exn ~equal:Node.equal s'.main_vars b in
+        if Q.equal qa qb then (`NotDistinct, env, s) else (`Distinct, env, s)
+  in
+  let rec test_equality env l =
+    match l with
+    | [] -> env
+    | [ _ ] :: l -> test_equality env l
+    | [] :: _ -> assert false
+    | (a :: l1) :: l2 -> (
+        let skip =
+          match Node.H.find_opt pair_seen a with
+          | None -> Base.List.hd l1
+          | Some h -> Base.List.find l1 ~f:(fun b -> not (Node.H.mem h b))
+        in
+        match skip with
+        | None -> test_equality env (l1 :: l2)
+        | Some b -> (
+            match one_dist env a b with
+            | `Distinct, env, s ->
+                Debug.dprintf1 debug "Distinct %s"
+                  ([%show: (Node.t * Q.t) list]
+                     (Lazy.force s).Sim.Core.main_vars);
+                let l = partition l s in
+                test_equality env l
+            | `NotDistinct, env, s -> (
+                let l = partition l s in
+                match one_dist env b a with
+                | `Distinct, env, s ->
+                    let l = partition l s in
+                    test_equality env l
+                | `NotDistinct, env, s -> (
+                    let l = partition l s in
+                    Egraph.merge d a b;
+                    match l with
+                    | [] -> assert false
+                    | ([] | [ _ ]) :: _ -> assert false
+                    | (a' :: l1) :: l2 ->
+                        assert (Node.equal a a');
+                        test_equality env (l1 :: l2)))))
+  in
+  let l = [ Node.S.elements vars ] in
+  let l = partition l s in
+  test_equality env l
+
+let update_domains d env =
+  let update_domain n ((v : Sim.Core.var_info), _) =
+    if Egraph.is_registered d n then
+      let inf =
+        Base.Option.map
+          ~f:(fun (q1, q2) ->
+            let s = Q.sign q2 in
+            let b =
+              if s = 0 then Bound.Large
+              else if s > 0 then Strict
+              else assert false
+              (* Why? *)
+            in
+            (q1, b))
+          v.mini
+      in
+      let sup =
+        Base.Option.map
+          ~f:(fun (q1, q2) ->
+            let s = Q.sign q2 in
+            let b =
+              if s = 0 then Bound.Large
+              else if s < 0 then Strict
+              else assert false
+              (* Why? *)
+            in
+            (q1, b))
+          v.maxi
+      in
+      let v = Dom_interval.D.from_convexe_hull (inf, sup) in
+      if not (Dom_interval.D.is_reals v) then (
+        Debug.dprintf4 debug "Propagate %a: %a" Node.pp n Dom_interval.D.pp v;
+        Dom_interval.upd_dom d n v)
+  in
+  Sim.Core.MX.iter update_domain env.Sim.Core.basic;
+  Sim.Core.MX.iter update_domain env.non_basic
+
+let simplex (d : Egraph.wt) =
+  Debug.dprintf0 debug "[Simplex]";
+  Debug.incr stats_run;
+  Datastructure.Ref.set scheduled d false;
+  let eqs, vars =
+    Datastructure.Push.fold comparisons d ~f:(make_equations d)
+      ~init:([], Node.S.empty)
+  in
+  let env = Sim.Core.empty ~is_int:false ~check_invs:false ~debug:0 in
+  let of_poly (p : Polynome.t) =
+    Node.M.fold
+      (fun n r acc -> fst (Sim.Core.P.accumulate n r acc))
+      p.poly Sim.Core.P.empty
+  in
+  let of_bound_sup q = function
+    | Bound.Large -> (q, Q.zero)
+    | Strict -> (q, Q.minus_one)
+  in
+  let of_bound_inf q = function
+    | Bound.Large -> (q, Q.zero)
+    | Strict -> (q, Q.one)
+  in
+  let add_vars env v =
+    let inf, sup =
+      match Egraph.get_dom d Dom_interval.dom v with
+      | None -> (None, None)
+      | Some d -> Dom_interval.D.get_convexe_hull d
+    in
+    let app f = function None -> None | Some (q, b) -> Some (f q b) in
+    let env, _ =
+      Sim.Assert.var env v (app of_bound_inf inf) () (app of_bound_sup sup) ()
+    in
+    env
+  in
+  let env = Node.S.fold_left add_vars env vars in
+  (* Debug.dprintf2 debug "[Simplex] after_adding variables: %a"
+   *   (Sim.Core.print Unknown) env; *)
+  let add_eqs env eq =
+    assert (not (Node.M.is_empty eq.p.poly));
+    if Node.M.is_num_elt 1 eq.p.poly then
+      let n, q = Node.M.choose eq.p.poly in
+      if Q.sign q < 0 then
+        let b = of_bound_inf (Q.neg (Q.div eq.p.cst q)) eq.bound in
+        let env, _ = Sim.Assert.var env n (Some b) () None () in
+        env
+      else
+        let b = of_bound_sup (Q.neg (Q.div eq.p.cst q)) eq.bound in
+        let env, _ = Sim.Assert.var env n None () (Some b) () in
+        env
+    else
+      let b = of_bound_sup (Q.neg eq.p.cst) eq.bound in
+      let p = Polynome.sub_cst eq.p eq.p.cst in
+      let n = Dom_polynome.node_of_polynome d p in
+      let env, _ = Sim.Assert.poly env (of_poly p) n None () (Some b) () in
+      env
+  in
+  let env = List.fold_left add_eqs env eqs in
+  let env = Sim.Solve.solve env in
+  let res = Sim.Result.get None env in
+  (* Debug.dprintf2 debug "[Simplex] Solving done: %a" (Sim.Core.print res) env; *)
+  match res with
+  | Sim.Core.Unknown -> assert false
+  | Sim.Core.Unsat _ -> Egraph.contradiction d
+  | Sim.Core.Unbounded _ -> assert false
+  | Sim.Core.Max (_, _) -> assert false
+  | Sim.Core.Sat s ->
+      let env = find_equalities d vars env s in
+      update_domains d env
+
+module Daemon = struct
+  let key =
+    Events.Dem.create
+      (module struct
+        type t = unit
+
+        let name = "LRA.simplex"
+      end)
+
+  let enqueue d _ =
+    if Datastructure.Ref.get scheduled d then (
+      Debug.dprintf0 debug "[Scheduler] Simplex? No";
+      Events.EnqAlready)
+    else (
+      Debug.dprintf0 debug "[Scheduler] Simplex? Yes";
+      Datastructure.Ref.set scheduled d true;
+      Events.EnqRun (key, (), None))
+
+  let delay = Events.Delayed_by 64
+
+  type runable = unit
+
+  let print_runable = Unit.pp
+
+  let run d () = simplex d
+end
+
+let () = Events.register (module Daemon)
+
+(** {2 Initialization} *)
+let converter d (f : Ground.t) =
+  match Ground.sem f with
+  | {
+   app = { builtin = Expr.Lt | Expr.Leq | Expr.Geq | Expr.Gt };
+   tyargs = [];
+   args;
+  } ->
+      let attach n =
+        Dom_polynome.events_repr_change d ~node:n Daemon.enqueue;
+        Events.attach_repr d n Daemon.enqueue
+      in
+      IArray.iter ~f:attach args;
+      Events.attach_value d (Ground.node f) Boolean.dom (fun d n _ ->
+          Daemon.enqueue d n);
+      Datastructure.Push.push comparisons d f;
+      Events.new_pending_daemon d Daemon.key ();
+      Choice.register d f (Boolean.chobool (Ground.node f))
+  | _ -> ()
+
+let init env = Ground.register_converter env converter
diff --git a/src_colibri2/theories/LRA/simplex.mli b/src_colibri2/theories/LRA/simplex.mli
new file mode 100644
index 000000000..c0983bff5
--- /dev/null
+++ b/src_colibri2/theories/LRA/simplex.mli
@@ -0,0 +1,21 @@
+(*************************************************************************)
+(*  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).           *)
+(*************************************************************************)
+
+val init : Egraph.wt -> unit
diff --git a/src_colibri2/theories/LRA/stages/interval_sig.ml b/src_colibri2/theories/LRA/stages/interval_sig.ml
index cff021537..f0894e63e 100644
--- a/src_colibri2/theories/LRA/stages/interval_sig.ml
+++ b/src_colibri2/theories/LRA/stages/interval_sig.ml
@@ -98,6 +98,9 @@ module type S = sig
   (* val choose_rnd : (int -> int) -> t -> Q.t
    * (\** choose an element randomly (but non-uniformly), the given function is
    *       the random generator *\)
-   * 
-   * val get_convexe_hull: t -> (Q.t * bound) option * (Q.t * bound) option *)
+   *)
+
+  val get_convexe_hull : t -> (Q.t * Bound.t) option * (Q.t * Bound.t) option
+
+  val from_convexe_hull : (Q.t * Bound.t) option * (Q.t * Bound.t) option -> t
 end
diff --git a/src_colibri2/theories/LRA/stages/stage0/dune b/src_colibri2/theories/LRA/stages/stage0/dune
index f3c33491d..9a8de2a2e 100644
--- a/src_colibri2/theories/LRA/stages/stage0/dune
+++ b/src_colibri2/theories/LRA/stages/stage0/dune
@@ -5,7 +5,7 @@
             colibri2.core colibri2.theories.bool
             colibri2.theories.quantifiers colibri2.theories.LRA.stages.def)
  (preprocess
-  (pps ppx_deriving.std ppx_hash))
+  (pps ppx_deriving.std ppx_hash ppx_here))
  (flags -open Colibri2_theories_LRA_stages_def -open Colibri2_stdlib -open Std)
  (synopsis "Sign domain")
 )
diff --git a/src_colibri2/theories/LRA/stages/stage0/integer_sign_domain.ml b/src_colibri2/theories/LRA/stages/stage0/integer_sign_domain.ml
index 33178987e..cc8999e05 100644
--- a/src_colibri2/theories/LRA/stages/stage0/integer_sign_domain.ml
+++ b/src_colibri2/theories/LRA/stages/stage0/integer_sign_domain.ml
@@ -150,3 +150,16 @@ let is_reals t = t.noninteger && Sign_domain.is_reals t.sign
 let choose t = Sign_domain.choose t.sign
 
 let is_integer t = not t.noninteger
+
+let get_convexe_hull t =
+  let inf, sup = Sign_domain.get_convexe_hull t.sign in
+  let checkint dir = function
+    | x when t.noninteger -> x
+    | None -> None
+    | Some (z, Bound.Strict) when Q.is_zero z -> Some (dir, Large)
+    | x -> x
+  in
+  (checkint Q.one inf, checkint Q.minus_one sup)
+
+let from_convexe_hull ch =
+  { sign = Sign_domain.from_convexe_hull ch; noninteger = true }
diff --git a/src_colibri2/theories/LRA/stages/stage0/sign_domain.ml b/src_colibri2/theories/LRA/stages/stage0/sign_domain.ml
index 5f458f933..0b1574fab 100644
--- a/src_colibri2/theories/LRA/stages/stage0/sign_domain.ml
+++ b/src_colibri2/theories/LRA/stages/stage0/sign_domain.ml
@@ -378,3 +378,45 @@ let gt' v = { neg = v.neg; zero = v.neg; pos = v.pos || v.zero || v.neg }
 let integers = reals
 
 let is_integer _ = false
+
+let get_convexe_hull v =
+  let inf =
+    match (v.neg, v.zero, v.pos) with
+    | true, _, _ -> None
+    | false, true, _ -> Some (Q.zero, Bound.Large)
+    | false, false, true -> Some (Q.zero, Bound.Strict)
+    | false, false, false -> assert false
+    (* absurd: bottom *)
+  in
+  let sup =
+    match (v.neg, v.zero, v.pos) with
+    | _, _, true -> None
+    | _, true, false -> Some (Q.zero, Bound.Large)
+    | true, false, false -> Some (Q.zero, Bound.Strict)
+    | false, false, false -> assert false
+    (* absurd: bottom *)
+  in
+  (inf, sup)
+
+let from_convexe_hull (inf, sup) =
+  let d1 =
+    match inf with
+    | None -> reals
+    | Some (q, b) ->
+        let s = Q.sign q in
+        if s > 0 then pos
+        else if s = 0 then
+          match b with Bound.Large -> pos_or_zero | Strict -> pos
+        else reals
+  in
+  let d2 =
+    match sup with
+    | None -> reals
+    | Some (q, b) ->
+        let s = Q.sign q in
+        if s < 0 then neg
+        else if s = 0 then
+          match b with Bound.Large -> neg_or_zero | Strict -> neg
+        else reals
+  in
+  Option.value_exn ~here:[%here] (inter d1 d2)
diff --git a/src_colibri2/theories/quantifier/common.ml b/src_colibri2/theories/quantifier/common.ml
index 21405040c..0bf08501f 100644
--- a/src_colibri2/theories/quantifier/common.ml
+++ b/src_colibri2/theories/quantifier/common.ml
@@ -28,5 +28,11 @@ let debug_full =
 
 let nb_instantiation = Debug.register_stats_int ~name:"instantiation" ~init:0
 
+let nb_eager_instantiation =
+  Debug.register_stats_int ~name:"eager_instantiation" ~init:0
+
+let nb_delayed_instantiation =
+  Debug.register_stats_int ~name:"delayed_instantiation" ~init:0
+
 let nb_new_instantiation =
   Debug.register_stats_int ~name:"new_instantiation" ~init:0
diff --git a/src_colibri2/theories/quantifier/trigger.ml b/src_colibri2/theories/quantifier/trigger.ml
index 3f9a5cb78..f17bb56d0 100644
--- a/src_colibri2/theories/quantifier/trigger.ml
+++ b/src_colibri2/theories/quantifier/trigger.ml
@@ -378,9 +378,12 @@ let instantiate d tri subst =
          (fun pat ->
            not (Node.S.is_empty (Pattern.check_term_exists d subst pat)))
          tri.checks
-  then instantiate_aux d tri subst
+  then (
+    Debug.incr nb_eager_instantiation;
+    instantiate_aux d tri subst)
   else (
     Debug.dprintf0 debug "[Quant] Delayed";
+    Debug.incr nb_delayed_instantiation;
     Events.new_pending_daemon d Delayed_instantiation.key (tri, subst))
 
 let match_ d tri n =
diff --git a/src_common/union.mlw b/src_common/union.mlw
index 2e5251be9..9003b7272 100644
--- a/src_common/union.mlw
+++ b/src_common/union.mlw
@@ -500,155 +500,154 @@ module Union
           end
 
 
+      let rec union_on_on (u:on) (v:on) : on
+        requires { ordered_on u }
+        requires { ordered_on v }
+        ensures { ordered_on result }
+        ensures {
+          forall x:real. (mem_on x u \/ mem_on x v) <-> mem_on x result
+        }
+        ensures {
+          forall q.
+          (lt_bound_on q u) -> (lt_bound_on q v) ->
+          (lt_bound_on q result )
+        }
+        variant { length_on u + length_on v } =
+        match u, v with
+        | _, OnInf | OnInf, _ -> OnInf
+        | OnSin qu lu, OnSin qv lv ->
+          match Q.compare qu qv with
+          | Ord.Eq -> OnSin qu (union_on_on lu lv)
+          | Ord.Lt -> smaller_lt_bound_on qu qv lv; (union_on_on lu v)
+          | Ord.Gt -> smaller_lt_bound_on qv qu lu; (union_on_on u lv)
+          end
+        | OnEnd qu bu lu, OnEnd qv bv lv ->
+            match Q.compare qu qv with
+             | Ord.Eq ->
+               let b = match bu, bv with
+                 | Strict, Strict -> Strict
+                 | _ -> Large
+                 end
+               in
+               lt_bound_is_not_mem_off qu lv;
+               lt_bound_is_not_mem_off qu lu;
+               OnEnd qu b (union_off_off lu lv)
+             | Ord.Lt -> smaller_lt_bound_off qu qv lv; (union_on_off v lu)
+             | Ord.Gt -> smaller_lt_bound_off qv qu lu; (union_on_off u lv)
+            end
+        | (OnSin qu lu) as u, (OnEnd qv bv lv) as v
+        | (OnEnd qv bv lv) as v, (OnSin qu lu) as u ->
+            lt_bound_is_not_mem_off qv lv;
+            match Q.compare qu qv with
+             | Ord.Eq ->
+               smaller_lt_bound_on qv qu lu;
+               match bv with
+                 | Strict -> OnSin qv (union_on_off lu lv)
+                 | _ -> (union_on_off lu lv)
+                 end
+             | Ord.Lt -> smaller_lt_bound_off qu qv lv; (union_on_on lu v)
+             | Ord.Gt -> smaller_lt_bound_on qv qu lu; (union_on_off u lv)
+            end
+        end
+      with  union_on_off (u:on) (v:off) : on
+        requires { ordered_on u }
+        requires { ordered_off v }
+        ensures { ordered_on result }
+        ensures {
+          forall x:real. (mem_on x u \/ mem_off x v) <-> mem_on x result
+        }
+        ensures {
+          forall q.
+          (lt_bound_on q u) -> (lt_bound_off q v) ->
+          (lt_bound_on q result )
+        }
+        variant { length_on u + length_off v } =
+        match u, v with
+        | u, OffInf -> u
+        | OnInf, _ -> OnInf
+        | OnSin qu lu, OffSin qv lv ->
+          lt_bound_is_not_mem_off qv lv;
+          match Q.compare qu qv with
+          | Ord.Eq -> union_on_off lu lv
+          | Ord.Lt -> smaller_lt_bound_off qu qv lv; OnSin qu (union_on_off lu v)
+          | Ord.Gt -> smaller_lt_bound_on  qv qu lu; assert { lt_bound_on qv u };
+                      (union_on_off u lv)
+          end
+        | OnEnd qu bu lu, OffEnd qv bv lv ->
+            lt_bound_is_not_mem_off qu lu;
+            match Q.compare qu qv with
+             | Ord.Eq ->
+               match bu, bv with
+                 | Strict, Strict -> OnSin qu (union_on_off lv lu)
+                 | _ -> (union_on_off lv lu)
+                 end
+             | Ord.Lt -> smaller_lt_bound_on qu qv lv; OnEnd qu bu (union_off_off lu v)
+             | Ord.Gt -> (union_on_on u lv)
+            end
+        | (OnSin qu lu) as u, (OffEnd qv bv lv) as v ->
+            match Q.compare qu qv with
+             | Ord.Eq -> match bv with Large -> (union_on_on lu lv) | Strict -> OnSin qu (union_on_on lu lv) end
+             | Ord.Lt -> smaller_lt_bound_on qu qv lv; OnSin qu (union_on_off lu v)
+             | Ord.Gt -> (union_on_on u lv)
+            end
+        | (OnEnd qv bv lv) as v, (OffSin qu lu) as u ->
+            lt_bound_is_not_mem_off qu lu;
+            lt_bound_is_not_mem_off qv lv;
+            match Q.compare qu qv with
+             | Ord.Eq -> OnEnd qv Large (union_off_off lu lv)
+             | Ord.Lt -> (union_on_off v lu)
+             | Ord.Gt -> smaller_lt_bound_off qv qu lu; OnEnd qv bv (union_off_off u lv)
+            end
+        end
+      with union_off_off (u:off) (v:off) : off
+        requires { ordered_off u}
+        requires { ordered_off v }
+        ensures { ordered_off result }
+        ensures {
+          forall x:real. (mem_off x u \/ mem_off x v) <-> mem_off x result
+        }
+        ensures {
+          forall q.
+          (lt_bound_off q u) -> (lt_bound_off q v) ->
+          (lt_bound_off q result )
+        }
+        variant { length_off u + length_off v } =
+        match u, v with
+        | u, OffInf | OffInf, u -> u
+        | OffSin qu lu, OffSin qv lv ->
+          lt_bound_is_not_mem_off qv lv;
+          lt_bound_is_not_mem_off qu lu;
+          match Q.compare qu qv with
+          | Ord.Eq -> OffSin qu (union_off_off lu lv)
+          | Ord.Lt -> smaller_lt_bound_off qu qv lv; OffSin qu (union_off_off lu v)
+          | Ord.Gt -> smaller_lt_bound_off qv qu lu; OffSin qv (union_off_off u lv)
+          end
+        | OffEnd qu bu lu, OffEnd qv bv lv ->
+            match Q.compare qu qv with
+             | Ord.Eq ->
+               let b = match bu, bv with
+                 | Strict, Strict -> Strict
+                 | _ -> Large
+                 end
+               in
+               OffEnd qu b (union_on_on lu lv)
+             | Ord.Lt -> smaller_lt_bound_on qu qv lv; OffEnd qu bu (union_on_off lu v)
+             | Ord.Gt -> smaller_lt_bound_on qv qu lu; OffEnd qv bv (union_on_off lv u)
+            end
+        | (OffSin qu lu) as u, (OffEnd qv bv lv) as v
+        | (OffEnd qv bv lv) as v, (OffSin qu lu) as u ->
+            lt_bound_is_not_mem_off qu lu;
+            match Q.compare qu qv with
+             | Ord.Eq -> smaller_lt_bound_off qv qu lu; OffEnd qv Large (union_on_off lv lu)
+             | Ord.Lt -> smaller_lt_bound_on  qu qv lv; OffSin qu (union_off_off lu v)
+             | Ord.Gt -> smaller_lt_bound_off qv qu lu; OffEnd qv bv (union_on_off lv u)
+            end
+        end
+
     let union (u:t') (v:t') : t'
        ensures {
          forall x:real. (mem x u.a \/ mem x v.a) <-> mem x result.a
        } =
-
-         let rec union_on_on (u:on) (v:on) : on
-           requires { ordered_on u }
-           requires { ordered_on v }
-           ensures { ordered_on result }
-           ensures {
-             forall x:real. (mem_on x u \/ mem_on x v) <-> mem_on x result
-           }
-           ensures {
-             forall q.
-             (lt_bound_on q u) -> (lt_bound_on q v) ->
-             (lt_bound_on q result )
-           }
-           variant { length_on u + length_on v } =
-           match u, v with
-           | _, OnInf | OnInf, _ -> OnInf
-           | OnSin qu lu, OnSin qv lv ->
-             match Q.compare qu qv with
-             | Ord.Eq -> OnSin qu (union_on_on lu lv)
-             | Ord.Lt -> smaller_lt_bound_on qu qv lv; (union_on_on lu v)
-             | Ord.Gt -> smaller_lt_bound_on qv qu lu; (union_on_on u lv)
-             end
-           | OnEnd qu bu lu, OnEnd qv bv lv ->
-               match Q.compare qu qv with
-                | Ord.Eq ->
-                  let b = match bu, bv with
-                    | Strict, Strict -> Strict
-                    | _ -> Large
-                    end
-                  in
-                  lt_bound_is_not_mem_off qu lv;
-                  lt_bound_is_not_mem_off qu lu;
-                  OnEnd qu b (union_off_off lu lv)
-                | Ord.Lt -> smaller_lt_bound_off qu qv lv; (union_on_off v lu)
-                | Ord.Gt -> smaller_lt_bound_off qv qu lu; (union_on_off u lv)
-               end
-           | (OnSin qu lu) as u, (OnEnd qv bv lv) as v
-           | (OnEnd qv bv lv) as v, (OnSin qu lu) as u ->
-               lt_bound_is_not_mem_off qv lv;
-               match Q.compare qu qv with
-                | Ord.Eq ->
-                  smaller_lt_bound_on qv qu lu;
-                  match bv with
-                    | Strict -> OnSin qv (union_on_off lu lv)
-                    | _ -> (union_on_off lu lv)
-                    end
-                | Ord.Lt -> smaller_lt_bound_off qu qv lv; (union_on_on lu v)
-                | Ord.Gt -> smaller_lt_bound_on qv qu lu; (union_on_off u lv)
-               end
-           end
-         with  union_on_off (u:on) (v:off) : on
-           requires { ordered_on u }
-           requires { ordered_off v }
-           ensures { ordered_on result }
-           ensures {
-             forall x:real. (mem_on x u \/ mem_off x v) <-> mem_on x result
-           }
-           ensures {
-             forall q.
-             (lt_bound_on q u) -> (lt_bound_off q v) ->
-             (lt_bound_on q result )
-           }
-           variant { length_on u + length_off v } =
-           match u, v with
-           | u, OffInf -> u
-           | OnInf, _ -> OnInf
-           | OnSin qu lu, OffSin qv lv ->
-             lt_bound_is_not_mem_off qv lv;
-             match Q.compare qu qv with
-             | Ord.Eq -> union_on_off lu lv
-             | Ord.Lt -> smaller_lt_bound_off qu qv lv; OnSin qu (union_on_off lu v)
-             | Ord.Gt -> smaller_lt_bound_on  qv qu lu; assert { lt_bound_on qv u };
-                         (union_on_off u lv)
-             end
-           | OnEnd qu bu lu, OffEnd qv bv lv ->
-               lt_bound_is_not_mem_off qu lu;
-               match Q.compare qu qv with
-                | Ord.Eq ->
-                  match bu, bv with
-                    | Strict, Strict -> OnSin qu (union_on_off lv lu)
-                    | _ -> (union_on_off lv lu)
-                    end
-                | Ord.Lt -> smaller_lt_bound_on qu qv lv; OnEnd qu bu (union_off_off lu v)
-                | Ord.Gt -> (union_on_on u lv)
-               end
-           | (OnSin qu lu) as u, (OffEnd qv bv lv) as v ->
-               match Q.compare qu qv with
-                | Ord.Eq -> match bv with Large -> (union_on_on lu lv) | Strict -> OnSin qu (union_on_on lu lv) end
-                | Ord.Lt -> smaller_lt_bound_on qu qv lv; OnSin qu (union_on_off lu v)
-                | Ord.Gt -> (union_on_on u lv)
-               end
-           | (OnEnd qv bv lv) as v, (OffSin qu lu) as u ->
-               lt_bound_is_not_mem_off qu lu;
-               lt_bound_is_not_mem_off qv lv;
-               match Q.compare qu qv with
-                | Ord.Eq -> OnEnd qv Large (union_off_off lu lv)
-                | Ord.Lt -> (union_on_off v lu)
-                | Ord.Gt -> smaller_lt_bound_off qv qu lu; OnEnd qv bv (union_off_off u lv)
-               end
-           end
-         with union_off_off (u:off) (v:off) : off
-           requires { ordered_off u}
-           requires { ordered_off v }
-           ensures { ordered_off result }
-           ensures {
-             forall x:real. (mem_off x u \/ mem_off x v) <-> mem_off x result
-           }
-           ensures {
-             forall q.
-             (lt_bound_off q u) -> (lt_bound_off q v) ->
-             (lt_bound_off q result )
-           }
-           variant { length_off u + length_off v } =
-           match u, v with
-           | u, OffInf | OffInf, u -> u
-           | OffSin qu lu, OffSin qv lv ->
-             lt_bound_is_not_mem_off qv lv;
-             lt_bound_is_not_mem_off qu lu;
-             match Q.compare qu qv with
-             | Ord.Eq -> OffSin qu (union_off_off lu lv)
-             | Ord.Lt -> smaller_lt_bound_off qu qv lv; OffSin qu (union_off_off lu v)
-             | Ord.Gt -> smaller_lt_bound_off qv qu lu; OffSin qv (union_off_off u lv)
-             end
-           | OffEnd qu bu lu, OffEnd qv bv lv ->
-               match Q.compare qu qv with
-                | Ord.Eq ->
-                  let b = match bu, bv with
-                    | Strict, Strict -> Strict
-                    | _ -> Large
-                    end
-                  in
-                  OffEnd qu b (union_on_on lu lv)
-                | Ord.Lt -> smaller_lt_bound_on qu qv lv; OffEnd qu bu (union_on_off lu v)
-                | Ord.Gt -> smaller_lt_bound_on qv qu lu; OffEnd qv bv (union_on_off lv u)
-               end
-           | (OffSin qu lu) as u, (OffEnd qv bv lv) as v
-           | (OffEnd qv bv lv) as v, (OffSin qu lu) as u ->
-               lt_bound_is_not_mem_off qu lu;
-               match Q.compare qu qv with
-                | Ord.Eq -> smaller_lt_bound_off qv qu lu; OffEnd qv Large (union_on_off lv lu)
-                | Ord.Lt -> smaller_lt_bound_on  qu qv lv; OffSin qu (union_off_off lu v)
-                | Ord.Gt -> smaller_lt_bound_off qv qu lu; OffEnd qv bv (union_on_off lv u)
-               end
-           end
-           in
           match u.a,v.a with
           | On u, On v -> { a = On (union_on_on u v) }
           | On u, Off v | Off v, On u -> { a = On (union_on_off u v) }
@@ -846,252 +845,252 @@ module Union
 
   use real.MinMax
 
-  let add_interval l (bu:Bound.t) (u:Q.t) (v:Q.t) (bv:Bound.t): (result:t',ghost fq':real -> real)
+  let rec add_interval_on (bu:Bound.t) (u:Q.t) (v:Q.t) (bv:Bound.t) (l:on) : (result:on,ghost fq':real -> real)
     requires { Q.(u < v) }
-    ensures {
-       forall q q'. (mem q l.a /\ cmp u bu q' /\ cmp q' bv v) -> mem (q+.q') result.a
-     }
-    ensures {
-       forall q. mem q result.a -> (mem (fq' q) l.a /\ cmp u bu (q-.(fq' q)) /\ cmp (q-.(fq' q)) bv v)
-    }
+    requires { ordered_on l }
+    ensures { ordered_on result }
+    ensures { forall q. (lt_bound_on q l) -> (lt_bound_on (q+.u) result) }
+    ensures { forall q q'. (mem_on q l /\ cmp u bu q' /\ cmp q' bv v) -> mem_on (q+.q') result }
+    ensures { forall q. mem_on q result -> (mem_on (fq' q) l /\ cmp u bu (q-.(fq' q)) /\ cmp (q-.(fq' q)) bv v) }
+    variant { length_on l }
    =
-    let rec add_interval_on (bu:Bound.t) (u:Q.t) (v:Q.t) (bv:Bound.t) (l:on) : (result:on,ghost fq':real -> real)
-      requires { Q.(u < v) }
-      requires { ordered_on l }
-      ensures { ordered_on result }
-      ensures { forall q. (lt_bound_on q l) -> (lt_bound_on (q+.u) result) }
-      ensures { forall q q'. (mem_on q l /\ cmp u bu q' /\ cmp q' bv v) -> mem_on (q+.q') result }
-      ensures { forall q. mem_on q result -> (mem_on (fq' q) l /\ cmp u bu (q-.(fq' q)) /\ cmp (q-.(fq' q)) bv v) }
-      variant { length_on l }
-     =
-       match l with
-       | OnSin qs l' ->
-          assert { forall q'. mem_on q' l -> mem_on q' l'};
-          let res,fq' = add_interval_on bu u v bv l' in
-          let ghost space_right = lt_bound_on_give_space (Q.real qs) l' in
-          let ghost fq'' (q:real)
-             ensures { mem_on q res -> (mem_on result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v) }
-            =
-            let q' = fq' q in
-            if pure { q' = Q.real qs } then
-               if pure { (q-.q') = v } then
-                 if pure { (space_right-.qs) <. (v-.u) } then
-                   pure { qs +. ((space_right-.qs)*.0.5) }
-                 else
-                  pure {qs +. ((v-.u) *.0.5) }
-               else
-                 pure { q' -. (v -. (q-.q'))*.0.5 }
-            else q'
-          in
-          (res,fq'')
-       | OnEnd qs bq l' ->
-         lt_bound_is_not_mem_off qs l';
-         let br = add_bound bq bv in
-         let r = Q.(qs+v) in
-         let res, fq = add_interval_off_remain bu u v bv r br l' in
-         let ghost fq' (q:real) : real
+     match l with
+     | OnSin qs l' ->
+        assert { forall q'. mem_on q' l -> mem_on q' l'};
+        let res,fq' = add_interval_on bu u v bv l' in
+        let ghost space_right = lt_bound_on_give_space (Q.real qs) l' in
+        let ghost fq'' (q:real)
            ensures { mem_on q res -> (mem_on result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v) }
-         =
-            if pure { cmp q br r }
-            then if pure { q = qs+.v } then Q.real qs
-            else if pure { q <. qs+.v*.0.5+.u*.0.5 } then pure { q -. (v*.0.5+.u*.0.5)} else let d = Q.real qs+.Q.real v-.q in Q.real qs -. d*.0.5
-            else fq q
-         in
-         res, fq'
-       | OnInf -> (OnInf,ghost fun q -> q-.Q.real u*.0.5-.Q.real v*.0.5)
-       end
+          =
+          let q' = fq' q in
+          if pure { q' = Q.real qs } then
+             if pure { (q-.q') = v } then
+               if pure { (space_right-.qs) <. (v-.u) } then
+                 pure { qs +. ((space_right-.qs)*.0.5) }
+               else
+                pure {qs +. ((v-.u) *.0.5) }
+             else
+               pure { q' -. (v -. (q-.q'))*.0.5 }
+          else q'
+        in
+        (res,fq'')
+     | OnEnd qs bq l' ->
+       lt_bound_is_not_mem_off qs l';
+       let br = add_bound bq bv in
+       let r = Q.(qs+v) in
+       let res, fq = add_interval_off_remain bu u v bv r br l' in
+       let ghost fq' (q:real) : real
+         ensures { mem_on q res -> (mem_on result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v) }
+       =
+          if pure { cmp q br r }
+          then if pure { q = qs+.v } then Q.real qs
+          else if pure { q <. qs+.v*.0.5+.u*.0.5 } then pure { q -. (v*.0.5+.u*.0.5)} else let d = Q.real qs+.Q.real v-.q in Q.real qs -. d*.0.5
+          else fq q
+       in
+       res, fq'
+     | OnInf -> (OnInf,ghost fun q -> q-.Q.real u*.0.5-.Q.real v*.0.5)
+     end
 
-    with add_interval_off (bu:Bound.t) (u:Q.t) (v:Q.t) (bv:Bound.t) (l:off) : (result:off,ghost fq':real -> real)
-      requires { Q.(u < v) }
-      requires { ordered_off l }
-      ensures { ordered_off result }
-      ensures { forall q. (lt_bound_off q l) -> (lt_bound_off (q+.u) result) }
-      ensures { forall q q'. (mem_off q l /\ cmp u bu q' /\ cmp q' bv v) -> mem_off (q+.q') result }
-      ensures { forall q. mem_off q result -> (mem_off (fq' q) l /\ cmp u bu (q-.(fq' q)) /\ cmp (q-.(fq' q)) bv v) }
-      variant { length_off l }
-     =
-       match l with
-       | OffSin qs l' ->
-         lt_bound_is_not_mem_off qs l';
-         let r = Q.(qs+v) in
-         let res, fq = (add_interval_off_remain bu u v bv r bv l') in
-         let res = OffEnd Q.(qs+u) bu res in
-         let ghost function fq' (q:real) : real
-           ensures { mem_off q res -> (mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v) }
-         =
-            if pure { cmp q bv r }
-            then pure { Q.real qs }
-            else fq q
-         in
-         res, fq'
-       | OffEnd qs b l' ->
-         let bbu = add_bound b bu in
-         let ghost space_right = lt_bound_on_give_space (Q.real qs) l' in
-         let res0, fq = (add_interval_on bu u v bv l') in
-         let res = OffEnd Q.(qs+u) bbu res0 in
-         let ghost function fq' (q:real) : real
-           ensures { mem_off q res -> (mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v) }
-         =
-            if pure { cmp qs b (fq q) } then fq q else begin
-              if pure { q = (qs+.u) } then Q.real qs
-              else
-                let p = pure { min (qs*.0.5+.space_right*.0.5) (qs+.(v-.u)) } in
-                if pure { q-.p <=. u } then pure { qs*.0.5+.(q-.u)*.0.5 } else p
-            end
-         in
-         res, fq'
-       | OffInf -> OffInf, (ghost fun _ -> 0.)
-       end
+  with add_interval_off (bu:Bound.t) (u:Q.t) (v:Q.t) (bv:Bound.t) (l:off) : (result:off,ghost fq':real -> real)
+    requires { Q.(u < v) }
+    requires { ordered_off l }
+    ensures { ordered_off result }
+    ensures { forall q. (lt_bound_off q l) -> (lt_bound_off (q+.u) result) }
+    ensures { forall q q'. (mem_off q l /\ cmp u bu q' /\ cmp q' bv v) -> mem_off (q+.q') result }
+    ensures { forall q. mem_off q result -> (mem_off (fq' q) l /\ cmp u bu (q-.(fq' q)) /\ cmp (q-.(fq' q)) bv v) }
+    variant { length_off l }
+   =
+     match l with
+     | OffSin qs l' ->
+       lt_bound_is_not_mem_off qs l';
+       let r = Q.(qs+v) in
+       let res, fq = (add_interval_off_remain bu u v bv r bv l') in
+       let res = OffEnd Q.(qs+u) bu res in
+       let ghost function fq' (q:real) : real
+         ensures { mem_off q res -> (mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v) }
+       =
+          if pure { cmp q bv r }
+          then pure { Q.real qs }
+          else fq q
+       in
+       res, fq'
+     | OffEnd qs b l' ->
+       let bbu = add_bound b bu in
+       let ghost space_right = lt_bound_on_give_space (Q.real qs) l' in
+       let res0, fq = (add_interval_on bu u v bv l') in
+       let res = OffEnd Q.(qs+u) bbu res0 in
+       let ghost function fq' (q:real) : real
+         ensures { mem_off q res -> (mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v) }
+       =
+          if pure { cmp qs b (fq q) } then fq q else begin
+            if pure { q = (qs+.u) } then Q.real qs
+            else
+              let p = pure { min (qs*.0.5+.space_right*.0.5) (qs+.(v-.u)) } in
+              if pure { q-.p <=. u } then pure { qs*.0.5+.(q-.u)*.0.5 } else p
+          end
+       in
+       res, fq'
+     | OffInf -> OffInf, (ghost fun _ -> 0.)
+     end
 
-    with add_interval_off_remain (bu:Bound.t) (u:Q.t) (v:Q.t) (bv:Bound.t) (r:Q.t) (br:Bound.t) (l:off)  : (result:on,ghost fq':real -> real)
-      requires { Q.(u < v) }
-      requires { lt_bound_off (r-.v) l }
-      requires { br = Large -> bv = Large }
-      requires { ordered_off l }
-      ensures { ordered_on result }
-      ensures { forall q. (lt_bound_off q l) -> (q+.u <. r) -> (lt_bound_on (q+.u) result) }
-      ensures { forall q q'. (mem_off q l /\ cmp u bu q' /\ cmp q' bv v) -> mem_on (q+.q') result }
-      ensures { forall q. cmp q br r -> mem_on q result }
-      ensures { forall q. mem_on q result ->
-                       ((mem_off (fq' q) l /\ cmp u bu (q-.(fq' q)) /\ cmp (q-.(fq' q)) bv v)
-                       \/ cmp q br r) }
-      variant { length_off l }
-     =
-       match l with
-       | OffSin qs l' ->
-         lt_bound_is_not_mem_off qs l';
-         let qu = Q.(qs+u) in
-         let r' =  Q.(qs+v) in
-         let res, fq = (add_interval_off_remain bu u v bv r' bv l') in
-         match Q.compare r qu with
-         | Ord.Lt ->
-           smaller_lt_bound_off Q.(r-u) qs l';
-           let res = OnEnd r br (OffEnd qu bu res) in
-           let ghost fq' (q:real)
-             ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
-                                        \/ cmp q br r) }
-            =
-            if pure { cmp qu bu q } then
-                if pure { cmp q bv r' } then Q.real qs else (fq q)
-            else 0.
-          in
-          res, fq'
-         | Ord.Gt ->
-           let ghost fq' (q:real)
-             ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
-                                        \/ cmp q br r) }
-            =
-            if pure { cmp qu bu q } then
-                if pure { cmp q bv r' } then Q.real qs else (fq q)
-            else 0.
-          in
-          res, fq'
-         | Ord.Eq ->
-           match br, bu with
-           | Strict, Strict ->
-              let res = OnSin qu res in
-              let ghost fq' (q:real)
-                ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
-                                          \/ cmp q br r)  }
-               =
-               if pure { cmp qu bu q } then
-                  if pure { cmp q bv r' } then Q.real qs else (fq q)
-               else 0.
-              in
-              res, fq'
-           | _ ->
-              let ghost fq' (q:real)
-                ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
-                                          \/ cmp q br r)  }
-               =
-               if pure { cmp qu bu q } then
-                  if pure { cmp q bv r' } then Q.real qs else (fq q)
-               else 0.
-              in
-              res, fq'
-           end
-         end
-       | OffEnd qs b l' ->
-         let qu = Q.(qs+u) in
-         let bbu = add_bound b bu in
-         let ghost space_right = lt_bound_on_give_space (Q.real qs) l' in
-         let res, fq =  (add_interval_on bu u v bv l') in
-         match Q.compare r qu with
-         | Ord.Lt ->
-            smaller_lt_bound_on Q.(r-u) qs l';
-            let res = OnEnd r br (OffEnd qu bbu res) in
-            let ghost fq' (q:real) : real
-              ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
-                                         \/ cmp q br r) }
-             =
-               if pure { cmp qu bu q } then
-                if pure { cmp qs b (fq q) } then fq q else begin
-                if pure { q = qu } then Q.real qs
-                else
-                  let p = pure { min (qs*.0.5+.space_right*.0.5) (qs+.(v-.u)) } in
-                  if pure { q-.p <=. u } then pure { qs*.0.5+.(q-.u)*.0.5 } else p
-              end
-              else 0.
-            in
-            res, fq'
-         | Ord.Gt ->
-            let ghost fq' (q:real)
-              ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
-                                        \/ cmp q br r) }
-             =
-               if pure { cmp qu bu q } then
-                if pure { cmp qs b (fq q) } then fq q else begin
-                if pure { q = qu } then Q.real qs
-                else
-                  let p = pure { min (qs*.0.5+.space_right*.0.5) (qs+.(v-.u)) } in
-                  if pure { q-.p <=. u } then pure { qs*.0.5+.(q-.u)*.0.5 } else p
-              end
-              else 0.
-            in
-            let ghost p = pure { 0.5 *. min (qs-.(r-.v)) (v-.u) } in
-            assert { forall q. cmp q br r -> cmp (q-.v+.p) b qs };
-            assert { forall q. cmp q br r -> (mem_on (q-.(v-.p)) l' /\ cmp u bu (v-.p) /\ cmp (v-.p) bv v) };
-            assert { forall q. cmp q br r -> mem_on ((q-.(v-.p))+.(v-.p)) res };
-            assert { forall q. cmp q br r -> mem_on q res };
-            res, fq'
-         | Ord.Eq ->
-           match br, bbu with
-           | Strict, Strict ->
+  with add_interval_off_remain (bu:Bound.t) (u:Q.t) (v:Q.t) (bv:Bound.t) (r:Q.t) (br:Bound.t) (l:off)  : (result:on,ghost fq':real -> real)
+    requires { Q.(u < v) }
+    requires { lt_bound_off (r-.v) l }
+    requires { br = Large -> bv = Large }
+    requires { ordered_off l }
+    ensures { ordered_on result }
+    ensures { forall q. (lt_bound_off q l) -> (q+.u <. r) -> (lt_bound_on (q+.u) result) }
+    ensures { forall q q'. (mem_off q l /\ cmp u bu q' /\ cmp q' bv v) -> mem_on (q+.q') result }
+    ensures { forall q. cmp q br r -> mem_on q result }
+    ensures { forall q. mem_on q result ->
+                     ((mem_off (fq' q) l /\ cmp u bu (q-.(fq' q)) /\ cmp (q-.(fq' q)) bv v)
+                     \/ cmp q br r) }
+    variant { length_off l }
+   =
+     match l with
+     | OffSin qs l' ->
+       lt_bound_is_not_mem_off qs l';
+       let qu = Q.(qs+u) in
+       let r' =  Q.(qs+v) in
+       let res, fq = (add_interval_off_remain bu u v bv r' bv l') in
+       match Q.compare r qu with
+       | Ord.Lt ->
+         smaller_lt_bound_off Q.(r-u) qs l';
+         let res = OnEnd r br (OffEnd qu bu res) in
+         let ghost fq' (q:real)
+           ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
+                                      \/ cmp q br r) }
+          =
+          if pure { cmp qu bu q } then
+              if pure { cmp q bv r' } then Q.real qs else (fq q)
+          else 0.
+        in
+        res, fq'
+       | Ord.Gt ->
+         let ghost fq' (q:real)
+           ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
+                                      \/ cmp q br r) }
+          =
+          if pure { cmp qu bu q } then
+              if pure { cmp q bv r' } then Q.real qs else (fq q)
+          else 0.
+        in
+        res, fq'
+       | Ord.Eq ->
+         match br, bu with
+         | Strict, Strict ->
             let res = OnSin qu res in
             let ghost fq' (q:real)
               ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
-                                        \/ cmp q br r) }
+                                        \/ cmp q br r)  }
              =
-               if pure { cmp qu bu q } then
-                if pure { cmp qs b (fq q) } then fq q else begin
-                if pure { q = qu } then Q.real qs
-                else
-                  let p = pure { min (qs*.0.5+.space_right*.0.5) (qs+.(v-.u)) } in
-                  if pure { q-.p <=. u } then pure { qs*.0.5+.(q-.u)*.0.5 } else p
-              end
-              else 0.
+             if pure { cmp qu bu q } then
+                if pure { cmp q bv r' } then Q.real qs else (fq q)
+             else 0.
             in
             res, fq'
-           | _ ->
+         | _ ->
             let ghost fq' (q:real)
               ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
-                                        \/ cmp q br r) }
+                                        \/ cmp q br r)  }
              =
-               if pure { cmp qu bu q } then
-                if pure { cmp qs b (fq q) } then fq q else begin
-                if pure { q = qu } then Q.real qs
-                else
-                  let p = pure { min (qs*.0.5+.space_right*.0.5) (qs+.(v-.u)) } in
-                  if pure { q-.p <=. u } then pure { qs*.0.5+.(q-.u)*.0.5 } else p
-              end
-              else 0.
+             if pure { cmp qu bu q } then
+                if pure { cmp q bv r' } then Q.real qs else (fq q)
+             else 0.
             in
             res, fq'
-           end
          end
-       | OffInf -> OnEnd r br OffInf,(ghost fun _ -> 0.)
        end
-     in
+     | OffEnd qs b l' ->
+       let qu = Q.(qs+u) in
+       let bbu = add_bound b bu in
+       let ghost space_right = lt_bound_on_give_space (Q.real qs) l' in
+       let res, fq =  (add_interval_on bu u v bv l') in
+       match Q.compare r qu with
+       | Ord.Lt ->
+          smaller_lt_bound_on Q.(r-u) qs l';
+          let res = OnEnd r br (OffEnd qu bbu res) in
+          let ghost fq' (q:real) : real
+            ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
+                                       \/ cmp q br r) }
+           =
+             if pure { cmp qu bu q } then
+              if pure { cmp qs b (fq q) } then fq q else begin
+              if pure { q = qu } then Q.real qs
+              else
+                let p = pure { min (qs*.0.5+.space_right*.0.5) (qs+.(v-.u)) } in
+                if pure { q-.p <=. u } then pure { qs*.0.5+.(q-.u)*.0.5 } else p
+            end
+            else 0.
+          in
+          res, fq'
+       | Ord.Gt ->
+          let ghost fq' (q:real)
+            ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
+                                      \/ cmp q br r) }
+           =
+             if pure { cmp qu bu q } then
+              if pure { cmp qs b (fq q) } then fq q else begin
+              if pure { q = qu } then Q.real qs
+              else
+                let p = pure { min (qs*.0.5+.space_right*.0.5) (qs+.(v-.u)) } in
+                if pure { q-.p <=. u } then pure { qs*.0.5+.(q-.u)*.0.5 } else p
+            end
+            else 0.
+          in
+          let ghost p = pure { 0.5 *. min (qs-.(r-.v)) (v-.u) } in
+          assert { forall q. cmp q br r -> cmp (q-.v+.p) b qs };
+          assert { forall q. cmp q br r -> (mem_on (q-.(v-.p)) l' /\ cmp u bu (v-.p) /\ cmp (v-.p) bv v) };
+          assert { forall q. cmp q br r -> mem_on ((q-.(v-.p))+.(v-.p)) res };
+          assert { forall q. cmp q br r -> mem_on q res };
+          res, fq'
+       | Ord.Eq ->
+         match br, bbu with
+         | Strict, Strict ->
+          let res = OnSin qu res in
+          let ghost fq' (q:real)
+            ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
+                                      \/ cmp q br r) }
+           =
+             if pure { cmp qu bu q } then
+              if pure { cmp qs b (fq q) } then fq q else begin
+              if pure { q = qu } then Q.real qs
+              else
+                let p = pure { min (qs*.0.5+.space_right*.0.5) (qs+.(v-.u)) } in
+                if pure { q-.p <=. u } then pure { qs*.0.5+.(q-.u)*.0.5 } else p
+            end
+            else 0.
+          in
+          res, fq'
+         | _ ->
+          let ghost fq' (q:real)
+            ensures { mem_on q res -> ((mem_off result l /\ cmp u bu (q-.result) /\ cmp (q-.result) bv v)
+                                      \/ cmp q br r) }
+           =
+             if pure { cmp qu bu q } then
+              if pure { cmp qs b (fq q) } then fq q else begin
+              if pure { q = qu } then Q.real qs
+              else
+                let p = pure { min (qs*.0.5+.space_right*.0.5) (qs+.(v-.u)) } in
+                if pure { q-.p <=. u } then pure { qs*.0.5+.(q-.u)*.0.5 } else p
+            end
+            else 0.
+          in
+          res, fq'
+         end
+       end
+     | OffInf -> OnEnd r br OffInf,(ghost fun _ -> 0.)
+     end
+
+  let add_interval l (bu:Bound.t) (u:Q.t) (v:Q.t) (bv:Bound.t): (result:t',ghost fq':real -> real)
+    requires { Q.(u < v) }
+    ensures {
+       forall q q'. (mem q l.a /\ cmp u bu q' /\ cmp q' bv v) -> mem (q+.q') result.a
+     }
+    ensures {
+       forall q. mem q result.a -> (mem (fq' q) l.a /\ cmp u bu (q-.(fq' q)) /\ cmp (q-.(fq' q)) bv v)
+    }
+   =
      match l.a with
      | On l ->
        let res, fq = add_interval_on bu u v bv l in
@@ -1103,5 +1102,149 @@ module Union
        { a = Off l }, fq
     end
 
+  let ghost mem_in_off_not_inf l : real
+      requires { l <> OffInf }
+      requires { ordered_off l }
+      ensures { mem_off result l } =
+    match l with
+    | OffSin qs _ -> Q.real qs
+    | OffEnd qs _ l ->
+       let ghost space = lt_bound_on_give_space (Q.real qs) l in
+       pure { qs*.0.5+.space*.0.5 }
+    | OffInf -> absurd
+    end
+
+  let add_minus_inf_on (v:Q.t) (bv:Bound.t) l: (result:t',ghost fq:real -> real)
+    ensures {
+       forall q q'. (mem q l.a /\ cmp q' bv v) -> mem (q+.q') result.a
+     }
+    ensures {
+       forall q. mem q result.a -> (mem (fq q) l.a /\ cmp (q-.(fq q)) bv v)
+    }
+   =
+     let rec add_minus_inf_on (v: Q.t) (bv:Bound.t) l: (result:on,ghost fq:real -> real)
+       requires { ordered_on l }
+       ensures { ordered_on result }
+       ensures {
+          forall q q'. (mem_on q l /\ cmp q' bv v) -> mem_on (q+.q') result
+        }
+       ensures {
+          forall q. mem_on q result -> (mem_on (fq q) l /\ cmp (q-.(fq q)) bv v)
+       }
+       variant { length_on l } =
+       match l with
+       | OnSin _ l' -> add_minus_inf_on v bv l'
+       | OnEnd qs bs OffInf -> (OnEnd Q.(v+qs) (add_bound bv bs) OffInf, ghost fun q -> q-.(Q.real v-.1.))
+       | OnEnd qs bs l' ->
+          lt_bound_is_not_mem_off qs l';
+          let w = mem_in_off_not_inf l' in
+          assert { forall q q'. (cmp q bs qs /\ cmp q' bv v) -> cmp (q'-.(w-.q)) bv v };
+          let res, fq = add_minus_inf_off v bv l' in
+          assert { forall q q'. (cmp q bs qs /\ cmp q' bv v) -> mem_on (w+.(q'-.(w-.q))) res };
+          res, fq
+       | OnInf -> (OnInf,ghost fun q -> q-.(Q.real v-.1.))
+       end
+     with add_minus_inf_off (v: Q.t) (bv:Bound.t) l: (result:on,ghost fq:real -> real)
+       requires { ordered_off l }
+       requires { l <> OffInf }
+       ensures { ordered_on result }
+       ensures {
+          forall q q'. (mem_off q l /\ cmp q' bv v) -> mem_on (q+.q') result
+        }
+       ensures {
+          forall q. mem_on q result -> (mem_off (fq q) l /\ cmp (q-.(fq q)) bv v)
+       }
+       variant { length_off l } =
+       match l with
+       | OffSin qs OffInf -> (OnEnd Q.(v+qs) bv OffInf,ghost fun q -> q-.(Q.real v-.1.))
+       | OffSin _ l' -> add_minus_inf_off v bv l'
+       | OffEnd _ _ l' -> add_minus_inf_on v bv l'
+       | OffInf -> absurd
+       end
+     in
+     match l.a with
+     | On l ->
+       let res, fq = add_minus_inf_on v bv l in
+       { a = On res }, fq
+     | Off l_off ->
+        let w = not_bottom l in
+        let l, fq = (add_minus_inf_off v bv l_off) in
+        assert { mem_on (w+.v-.1.) l };
+       { a = On l }, fq
+    end
+(*
+  let add l1 l2: (result:t',ghost fq:real -> real)
+    ensures {
+       forall q q'. (mem q l1.a /\ mem q l2.a) -> mem (q+.q') result.a
+     }
+    ensures {
+       forall q. mem q result.a -> (mem (fq q) l1.a /\ mem (q-.(fq q)) l2.a)
+    }
+   =
+    let rec add_on_on u bu (l1:on) (l2:on) : (result:on,ghost fq:real -> real)
+      requires { Q.(u < v) }
+      requires { ordered_on l1 }
+      requires { ordered_on l2 }
+      ensures { ordered_on result }
+      ensures { forall q q'. ((cmp u bu q /\ mem_on q l1) /\ mem_on q l2) -> mem_on (q+.q') result }
+      ensures { forall q. mem_on q result -> ((cmp u bu (fq q) /\ mem_on (fq q) l1) /\ mem_on (q-(fq q)) l2) }
+      variant { length_on l1 }
+     =
+       match l1 with
+       | OnSin qs l1' ->
+         let res1,fq1 = add_interval_on u bu qs Strict l2 in
+         let res2,fq2 = add_on_on qs Strict l1' l2 in
+         let res = union_on_on res1 res2 in
+         let ghost union_fq q : real =
+           ensures { forall q. mem_on q res -> (mem_on (fq q) l1 /\ mem_on (q-(fq q)) l2) }
+           if pure { mem_on q res1 } then fq1 q else fq2 q
+         in
+         res, union_fq res1 fq1 res2 fq2
+       | OnEnd qs bq l1' ->
+         let res1,fq1 = add_interval_on u bu qs bq l2 in
+         let res2,fq2 = add_off_on l1' l2 in
+         let res = union_on_off res1 res2 in
+         let ghost union_fq q : real =
+           ensures { forall q. mem_on q res -> (mem_on (fq q) l1 /\ mem_on (q-(fq q)) l2) }
+           if pure { mem_on q res1 } then fq1 q else fq2 q
+         in
+         res, union_fq
+       | OnInf -> (OnInf,ghost fun q -> q-.Q.real u*.0.5-.Q.real v*.0.5)
+       end
+
+    with add_off_on  (l1:off) (l2:on) : (result:off,ghost fq:real -> real)
+      requires { ordered_off l1 }
+      requires { ordered_on  l2 }
+      ensures { ordered_off result }
+      ensures { forall q q'. (mem_off q l1 /\ mem_on q l2) -> mem_off (q+.q') result }
+      ensures { forall q. mem_off q result -> (mem_off (fq q) l1 /\ mem_on (q-(fq q)) l2 }
+      variant { length_off l1 }
+     =
+       match l1 with
+       | OffSin qs l1' ->
+         let res1,fq1 = add_cst qs l2 in
+         let res2,fq2 = add_off_on qs Strict l1' l2 in
+         let res = union_on_on res1 res2 in
+         let ghost union_fq q : real =
+           ensures { forall q. mem_on q res -> (mem_on (fq q) l1 /\ mem_on (q-(fq q)) l2) }
+           if pure { mem_on q res1 } then fq1 q else fq2 q
+         in
+         res, union_fq res1 fq1 res2 fq2
+       | OffEnd qs b l1' ->
+         add_on_on qs b l1' l2
+       | OffInf -> OffInf, (ghost fun _ -> 0.)
+       end
+     in
+     match l1.a with
+     | On l1 ->
+       let res, fq = add_on bu u v bv l in
+       { a = On res }, fq
+     | Off l_off ->
+        let w = not_bottom l in
+        let l, fq = (add_interval_off bu u v bv l_off) in
+        assert { mem_off (w+.(u*.0.5+.v*.0.5)) l };
+       { a = Off l }, fq
+    end
+*)
 
 end
diff --git a/src_common/union/why3session.xml b/src_common/union/why3session.xml
index 3993d2cc5..ba4719739 100644
--- a/src_common/union/why3session.xml
+++ b/src_common/union/why3session.xml
@@ -3,9 +3,9 @@
 "http://why3.lri.fr/why3session.dtd">
 <why3session shape_version="6">
 <prover id="3" name="Colibri2" version="n/a" timelimit="5" steplimit="0" memlimit="1000"/>
-<file format="whyml" proved="true">
+<file format="whyml">
 <path name=".."/><path name="union.mlw"/>
-<theory name="Union" proved="true">
+<theory name="Union">
  <goal name="pos_length_on&#39;vc" expl="VC for pos_length_on" proved="true">
  <proof prover="3"><result status="valid" time="0.02"/></proof>
  </goal>
@@ -1252,531 +1252,500 @@
   </goal>
  </transf>
  </goal>
- <goal name="union&#39;vc" expl="VC for union" proved="true">
+ <goal name="union_on_on&#39;vc" expl="VC for union_on_on" proved="true">
  <transf name="split_vc" proved="true" >
-  <goal name="union&#39;vc.0" expl="variant decrease" proved="true">
+  <goal name="union_on_on&#39;vc.0" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.1" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.1" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.2" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
-  </goal>
-  <goal name="union&#39;vc.3" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.2" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.4" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.3" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.5" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  <goal name="union_on_on&#39;vc.4" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.6" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.5" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.7" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_on_on&#39;vc.6" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.8" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.7" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.9" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.8" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.10" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.9" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.11" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.10" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
   </goal>
-  <goal name="union&#39;vc.12" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.11" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.13" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_on_on&#39;vc.12" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.14" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.13" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.15" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.14" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.16" expl="variant decrease" proved="true">
+  <goal name="union_on_on&#39;vc.15" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.17" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.16" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.18" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.17" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.19" expl="variant decrease" proved="true">
+  <goal name="union_on_on&#39;vc.18" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.20" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.19" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.21" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
-  </goal>
-  <goal name="union&#39;vc.22" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.20" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.23" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.21" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.24" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.22" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.25" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.23" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.26" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.24" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.27" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.25" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.28" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.26" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.29" expl="variant decrease" proved="true">
+  <goal name="union_on_on&#39;vc.27" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.30" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
-  </goal>
-  <goal name="union&#39;vc.31" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.28" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.32" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.29" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.33" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.30" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="union&#39;vc.34" expl="variant decrease" proved="true">
+  <goal name="union_on_on&#39;vc.31" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.35" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.32" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.36" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.33" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.37" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
-  </goal>
-  <goal name="union&#39;vc.38" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.34" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.39" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.35" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.40" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.36" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.41" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.37" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.42" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.38" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.43" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.39" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.44" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.40" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="union&#39;vc.45" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.41" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.46" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.42" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.47" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.43" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.48" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.44" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="union_on_on&#39;vc.45" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="union_on_on&#39;vc.46" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.49" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.47" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.50" expl="variant decrease" proved="true">
+  <goal name="union_on_on&#39;vc.48" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="union_on_on&#39;vc.49" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.51" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.50" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
+  </goal>
+  <goal name="union_on_on&#39;vc.51" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.52" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.52" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.53" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  <goal name="union_on_on&#39;vc.53" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
   </goal>
-  <goal name="union&#39;vc.54" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.54" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.55" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.55" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.56" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.56" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.57" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_on_on&#39;vc.57" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.58" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_on&#39;vc.58" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.59" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.59" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.60" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.60" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.61" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.61" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.62" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.62" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.63" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  <goal name="union_on_on&#39;vc.63" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.64" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.64" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.65" expl="precondition" proved="true">
+  <goal name="union_on_on&#39;vc.65" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.66" expl="postcondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.11"/></proof>
+  <goal name="union_on_on&#39;vc.66" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.13"/></proof>
   </goal>
-  <goal name="union&#39;vc.67" expl="postcondition" proved="true">
+  <goal name="union_on_on&#39;vc.67" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="union&#39;vc.67.0" expl="postcondition" proved="true">
+   <goal name="union_on_on&#39;vc.67.0" expl="postcondition" proved="true">
    <transf name="split_vc" proved="true" >
-    <goal name="union&#39;vc.67.0.0" expl="postcondition" proved="true">
+    <goal name="union_on_on&#39;vc.67.0.0" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.00"/></proof>
     </goal>
-    <goal name="union&#39;vc.67.0.1" expl="postcondition" proved="true">
+    <goal name="union_on_on&#39;vc.67.0.1" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.67.0.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.00"/></proof>
+    <goal name="union_on_on&#39;vc.67.0.2" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.67.0.3" expl="postcondition" proved="true">
+    <goal name="union_on_on&#39;vc.67.0.3" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.06"/></proof>
     </goal>
-    <goal name="union&#39;vc.67.0.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="3.18"/></proof>
+    <goal name="union_on_on&#39;vc.67.0.4" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="3.16"/></proof>
     </goal>
-    <goal name="union&#39;vc.67.0.5" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.01"/></proof>
+    <goal name="union_on_on&#39;vc.67.0.5" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.02"/></proof>
     </goal>
-    <goal name="union&#39;vc.67.0.6" expl="postcondition" proved="true">
+    <goal name="union_on_on&#39;vc.67.0.6" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="1.41"/></proof>
     </goal>
-    <goal name="union&#39;vc.67.0.7" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="3.61"/></proof>
+    <goal name="union_on_on&#39;vc.67.0.7" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="3.37"/></proof>
     </goal>
    </transf>
    </goal>
-   <goal name="union&#39;vc.67.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="1.95"/></proof>
+   <goal name="union_on_on&#39;vc.67.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="1.70"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="union&#39;vc.68" expl="postcondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.17"/></proof>
+  <goal name="union_on_on&#39;vc.68" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.18"/></proof>
   </goal>
-  <goal name="union&#39;vc.69" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </transf>
+ </goal>
+ <goal name="union_on_off&#39;vc" expl="VC for union_on_off" proved="true">
+ <transf name="split_vc" proved="true" >
+  <goal name="union_on_off&#39;vc.0" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="union&#39;vc.70" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  <goal name="union_on_off&#39;vc.1" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
   </goal>
-  <goal name="union&#39;vc.71" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.2" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.72" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.3" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.73" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.4" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.74" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.5" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.75" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.6" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.76" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_on_off&#39;vc.7" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.77" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.8" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.78" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.9" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.79" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.10" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.80" expl="assertion" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.11" expl="assertion" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.81" expl="variant decrease" proved="true">
+  <goal name="union_on_off&#39;vc.12" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.82" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_on_off&#39;vc.13" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.83" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.14" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="union_on_off&#39;vc.15" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.84" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.16" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.85" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.17" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="union_on_off&#39;vc.18" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.86" expl="variant decrease" proved="true">
+  <goal name="union_on_off&#39;vc.19" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.87" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.20" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.88" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.21" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.89" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.22" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.90" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.23" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.91" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.24" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.92" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.25" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
   </goal>
-  <goal name="union&#39;vc.93" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_on_off&#39;vc.26" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.94" expl="variant decrease" proved="true">
+  <goal name="union_on_off&#39;vc.27" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.95" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.28" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.96" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.29" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.97" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.30" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.98" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
-  </goal>
-  <goal name="union&#39;vc.99" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
-  </goal>
-  <goal name="union&#39;vc.100" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.31" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.101" expl="variant decrease" proved="true">
+  <goal name="union_on_off&#39;vc.32" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.102" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.33" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.103" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_on_off&#39;vc.34" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.104" expl="variant decrease" proved="true">
+  <goal name="union_on_off&#39;vc.35" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.105" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.36" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.106" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.37" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.107" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.38" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.108" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.39" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.109" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_on_off&#39;vc.40" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.110" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.41" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.111" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.42" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.112" expl="variant decrease" proved="true">
+  <goal name="union_on_off&#39;vc.43" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.113" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.44" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.114" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.45" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.115" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.46" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.116" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.47" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.117" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.48" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.118" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.49" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.119" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.50" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.120" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.51" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
   </goal>
-  <goal name="union&#39;vc.121" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.52" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.122" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.53" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="union_on_off&#39;vc.54" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
   </goal>
-  <goal name="union&#39;vc.123" expl="variant decrease" proved="true">
+  <goal name="union_on_off&#39;vc.55" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.124" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.56" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="union&#39;vc.125" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_on_off&#39;vc.57" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.126" expl="variant decrease" proved="true">
+  <goal name="union_on_off&#39;vc.58" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.127" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
-  </goal>
-  <goal name="union&#39;vc.128" expl="precondition" proved="true">
+  <goal name="union_on_off&#39;vc.59" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.129" expl="postcondition" proved="true">
-  <transf name="split_vc" proved="true" >
-   <goal name="union&#39;vc.129.0" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.00"/></proof>
-   </goal>
-   <goal name="union&#39;vc.129.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.00"/></proof>
-   </goal>
-   <goal name="union&#39;vc.129.2" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.01"/></proof>
-   </goal>
-   <goal name="union&#39;vc.129.3" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="union&#39;vc.129.3.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.01"/></proof>
-    </goal>
-    <goal name="union&#39;vc.129.3.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.36"/></proof>
-    </goal>
-    <goal name="union&#39;vc.129.3.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.00"/></proof>
-    </goal>
-   </transf>
-   </goal>
-   <goal name="union&#39;vc.129.4" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.59"/></proof>
-   </goal>
-   <goal name="union&#39;vc.129.5" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.01"/></proof>
-   </goal>
-   <goal name="union&#39;vc.129.6" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.47"/></proof>
-   </goal>
-   <goal name="union&#39;vc.129.7" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.24"/></proof>
-   </goal>
-  </transf>
+  <goal name="union_on_off&#39;vc.60" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="1.46"/></proof>
   </goal>
-  <goal name="union&#39;vc.130" expl="postcondition" proved="true">
+  <goal name="union_on_off&#39;vc.61" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="union&#39;vc.130.0" expl="postcondition" proved="true">
+   <goal name="union_on_off&#39;vc.61.0" expl="postcondition" proved="true">
    <transf name="split_vc" proved="true" >
-    <goal name="union&#39;vc.130.0.0" expl="postcondition" proved="true">
+    <goal name="union_on_off&#39;vc.61.0.0" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.0.1" expl="postcondition" proved="true">
+    <goal name="union_on_off&#39;vc.61.0.1" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.0.2" expl="postcondition" proved="true">
+    <goal name="union_on_off&#39;vc.61.0.2" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.0.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="1.80"/></proof>
+    <goal name="union_on_off&#39;vc.61.0.3" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="1.77"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.0.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.89"/></proof>
+    <goal name="union_on_off&#39;vc.61.0.4" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.99"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.0.5" expl="postcondition" proved="true">
+    <goal name="union_on_off&#39;vc.61.0.5" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.0.6" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="3.81"/></proof>
+    <goal name="union_on_off&#39;vc.61.0.6" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="3.82"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.0.7" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="1.22"/></proof>
+    <goal name="union_on_off&#39;vc.61.0.7" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="1.24"/></proof>
     </goal>
    </transf>
    </goal>
-   <goal name="union&#39;vc.130.1" expl="postcondition" proved="true">
+   <goal name="union_on_off&#39;vc.61.1" expl="postcondition" proved="true">
    <transf name="split_vc" proved="true" >
-    <goal name="union&#39;vc.130.1.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.01"/></proof>
+    <goal name="union_on_off&#39;vc.61.1.0" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.02"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.1.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.00"/></proof>
+    <goal name="union_on_off&#39;vc.61.1.1" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.1.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.00"/></proof>
+    <goal name="union_on_off&#39;vc.61.1.2" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.02"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.1.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.05"/></proof>
+    <goal name="union_on_off&#39;vc.61.1.3" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.06"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.1.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.64"/></proof>
+    <goal name="union_on_off&#39;vc.61.1.4" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.69"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.1.5" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.00"/></proof>
+    <goal name="union_on_off&#39;vc.61.1.5" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.1.6" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="3.69"/></proof>
+    <goal name="union_on_off&#39;vc.61.1.6" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="3.67"/></proof>
     </goal>
-    <goal name="union&#39;vc.130.1.7" expl="postcondition" proved="true">
+    <goal name="union_on_off&#39;vc.61.1.7" expl="postcondition" proved="true">
     <transf name="split_vc" proved="true" >
-     <goal name="union&#39;vc.130.1.7.0" expl="postcondition" proved="true">
-     <proof prover="3"><result status="valid" time="3.51"/></proof>
+     <goal name="union_on_off&#39;vc.61.1.7.0" expl="postcondition" proved="true">
+     <proof prover="3"><result status="valid" time="3.20"/></proof>
      </goal>
-     <goal name="union&#39;vc.130.1.7.1" expl="postcondition" proved="true">
+     <goal name="union_on_off&#39;vc.61.1.7.1" expl="postcondition" proved="true">
      <proof prover="3"><result status="valid" time="0.03"/></proof>
      </goal>
-     <goal name="union&#39;vc.130.1.7.2" expl="postcondition" proved="true">
+     <goal name="union_on_off&#39;vc.61.1.7.2" expl="postcondition" proved="true">
      <proof prover="3"><result status="valid" time="0.03"/></proof>
      </goal>
-     <goal name="union&#39;vc.130.1.7.3" expl="postcondition" proved="true">
-     <proof prover="3"><result status="valid" time="0.49"/></proof>
+     <goal name="union_on_off&#39;vc.61.1.7.3" expl="postcondition" proved="true">
+     <proof prover="3"><result status="valid" time="0.51"/></proof>
      </goal>
     </transf>
     </goal>
@@ -1784,362 +1753,355 @@
    </goal>
   </transf>
   </goal>
-  <goal name="union&#39;vc.131" expl="postcondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.13"/></proof>
+  <goal name="union_on_off&#39;vc.62" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.16"/></proof>
   </goal>
-  <goal name="union&#39;vc.132" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+ </transf>
+ </goal>
+ <goal name="union_off_off&#39;vc" expl="VC for union_off_off" proved="true">
+ <transf name="split_vc" proved="true" >
+  <goal name="union_off_off&#39;vc.0" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.133" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.1" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.134" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
-  </goal>
-  <goal name="union&#39;vc.135" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.2" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.136" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.3" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.137" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
-  </goal>
-  <goal name="union&#39;vc.138" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.4" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.139" expl="variant decrease" proved="true">
+  <goal name="union_off_off&#39;vc.5" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.140" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.6" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.141" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_off_off&#39;vc.7" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.142" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.8" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.143" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_off_off&#39;vc.9" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.144" expl="variant decrease" proved="true">
+  <goal name="union_off_off&#39;vc.10" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.145" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.11" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.146" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.12" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.147" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.13" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.148" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.14" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.149" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_off_off&#39;vc.15" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.150" expl="variant decrease" proved="true">
+  <goal name="union_off_off&#39;vc.16" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.151" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.17" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.152" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.18" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.153" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_off_off&#39;vc.19" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.154" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.20" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.155" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_off_off&#39;vc.21" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.156" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.22" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.157" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_off_off&#39;vc.23" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.158" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.24" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.159" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
-  </goal>
-  <goal name="union&#39;vc.160" expl="variant decrease" proved="true">
+  <goal name="union_off_off&#39;vc.25" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.161" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.26" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.162" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_off_off&#39;vc.27" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.163" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_off_off&#39;vc.28" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.164" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.29" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.165" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.30" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.166" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_off_off&#39;vc.31" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
   </goal>
-  <goal name="union&#39;vc.167" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_off_off&#39;vc.32" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.168" expl="variant decrease" proved="true">
+  <goal name="union_off_off&#39;vc.33" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.169" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_off_off&#39;vc.34" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.170" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_off_off&#39;vc.35" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.171" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_off_off&#39;vc.36" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.172" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_off_off&#39;vc.37" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.173" expl="variant decrease" proved="true">
+  <goal name="union_off_off&#39;vc.38" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.174" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.39" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="union_off_off&#39;vc.40" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.175" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="union_off_off&#39;vc.41" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.176" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.42" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.177" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.43" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.178" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.44" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.179" expl="variant decrease" proved="true">
+  <goal name="union_off_off&#39;vc.45" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="union_off_off&#39;vc.46" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.180" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.47" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="union_off_off&#39;vc.48" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.181" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.49" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.182" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.50" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.183" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.51" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.184" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_off_off&#39;vc.52" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
   </goal>
-  <goal name="union&#39;vc.185" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.53" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.186" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_off_off&#39;vc.54" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="union&#39;vc.187" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.55" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.188" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  <goal name="union_off_off&#39;vc.56" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.189" expl="variant decrease" proved="true">
+  <goal name="union_off_off&#39;vc.57" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.190" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="union_off_off&#39;vc.58" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="union&#39;vc.191" expl="precondition" proved="true">
+  <goal name="union_off_off&#39;vc.59" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.192" expl="postcondition" proved="true">
-  <transf name="split_vc" proved="true" >
-   <goal name="union&#39;vc.192.0" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.00"/></proof>
-   </goal>
-   <goal name="union&#39;vc.192.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.01"/></proof>
-   </goal>
-   <goal name="union&#39;vc.192.2" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.01"/></proof>
-   </goal>
-   <goal name="union&#39;vc.192.3" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="union&#39;vc.192.3.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.02"/></proof>
-    </goal>
-    <goal name="union&#39;vc.192.3.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.57"/></proof>
-    </goal>
-    <goal name="union&#39;vc.192.3.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.43"/></proof>
-    </goal>
-   </transf>
-   </goal>
-   <goal name="union&#39;vc.192.4" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.71"/></proof>
-   </goal>
-   <goal name="union&#39;vc.192.5" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.00"/></proof>
-   </goal>
-   <goal name="union&#39;vc.192.6" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.47"/></proof>
-   </goal>
-   <goal name="union&#39;vc.192.7" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.70"/></proof>
-   </goal>
-  </transf>
+  <goal name="union_off_off&#39;vc.60" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="3.03"/></proof>
   </goal>
-  <goal name="union&#39;vc.193" expl="postcondition" proved="true">
+  <goal name="union_off_off&#39;vc.61" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="union&#39;vc.193.0" expl="postcondition" proved="true">
+   <goal name="union_off_off&#39;vc.61.0" expl="postcondition" proved="true">
    <transf name="split_vc" proved="true" >
-    <goal name="union&#39;vc.193.0.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.00"/></proof>
+    <goal name="union_off_off&#39;vc.61.0.0" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.0.1" expl="postcondition" proved="true">
+    <goal name="union_off_off&#39;vc.61.0.1" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.00"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.0.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.01"/></proof>
+    <goal name="union_off_off&#39;vc.61.0.2" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.02"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.0.3" expl="postcondition" proved="true">
+    <goal name="union_off_off&#39;vc.61.0.3" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.08"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.0.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="6.10"/></proof>
+    <goal name="union_off_off&#39;vc.61.0.4" expl="postcondition" proved="true">
+    <transf name="split_vc" proved="true" >
+     <goal name="union_off_off&#39;vc.61.0.4.0" expl="postcondition" proved="true">
+     <proof prover="3"><result status="valid" time="2.26"/></proof>
+     </goal>
+     <goal name="union_off_off&#39;vc.61.0.4.1" expl="postcondition" proved="true">
+     <proof prover="3"><result status="valid" time="0.03"/></proof>
+     </goal>
+     <goal name="union_off_off&#39;vc.61.0.4.2" expl="postcondition" proved="true">
+     <proof prover="3"><result status="valid" time="3.16"/></proof>
+     </goal>
+    </transf>
     </goal>
-    <goal name="union&#39;vc.193.0.5" expl="postcondition" proved="true">
+    <goal name="union_off_off&#39;vc.61.0.5" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.0.6" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="3.44"/></proof>
+    <goal name="union_off_off&#39;vc.61.0.6" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="4.00"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.0.7" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="5.83"/></proof>
+    <goal name="union_off_off&#39;vc.61.0.7" expl="postcondition" proved="true">
+    <transf name="split_vc" proved="true" >
+     <goal name="union_off_off&#39;vc.61.0.7.0" expl="postcondition" proved="true">
+     <proof prover="3"><result status="valid" time="2.12"/></proof>
+     </goal>
+     <goal name="union_off_off&#39;vc.61.0.7.1" expl="postcondition" proved="true">
+     <proof prover="3"><result status="valid" time="0.02"/></proof>
+     </goal>
+     <goal name="union_off_off&#39;vc.61.0.7.2" expl="postcondition" proved="true">
+     <proof prover="3"><result status="valid" time="3.14"/></proof>
+     </goal>
+    </transf>
     </goal>
    </transf>
    </goal>
-   <goal name="union&#39;vc.193.1" expl="postcondition" proved="true">
+   <goal name="union_off_off&#39;vc.61.1" expl="postcondition" proved="true">
    <transf name="split_vc" proved="true" >
-    <goal name="union&#39;vc.193.1.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.00"/></proof>
+    <goal name="union_off_off&#39;vc.61.1.0" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.1.1" expl="postcondition" proved="true">
+    <goal name="union_off_off&#39;vc.61.1.1" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.1.2" expl="postcondition" proved="true">
+    <goal name="union_off_off&#39;vc.61.1.2" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.1.3" expl="postcondition" proved="true">
+    <goal name="union_off_off&#39;vc.61.1.3" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.07"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.1.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.77"/></proof>
+    <goal name="union_off_off&#39;vc.61.1.4" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.86"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.1.5" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.00"/></proof>
+    <goal name="union_off_off&#39;vc.61.1.5" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="union&#39;vc.193.1.6" expl="postcondition" proved="true">
+    <goal name="union_off_off&#39;vc.61.1.6" expl="postcondition" proved="true">
     <transf name="split_vc" proved="true" >
-     <goal name="union&#39;vc.193.1.6.0" expl="postcondition" proved="true">
+     <goal name="union_off_off&#39;vc.61.1.6.0" expl="postcondition" proved="true">
      <transf name="split_vc" proved="true" >
-      <goal name="union&#39;vc.193.1.6.0.0" expl="postcondition" proved="true">
+      <goal name="union_off_off&#39;vc.61.1.6.0.0" expl="postcondition" proved="true">
       <proof prover="3"><result status="valid" time="0.03"/></proof>
       </goal>
-      <goal name="union&#39;vc.193.1.6.0.1" expl="postcondition" proved="true">
-      <proof prover="3"><result status="valid" time="2.60"/></proof>
+      <goal name="union_off_off&#39;vc.61.1.6.0.1" expl="postcondition" proved="true">
+      <proof prover="3"><result status="valid" time="2.03"/></proof>
       </goal>
-      <goal name="union&#39;vc.193.1.6.0.2" expl="postcondition" proved="true">
-      <proof prover="3"><result status="valid" time="5.94"/></proof>
+      <goal name="union_off_off&#39;vc.61.1.6.0.2" expl="postcondition" proved="true">
+      <proof prover="3"><result status="valid" time="4.62"/></proof>
       </goal>
      </transf>
      </goal>
-     <goal name="union&#39;vc.193.1.6.1" expl="postcondition" proved="true">
-     <proof prover="3"><result status="valid" time="0.02"/></proof>
+     <goal name="union_off_off&#39;vc.61.1.6.1" expl="postcondition" proved="true">
+     <proof prover="3"><result status="valid" time="0.01"/></proof>
      </goal>
-     <goal name="union&#39;vc.193.1.6.2" expl="postcondition" proved="true">
+     <goal name="union_off_off&#39;vc.61.1.6.2" expl="postcondition" proved="true">
      <proof prover="3"><result status="valid" time="0.02"/></proof>
      </goal>
     </transf>
     </goal>
-    <goal name="union&#39;vc.193.1.7" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.76"/></proof>
+    <goal name="union_off_off&#39;vc.61.1.7" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.89"/></proof>
     </goal>
    </transf>
    </goal>
   </transf>
   </goal>
-  <goal name="union&#39;vc.194" expl="postcondition" proved="true">
+  <goal name="union_off_off&#39;vc.62" expl="postcondition" proved="true">
   <proof prover="3"><result status="valid" time="0.15"/></proof>
   </goal>
-  <goal name="union&#39;vc.195" expl="precondition" proved="true">
+ </transf>
+ </goal>
+ <goal name="union&#39;vc" expl="VC for union" proved="true">
+ <transf name="split_vc" proved="true" >
+  <goal name="union&#39;vc.0" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="union&#39;vc.196" expl="precondition" proved="true">
+  <goal name="union&#39;vc.1" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.197" expl="precondition" proved="true">
+  <goal name="union&#39;vc.2" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.198" expl="precondition" proved="true">
+  <goal name="union&#39;vc.3" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.199" expl="precondition" proved="true">
+  <goal name="union&#39;vc.4" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.200" expl="precondition" proved="true">
+  <goal name="union&#39;vc.5" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.201" expl="precondition" proved="true">
+  <goal name="union&#39;vc.6" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.202" expl="precondition" proved="true">
+  <goal name="union&#39;vc.7" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="union&#39;vc.203" expl="precondition" proved="true">
+  <goal name="union&#39;vc.8" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.204" expl="precondition" proved="true">
+  <goal name="union&#39;vc.9" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.205" expl="precondition" proved="true">
+  <goal name="union&#39;vc.10" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="union&#39;vc.206" expl="precondition" proved="true">
+  <goal name="union&#39;vc.11" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="union&#39;vc.207" expl="precondition" proved="true">
+  <goal name="union&#39;vc.12" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.208" expl="precondition" proved="true">
+  <goal name="union&#39;vc.13" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.209" expl="assertion" proved="true">
+  <goal name="union&#39;vc.14" expl="assertion" proved="true">
   <proof prover="3"><result status="valid" time="0.13"/></proof>
   </goal>
-  <goal name="union&#39;vc.210" expl="precondition" proved="true">
+  <goal name="union&#39;vc.15" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="union&#39;vc.211" expl="precondition" proved="true">
+  <goal name="union&#39;vc.16" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="union&#39;vc.212" expl="postcondition" proved="true">
+  <goal name="union&#39;vc.17" expl="postcondition" proved="true">
   <proof prover="3"><result status="valid" time="0.04"/></proof>
   </goal>
  </transf>
@@ -2314,785 +2276,642 @@
  <goal name="lt_bound_on_give_space&#39;vc" expl="VC for lt_bound_on_give_space" proved="true">
  <proof prover="3"><result status="valid" time="0.14"/></proof>
  </goal>
- <goal name="add_interval&#39;vc" expl="VC for add_interval" proved="true">
+ <goal name="add_interval_on&#39;vc" expl="VC for add_interval_on" proved="true">
  <transf name="split_vc" proved="true" >
-  <goal name="add_interval&#39;vc.0" expl="assertion" proved="true">
-  <proof prover="3"><result status="valid" time="0.27"/></proof>
+  <goal name="add_interval_on&#39;vc.0" expl="assertion" proved="true">
+  <proof prover="3"><result status="valid" time="0.20"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.1" expl="variant decrease" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="add_interval_on&#39;vc.1" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.2" expl="precondition" proved="true">
+  <goal name="add_interval_on&#39;vc.2" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.3" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="add_interval_on&#39;vc.3" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.4" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="add_interval_on&#39;vc.4" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.5" expl="postcondition" proved="true">
+  <goal name="add_interval_on&#39;vc.5" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.5.0" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.5.0.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.5.0.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.5.0.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="1.83"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.5.0.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.43"/></proof>
-    </goal>
-   </transf>
+   <goal name="add_interval_on&#39;vc.5.0" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="2.03"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.5.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="1.83"/></proof>
+   <goal name="add_interval_on&#39;vc.5.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="1.64"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.5.2" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.5.2.0" expl="postcondition" proved="true">
-    <transf name="eliminate_let_fmla" proved="true" >
-     <goal name="add_interval&#39;vc.5.2.0.0" expl="postcondition" proved="true">
-     <transf name="subst_all" proved="true" >
-      <goal name="add_interval&#39;vc.5.2.0.0.0" expl="postcondition" proved="true">
-      <proof prover="3"><result status="valid" time="0.03"/></proof>
-      </goal>
-     </transf>
-     </goal>
-    </transf>
-    <transf name="subst_all" proved="true" >
-     <goal name="add_interval&#39;vc.5.2.0.0" expl="postcondition" proved="true">
-     <proof prover="3"><result status="valid" time="0.03"/></proof>
-     </goal>
-    </transf>
-    </goal>
-    <goal name="add_interval&#39;vc.5.2.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.5.2.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="1.19"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.5.2.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.56"/></proof>
-    </goal>
-   </transf>
+   <goal name="add_interval_on&#39;vc.5.2" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="1.65"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.6" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="add_interval_on&#39;vc.6" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.7" expl="variant decrease" proved="true">
+  <goal name="add_interval_on&#39;vc.7" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.8" expl="precondition" proved="true">
+  <goal name="add_interval_on&#39;vc.8" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.9" expl="precondition" proved="true">
+  <goal name="add_interval_on&#39;vc.9" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.10" expl="precondition" proved="true">
+  <goal name="add_interval_on&#39;vc.10" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.03"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.11" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
-  </goal>
-  <goal name="add_interval&#39;vc.12" expl="postcondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.90"/></proof>
+  <goal name="add_interval_on&#39;vc.11" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.13" expl="postcondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  <goal name="add_interval_on&#39;vc.12" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.81"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.14" expl="postcondition" proved="true">
+  <goal name="add_interval_on&#39;vc.13" expl="postcondition" proved="true">
   <proof prover="3"><result status="valid" time="0.03"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.15" expl="postcondition" proved="true">
-  <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.15.0" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.15.0.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.02"/></proof>
-    </goal>
-   </transf>
-   </goal>
-   <goal name="add_interval&#39;vc.15.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="2.22"/></proof>
-   </goal>
-   <goal name="add_interval&#39;vc.15.2" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.15.2.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.04"/></proof>
-    </goal>
-   </transf>
-   </goal>
-  </transf>
+  <goal name="add_interval_on&#39;vc.14" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.04"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.16" expl="postcondition" proved="true">
-  <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.16.0" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.16.0.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.81"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.16.0.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.72"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.16.0.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.00"/></proof>
-    </goal>
-   </transf>
-   </goal>
-   <goal name="add_interval&#39;vc.16.1" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.16.1.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.64"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.16.1.1" expl="postcondition" proved="true">
-    <transf name="eliminate_let_fmla" proved="true" >
-     <goal name="add_interval&#39;vc.16.1.1.0" expl="postcondition" proved="true">
-     <proof prover="3"><result status="valid" time="0.67"/></proof>
-     </goal>
-    </transf>
-    </goal>
-    <goal name="add_interval&#39;vc.16.1.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.16"/></proof>
-    </goal>
-   </transf>
-   </goal>
-   <goal name="add_interval&#39;vc.16.2" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.16.2.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.65"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.16.2.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.64"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.16.2.2" expl="postcondition" proved="true">
-    <transf name="eliminate_let_fmla" proved="true" >
-     <goal name="add_interval&#39;vc.16.2.2.0" expl="postcondition" proved="true">
-     <proof prover="3"><result status="valid" time="0.15"/></proof>
-     </goal>
-    </transf>
-    </goal>
-   </transf>
-   </goal>
-  </transf>
+  <goal name="add_interval_on&#39;vc.15" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="3.97"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.17" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="add_interval_on&#39;vc.16" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.26"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.18" expl="variant decrease" proved="true">
+ </transf>
+ </goal>
+ <goal name="add_interval_off&#39;vc" expl="VC for add_interval_off" proved="true">
+ <transf name="split_vc" proved="true" >
+  <goal name="add_interval_off&#39;vc.0" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.19" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="add_interval_off&#39;vc.1" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.20" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  <goal name="add_interval_off&#39;vc.2" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.21" expl="precondition" proved="true">
+  <goal name="add_interval_off&#39;vc.3" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.22" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="add_interval_off&#39;vc.4" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.23" expl="postcondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.04"/></proof>
+  <goal name="add_interval_off&#39;vc.5" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.24" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.03"/></proof>
+  <goal name="add_interval_off&#39;vc.6" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.05"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.25" expl="variant decrease" proved="true">
+  <goal name="add_interval_off&#39;vc.7" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.26" expl="precondition" proved="true">
+  <goal name="add_interval_off&#39;vc.8" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="add_interval_off&#39;vc.9" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.27" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  <goal name="add_interval_off&#39;vc.10" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.28" expl="postcondition" proved="true">
+  <goal name="add_interval_off&#39;vc.11" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.28.0" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.84"/></proof>
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.28.0.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.79"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.28.0.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.28.0.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.07"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.28.0.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.08"/></proof>
-    </goal>
-   </transf>
+   <goal name="add_interval_off&#39;vc.11.0" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.96"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.28.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.85"/></proof>
+   <goal name="add_interval_off&#39;vc.11.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.98"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.28.2" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="3.63"/></proof>
+   <goal name="add_interval_off&#39;vc.11.2" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="3.40"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.29" expl="postcondition" proved="true">
-  <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.29.0" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.03"/></proof>
-   </goal>
-   <goal name="add_interval&#39;vc.29.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.02"/></proof>
-   </goal>
-   <goal name="add_interval&#39;vc.29.2" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.01"/></proof>
-   </goal>
-  </transf>
+  <goal name="add_interval_off&#39;vc.12" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.04"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.30" expl="postcondition" proved="true">
+  <goal name="add_interval_off&#39;vc.13" expl="postcondition" proved="true">
   <proof prover="3"><result status="valid" time="0.05"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.31" expl="postcondition" proved="true">
+  <goal name="add_interval_off&#39;vc.14" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.31.0" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="4.93"/></proof>
+   <goal name="add_interval_off&#39;vc.14.0" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="4.69"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.31.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.11"/></proof>
+   <goal name="add_interval_off&#39;vc.14.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.12"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.31.2" expl="postcondition" proved="true">
+   <goal name="add_interval_off&#39;vc.14.2" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.01"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.32" expl="postcondition" proved="true">
-  <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.32.0" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.32.0.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.45"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.32.0.1" expl="postcondition" proved="true">
-    <transf name="eliminate_let_fmla" proved="true" >
-     <goal name="add_interval&#39;vc.32.0.1.0" expl="postcondition" proved="true">
-     <transf name="instantiate" proved="true" arg1="H3" arg2="q">
-      <goal name="add_interval&#39;vc.32.0.1.0.0" expl="postcondition" proved="true">
-      <proof prover="3"><result status="valid" time="0.01"/></proof>
-      </goal>
-     </transf>
-     </goal>
-    </transf>
-    </goal>
-    <goal name="add_interval&#39;vc.32.0.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.01"/></proof>
-    </goal>
-   </transf>
-   </goal>
-   <goal name="add_interval&#39;vc.32.1" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.32.1.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.50"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.32.1.1" expl="postcondition" proved="true">
-    <transf name="eliminate_let_fmla" proved="true" >
-     <goal name="add_interval&#39;vc.32.1.1.0" expl="postcondition" proved="true">
-     <transf name="instantiate" proved="true" arg1="H3" arg2="q">
-      <goal name="add_interval&#39;vc.32.1.1.0.0" expl="postcondition" proved="true">
-      <proof prover="3"><result status="valid" time="0.01"/></proof>
-      </goal>
-     </transf>
-     </goal>
-    </transf>
-    </goal>
-    <goal name="add_interval&#39;vc.32.1.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.01"/></proof>
-    </goal>
-   </transf>
-   </goal>
-   <goal name="add_interval&#39;vc.32.2" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.32.2.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.51"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.32.2.1" expl="postcondition" proved="true">
-    <transf name="eliminate_let_fmla" proved="true" >
-     <goal name="add_interval&#39;vc.32.2.1.0" expl="postcondition" proved="true">
-     <transf name="instantiate" proved="true" arg1="H3" arg2="q">
-      <goal name="add_interval&#39;vc.32.2.1.0.0" expl="postcondition" proved="true">
-      <proof prover="3"><result status="valid" time="0.02"/></proof>
-      </goal>
-     </transf>
-     </goal>
-    </transf>
-    </goal>
-    <goal name="add_interval&#39;vc.32.2.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.01"/></proof>
-    </goal>
-   </transf>
-   </goal>
-  </transf>
+  <goal name="add_interval_off&#39;vc.15" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.09"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.33" expl="precondition" proved="true">
+ </transf>
+ </goal>
+ <goal name="add_interval_off_remain&#39;vc" expl="VC for add_interval_off_remain" proved="true">
+ <transf name="split_vc" proved="true" >
+  <goal name="add_interval_off_remain&#39;vc.0" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.34" expl="variant decrease" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.1" expl="variant decrease" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.35" expl="precondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.2" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.36" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.03"/></proof>
+  <goal name="add_interval_off_remain&#39;vc.3" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.37" expl="precondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.4" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.38" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.02"/></proof>
-  </goal>
-  <goal name="add_interval&#39;vc.39" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.08"/></proof>
+  <goal name="add_interval_off_remain&#39;vc.5" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.40" expl="precondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.6" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.41" expl="postcondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.18"/></proof>
+  <goal name="add_interval_off_remain&#39;vc.7" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.42" expl="postcondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.08"/></proof>
+  <goal name="add_interval_off_remain&#39;vc.8" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.15"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.43" expl="postcondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.9" expl="postcondition" proved="true">
   <proof prover="3"><result status="valid" time="0.08"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.44" expl="postcondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.06"/></proof>
+  <goal name="add_interval_off_remain&#39;vc.10" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.09"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.45" expl="postcondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.11" expl="postcondition" proved="true">
   <proof prover="3"><result status="valid" time="0.07"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.46" expl="precondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.12" expl="postcondition" proved="true">
   <proof prover="3"><result status="valid" time="0.08"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.47" expl="variant decrease" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.13" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.48" expl="precondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.14" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
+  </goal>
+  <goal name="add_interval_off_remain&#39;vc.15" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.49" expl="precondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.16" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.50" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.07"/></proof>
+  <goal name="add_interval_off_remain&#39;vc.17" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.51" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.08"/></proof>
+  <goal name="add_interval_off_remain&#39;vc.18" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.52" expl="postcondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.19" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.52.0" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.10"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.19.0" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.08"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.52.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.11"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.19.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.14"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.52.2" expl="postcondition" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.19.2" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.28"/></proof>
+   </goal>
+   <goal name="add_interval_off_remain&#39;vc.19.3" expl="postcondition" proved="true">
    <transf name="left" proved="true" >
-    <goal name="add_interval&#39;vc.52.2.0" expl="left case" proved="true">
+    <goal name="add_interval_off_remain&#39;vc.19.3.0" expl="left case" proved="true">
     <transf name="split_vc" proved="true" >
-     <goal name="add_interval&#39;vc.52.2.0.0" expl="left case" proved="true">
+     <goal name="add_interval_off_remain&#39;vc.19.3.0.0" expl="left case" proved="true">
      <proof prover="3"><result status="valid" time="0.11"/></proof>
      </goal>
-     <goal name="add_interval&#39;vc.52.2.0.1" expl="left case" proved="true">
-     <proof prover="3"><result status="valid" time="0.12"/></proof>
+     <goal name="add_interval_off_remain&#39;vc.19.3.0.1" expl="left case" proved="true">
+     <proof prover="3"><result status="valid" time="0.04"/></proof>
      </goal>
-     <goal name="add_interval&#39;vc.52.2.0.2" expl="left case" proved="true">
-     <proof prover="3"><result status="valid" time="0.07"/></proof>
+     <goal name="add_interval_off_remain&#39;vc.19.3.0.2" expl="left case" proved="true">
+     <proof prover="3" timelimit="100"><result status="valid" time="11.06"/></proof>
      </goal>
     </transf>
     </goal>
    </transf>
    </goal>
-   <goal name="add_interval&#39;vc.52.3" expl="postcondition" proved="true">
-   <transf name="instantiate" proved="true" arg1="Ensures3" arg2="q">
-    <goal name="add_interval&#39;vc.52.3.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.33"/></proof>
-    </goal>
-   </transf>
-   </goal>
-   <goal name="add_interval&#39;vc.52.4" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="2.61"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.19.4" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="2.75"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.53" expl="postcondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.20" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.53.0" expl="postcondition" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.20.0" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.03"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.53.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.04"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.20.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.06"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.53.2" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.14"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.20.2" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.17"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.53.3" expl="postcondition" proved="true">
-   <proof prover="3" timelimit="100"><result status="valid" time="14.47"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.20.3" expl="postcondition" proved="true">
    <transf name="left" proved="true" >
-    <goal name="add_interval&#39;vc.53.3.0" expl="left case" proved="true">
-    <transf name="split_vc" proved="true" >
-     <goal name="add_interval&#39;vc.53.3.0.0" expl="left case" proved="true">
-     <proof prover="3"><result status="valid" time="0.09"/></proof>
-     </goal>
-     <goal name="add_interval&#39;vc.53.3.0.1" expl="left case" proved="true">
-     <proof prover="3"><result status="valid" time="0.04"/></proof>
-     </goal>
-     <goal name="add_interval&#39;vc.53.3.0.2" expl="left case" proved="true">
-     <proof prover="3" timelimit="100"><result status="valid" time="8.52"/></proof>
-     </goal>
-    </transf>
+    <goal name="add_interval_off_remain&#39;vc.20.3.0" expl="left case" proved="true">
+    <proof prover="3" timelimit="100"><result status="valid" time="13.72"/></proof>
     </goal>
    </transf>
    </goal>
-   <goal name="add_interval&#39;vc.53.4" expl="postcondition" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.20.4" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.04"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.54" expl="assertion" proved="true">
-  <proof prover="3"><result status="valid" time="0.03"/></proof>
+  <goal name="add_interval_off_remain&#39;vc.21" expl="assertion" proved="true">
+  <proof prover="3"><result status="valid" time="0.05"/></proof>
+  </goal>
+  <goal name="add_interval_off_remain&#39;vc.22" expl="assertion" proved="true">
+  <proof prover="3"><result status="valid" time="0.09"/></proof>
+  </goal>
+  <goal name="add_interval_off_remain&#39;vc.23" expl="assertion" proved="true">
+  <proof prover="3"><result status="valid" time="1.02"/></proof>
+  </goal>
+  <goal name="add_interval_off_remain&#39;vc.24" expl="assertion" proved="true">
+  <proof prover="3"><result status="valid" time="0.80"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.55" expl="assertion" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.25" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.55.0" expl="assertion" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.25.0" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.05"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.55.1" expl="assertion" proved="true">
-   <proof prover="3"><result status="valid" time="0.04"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.25.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.05"/></proof>
+   </goal>
+   <goal name="add_interval_off_remain&#39;vc.25.2" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.17"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.55.2" expl="assertion" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.25.3" expl="postcondition" proved="true">
+   <transf name="left" proved="true" >
+    <goal name="add_interval_off_remain&#39;vc.25.3.0" expl="left case" proved="true">
+    <proof prover="3" timelimit="100"><result status="valid" time="5.35"/></proof>
+    </goal>
+   </transf>
+   </goal>
+   <goal name="add_interval_off_remain&#39;vc.25.4" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.04"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.56" expl="assertion" proved="true">
-  <proof prover="3"><result status="valid" time="0.74"/></proof>
-  </goal>
-  <goal name="add_interval&#39;vc.57" expl="assertion" proved="true">
-  <proof prover="3"><result status="valid" time="0.59"/></proof>
-  </goal>
-  <goal name="add_interval&#39;vc.58" expl="postcondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.26" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.58.0" expl="postcondition" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.26.0" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.04"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.58.1" expl="postcondition" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.26.1" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.04"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.58.2" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.14"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.26.2" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.11"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.58.3" expl="postcondition" proved="true">
-   <proof prover="3" timelimit="100"><result status="valid" time="5.85"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.26.3" expl="postcondition" proved="true">
+   <transf name="left" proved="true" >
+    <goal name="add_interval_off_remain&#39;vc.26.3.0" expl="left case" proved="true">
+    <proof prover="3"><result status="valid" time="4.63"/></proof>
+    </goal>
+   </transf>
    </goal>
-   <goal name="add_interval&#39;vc.58.4" expl="postcondition" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.26.4" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.04"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.59" expl="postcondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.27" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.59.0" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.02"/></proof>
-   </goal>
-   <goal name="add_interval&#39;vc.59.1" expl="postcondition" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.27.0" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.03"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.59.2" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.08"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.27.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.07"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.59.3" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="5.14"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.27.2" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.12"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.59.4" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.02"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.27.3" expl="postcondition" proved="true">
+   <transf name="left" proved="true" >
+    <goal name="add_interval_off_remain&#39;vc.27.3.0" expl="left case" proved="true">
+    <proof prover="3"><result status="valid" time="4.27"/></proof>
+    </goal>
+   </transf>
+   </goal>
+   <goal name="add_interval_off_remain&#39;vc.27.4" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.07"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.60" expl="postcondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.28" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.60.0" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.03"/></proof>
-   </goal>
-   <goal name="add_interval&#39;vc.60.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.06"/></proof>
-   </goal>
-   <goal name="add_interval&#39;vc.60.2" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.11"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.28.0" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="1.01"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.60.3" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="5.04"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.28.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="1.16"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.60.4" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.06"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.28.2" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.02"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.61" expl="postcondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.29" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.92"/></proof>
+  </goal>
+  <goal name="add_interval_off_remain&#39;vc.30" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.61.0" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="1.17"/></proof>
-   </goal>
-   <goal name="add_interval&#39;vc.61.1" expl="postcondition" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.30.0" expl="postcondition" proved="true">
    <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.61.1.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.83"/></proof>
+    <goal name="add_interval_off_remain&#39;vc.30.0.0" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="3.19"/></proof>
     </goal>
-    <goal name="add_interval&#39;vc.61.1.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
+    <goal name="add_interval_off_remain&#39;vc.30.0.1" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="3.51"/></proof>
     </goal>
-    <goal name="add_interval&#39;vc.61.1.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.08"/></proof>
+    <goal name="add_interval_off_remain&#39;vc.30.0.2" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="1.20"/></proof>
     </goal>
-    <goal name="add_interval&#39;vc.61.1.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.05"/></proof>
+    <goal name="add_interval_off_remain&#39;vc.30.0.3" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="1.46"/></proof>
     </goal>
-    <goal name="add_interval&#39;vc.61.1.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.01"/></proof>
+    <goal name="add_interval_off_remain&#39;vc.30.0.4" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="2.21"/></proof>
     </goal>
    </transf>
    </goal>
-   <goal name="add_interval&#39;vc.61.2" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.01"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.30.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.76"/></proof>
+   </goal>
+   <goal name="add_interval_off_remain&#39;vc.30.2" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.02"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.62" expl="postcondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.31" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.62.0" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.62.0.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.62.0.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.62.0.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.06"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.62.0.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.04"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.62.0.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-   </transf>
+   <goal name="add_interval_off_remain&#39;vc.31.0" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="3.73"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.62.1" expl="postcondition" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.31.1" expl="postcondition" proved="true">
    <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.62.1.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.62.1.1" expl="postcondition" proved="true">
+    <goal name="add_interval_off_remain&#39;vc.31.1.0" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.03"/></proof>
     </goal>
-    <goal name="add_interval&#39;vc.62.1.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.04"/></proof>
+    <goal name="add_interval_off_remain&#39;vc.31.1.1" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
-    <goal name="add_interval&#39;vc.62.1.3" expl="postcondition" proved="true">
+    <goal name="add_interval_off_remain&#39;vc.31.1.2" expl="postcondition" proved="true">
     <proof prover="3"><result status="valid" time="0.03"/></proof>
     </goal>
-    <goal name="add_interval&#39;vc.62.1.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.10"/></proof>
+    <goal name="add_interval_off_remain&#39;vc.31.1.3" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="3.91"/></proof>
+    </goal>
+    <goal name="add_interval_off_remain&#39;vc.31.1.4" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="4.67"/></proof>
     </goal>
    </transf>
    </goal>
-   <goal name="add_interval&#39;vc.62.2" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.02"/></proof>
+   <goal name="add_interval_off_remain&#39;vc.31.2" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.01"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.63" expl="postcondition" proved="true">
+  <goal name="add_interval_off_remain&#39;vc.32" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.63.0" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.63.0.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="2.60"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.63.0.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="2.85"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.63.0.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="1.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.63.0.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="1.25"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.63.0.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="1.91"/></proof>
-    </goal>
-   </transf>
+   <goal name="add_interval_off_remain&#39;vc.32.0" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.25"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.63.1" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.63.1.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.83"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.63.1.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.04"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.63.1.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.22"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.63.1.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.63.1.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-   </transf>
+   <goal name="add_interval_off_remain&#39;vc.32.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.24"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.63.2" expl="postcondition" proved="true">
+   <goal name="add_interval_off_remain&#39;vc.32.2" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.02"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.64" expl="postcondition" proved="true">
+ </transf>
+ </goal>
+ <goal name="add_interval&#39;vc" expl="VC for add_interval" proved="true">
+ <transf name="split_vc" proved="true" >
+  <goal name="add_interval&#39;vc.0" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  </goal>
+  <goal name="add_interval&#39;vc.1" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="add_interval&#39;vc.2" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_interval&#39;vc.3" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_interval&#39;vc.4" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_interval&#39;vc.5" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_interval&#39;vc.6" expl="assertion" proved="true">
+  <proof prover="3"><result status="valid" time="1.13"/></proof>
+  </goal>
+  <goal name="add_interval&#39;vc.7" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="add_interval&#39;vc.8" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_interval&#39;vc.9" expl="postcondition" proved="true">
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.64.0" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.64.0.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.64.0.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.85"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.64.0.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.04"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.64.0.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.79"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.64.0.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.85"/></proof>
-    </goal>
-   </transf>
-   </goal>
-   <goal name="add_interval&#39;vc.64.1" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.64.1.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.64.1.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.64.1.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.64.1.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="3.56"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.64.1.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="4.28"/></proof>
-    </goal>
-   </transf>
-   </goal>
-   <goal name="add_interval&#39;vc.64.2" expl="postcondition" proved="true">
+   <goal name="add_interval&#39;vc.9.0" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.02"/></proof>
    </goal>
+   <goal name="add_interval&#39;vc.9.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.06"/></proof>
+   </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.65" expl="postcondition" proved="true">
+  <goal name="add_interval&#39;vc.10" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.03"/></proof>
+  </goal>
+ </transf>
+ </goal>
+ <goal name="mem_in_off_not_inf&#39;vc" expl="VC for mem_in_off_not_inf" proved="true">
+ <proof prover="3"><result status="valid" time="0.16"/></proof>
+ </goal>
+ <goal name="add_minus_inf_on&#39;vc" expl="VC for add_minus_inf_on">
+ <transf name="split_vc" >
+  <goal name="add_minus_inf_on&#39;vc.0" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.1" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.2" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.3" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.4" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.5" expl="assertion" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.6" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.7" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.8" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.9" expl="assertion" proved="true">
+  <proof prover="3"><result status="valid" time="0.46"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.10" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.11" expl="postcondition" proved="true">
+  <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
   <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.65.0" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.65.0.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.65.0.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.65.0.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.65.0.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.04"/></proof>
+   <goal name="add_minus_inf_on&#39;vc.11.0" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.33"/></proof>
+   </goal>
+   <goal name="add_minus_inf_on&#39;vc.11.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.02"/></proof>
+   </goal>
+   <goal name="add_minus_inf_on&#39;vc.11.2" expl="postcondition" proved="true">
+   <transf name="case" proved="true" arg1="(cmp q x1 x2)">
+    <goal name="add_minus_inf_on&#39;vc.11.2.0" expl="true case (postcondition)" proved="true">
+    <transf name="eliminate_let_fmla" proved="true" >
+     <goal name="add_minus_inf_on&#39;vc.11.2.0.0" expl="true case (postcondition)" proved="true">
+     <transf name="instantiate" proved="true" arg1="H4" arg2="q,q&#39;">
+      <goal name="add_minus_inf_on&#39;vc.11.2.0.0.0" expl="true case (postcondition)" proved="true">
+      <proof prover="3"><result status="valid" time="0.01"/></proof>
+      </goal>
+     </transf>
+     </goal>
+    </transf>
     </goal>
-    <goal name="add_interval&#39;vc.65.0.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.02"/></proof>
+    <goal name="add_minus_inf_on&#39;vc.11.2.1" expl="false case (postcondition)" proved="true">
+    <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
    </transf>
    </goal>
-   <goal name="add_interval&#39;vc.65.1" expl="postcondition" proved="true">
-   <transf name="split_vc" proved="true" >
-    <goal name="add_interval&#39;vc.65.1.0" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
-    </goal>
-    <goal name="add_interval&#39;vc.65.1.1" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.04"/></proof>
+   <goal name="add_minus_inf_on&#39;vc.11.3" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.01"/></proof>
+   </goal>
+  </transf>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.12" expl="postcondition">
+  <proof prover="3" obsolete="true"><result status="timeout" time="5.00"/></proof>
+  <transf name="split_vc" >
+   <goal name="add_minus_inf_on&#39;vc.12.0" expl="postcondition">
+   <proof prover="3"><result status="timeout" time="5.00"/></proof>
+   <transf name="split_vc" >
+    <goal name="add_minus_inf_on&#39;vc.12.0.0" expl="postcondition">
+    <proof prover="3"><result status="timeout" time="5.00"/></proof>
     </goal>
-    <goal name="add_interval&#39;vc.65.1.2" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
+    <goal name="add_minus_inf_on&#39;vc.12.0.1" expl="postcondition">
+    <proof prover="3"><result status="timeout" time="5.00"/></proof>
     </goal>
-    <goal name="add_interval&#39;vc.65.1.3" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.03"/></proof>
+    <goal name="add_minus_inf_on&#39;vc.12.0.2" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.36"/></proof>
     </goal>
-    <goal name="add_interval&#39;vc.65.1.4" expl="postcondition" proved="true">
-    <proof prover="3"><result status="valid" time="0.04"/></proof>
+    <goal name="add_minus_inf_on&#39;vc.12.0.3" expl="postcondition" proved="true">
+    <proof prover="3"><result status="valid" time="0.01"/></proof>
     </goal>
    </transf>
    </goal>
-   <goal name="add_interval&#39;vc.65.2" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.02"/></proof>
+   <goal name="add_minus_inf_on&#39;vc.12.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="3.69"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.66" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  <goal name="add_minus_inf_on&#39;vc.13" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.67" expl="precondition" proved="true">
+  <goal name="add_minus_inf_on&#39;vc.14" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.68" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="add_minus_inf_on&#39;vc.15" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.69" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  <goal name="add_minus_inf_on&#39;vc.16" expl="variant decrease" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.70" expl="precondition" proved="true">
+  <goal name="add_minus_inf_on&#39;vc.17" expl="precondition" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.71" expl="precondition" proved="true">
+  <goal name="add_minus_inf_on&#39;vc.18" expl="unreachable point" proved="true">
   <proof prover="3"><result status="valid" time="0.01"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.72" expl="assertion" proved="true">
-  <proof prover="3"><result status="valid" time="1.13"/></proof>
-  </goal>
-  <goal name="add_interval&#39;vc.73" expl="precondition" proved="true">
+  <goal name="add_minus_inf_on&#39;vc.19" expl="postcondition" proved="true">
   <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
-  <goal name="add_interval&#39;vc.74" expl="precondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.01"/></proof>
-  </goal>
-  <goal name="add_interval&#39;vc.75" expl="postcondition" proved="true">
-  <transf name="split_vc" proved="true" >
-   <goal name="add_interval&#39;vc.75.0" expl="postcondition" proved="true">
+  <goal name="add_minus_inf_on&#39;vc.20" expl="postcondition">
+  <proof prover="3"><result status="timeout" time="5.00"/></proof>
+  <transf name="split_vc" >
+   <goal name="add_minus_inf_on&#39;vc.20.0" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="0.03"/></proof>
+   </goal>
+   <goal name="add_minus_inf_on&#39;vc.20.1" expl="postcondition">
+   <proof prover="3"><result status="highfailure" time="3.87"/></proof>
+   </goal>
+   <goal name="add_minus_inf_on&#39;vc.20.2" expl="postcondition" proved="true">
    <proof prover="3"><result status="valid" time="0.02"/></proof>
    </goal>
-   <goal name="add_interval&#39;vc.75.1" expl="postcondition" proved="true">
-   <proof prover="3"><result status="valid" time="0.06"/></proof>
+  </transf>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.21" expl="postcondition">
+  <proof prover="3"><result status="timeout" time="5.00"/></proof>
+  <transf name="split_vc" >
+   <goal name="add_minus_inf_on&#39;vc.21.0" expl="postcondition">
+   <proof prover="3"><result status="timeout" time="5.00"/></proof>
+   </goal>
+   <goal name="add_minus_inf_on&#39;vc.21.1" expl="postcondition" proved="true">
+   <proof prover="3"><result status="valid" time="2.03"/></proof>
    </goal>
   </transf>
   </goal>
-  <goal name="add_interval&#39;vc.76" expl="postcondition" proved="true">
-  <proof prover="3"><result status="valid" time="0.03"/></proof>
+  <goal name="add_minus_inf_on&#39;vc.22" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.23" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.24" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.25" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.26" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.27" expl="assertion">
+  <proof prover="3"><result status="timeout" time="5.00"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.28" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.01"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.29" expl="precondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.00"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.30" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
+  </goal>
+  <goal name="add_minus_inf_on&#39;vc.31" expl="postcondition" proved="true">
+  <proof prover="3"><result status="valid" time="0.02"/></proof>
   </goal>
  </transf>
  </goal>
diff --git a/src_common/union__Union.ml b/src_common/union__Union.ml
index 13fd7e3a0..84e58b318 100644
--- a/src_common/union__Union.ml
+++ b/src_common/union__Union.ml
@@ -223,138 +223,139 @@ let inter (u: t') (v: t') : t' option =
   | ((On u8, Off v8) | (Off v8, On u8)) -> mk_off_option (inter_on_off u8 v8)
   | (Off u8, Off v8) -> mk_off_option (inter_off_off u8 v8)
 
-let union (u: t') (v: t') : t' =
-  let rec union_on_on (u1: on) (v1: on) : on =
-    match (u1, v1) with
-    | ((_, OnInf) | (OnInf, _)) -> OnInf
-    | (OnSin (qu,
-      lu),
-      OnSin (qv,
-      lv)) ->
-      begin match (Q_extra.compare qu qv) with
-      | Ord.Eq -> OnSin (qu, union_on_on lu lv)
-      | Ord.Lt -> union_on_on lu v1
-      | Ord.Gt -> union_on_on u1 lv
-      end
-    | (OnEnd (qu,
-      bu,
-      lu),
-      OnEnd (qv,
-      bv,
-      lv)) ->
-      begin match (Q_extra.compare qu qv) with
-      | Ord.Eq ->
-        (let b =
-           match (bu, bv) with
-           | (Interval__Bound.Strict,
-             Interval__Bound.Strict) ->
-             Interval__Bound.Strict
-           | _ -> Interval__Bound.Large in
-         OnEnd (qu, b, union_off_off lu lv))
-      | Ord.Lt -> union_on_off v1 lu
-      | Ord.Gt -> union_on_off u1 lv
-      end
-    | (((OnSin (qu, lu) as u3),
-       (OnEnd (qv, bv, lv) as v3)) | ((OnEnd (qv, bv, lv) as v3),
-       (OnSin (qu, lu) as u3))) ->
-      begin match (Q_extra.compare qu qv) with
-      | Ord.Eq ->
-        begin match bv with
-        | Interval__Bound.Strict -> OnSin (qv, union_on_off lu lv)
-        | _ -> union_on_off lu lv
-        end
-      | Ord.Lt -> union_on_on lu v3
-      | Ord.Gt -> union_on_off u3 lv
-      end
-  and union_on_off (u6: on) (v6: off) : on =
-    match (u6, v6) with
-    | (u8, OffInf) -> u8
-    | (OnInf, _) -> OnInf
-    | (OnSin (qu,
-      lu),
-      OffSin (qv,
-      lv)) ->
-      begin match (Q_extra.compare qu qv) with
-      | Ord.Eq -> union_on_off lu lv
-      | Ord.Lt -> OnSin (qu, union_on_off lu v6)
-      | Ord.Gt -> union_on_off u6 lv
-      end
-    | (OnEnd (qu,
-      bu,
-      lu),
-      OffEnd (qv,
-      bv,
-      lv)) ->
-      begin match (Q_extra.compare qu qv) with
-      | Ord.Eq ->
-        begin match (bu, bv) with
-        | (Interval__Bound.Strict,
-          Interval__Bound.Strict) ->
-          OnSin (qu, union_on_off lv lu)
-        | _ -> union_on_off lv lu
-        end
-      | Ord.Lt -> OnEnd (qu, bu, union_off_off lu v6)
-      | Ord.Gt -> union_on_on u6 lv
-      end
-    | ((OnSin (qu, lu) as u8),
-      (OffEnd (qv, bv, lv) as v8)) ->
-      begin match (Q_extra.compare qu qv) with
-      | Ord.Eq ->
-        begin match bv with
-        | Interval__Bound.Large -> union_on_on lu lv
-        | Interval__Bound.Strict -> OnSin (qu, union_on_on lu lv)
-        end
-      | Ord.Lt -> OnSin (qu, union_on_off lu v8)
-      | Ord.Gt -> union_on_on u8 lv
-      end
-    | ((OnEnd (qv, bv, lv) as v9),
-      (OffSin (qu, lu) as u9)) ->
-      begin match (Q_extra.compare qu qv) with
-      | Ord.Eq -> OnEnd (qv, Interval__Bound.Large, union_off_off lu lv)
-      | Ord.Lt -> union_on_off v9 lu
-      | Ord.Gt -> OnEnd (qv, bv, union_off_off u9 lv)
+let rec union_on_on (u: on) (v: on) : on =
+  match (u, v) with
+  | ((_, OnInf) | (OnInf, _)) -> OnInf
+  | (OnSin (qu,
+    lu),
+    OnSin (qv,
+    lv)) ->
+    begin match (Q_extra.compare qu qv) with
+    | Ord.Eq -> OnSin (qu, union_on_on lu lv)
+    | Ord.Lt -> union_on_on lu v
+    | Ord.Gt -> union_on_on u lv
+    end
+  | (OnEnd (qu,
+    bu,
+    lu),
+    OnEnd (qv,
+    bv,
+    lv)) ->
+    begin match (Q_extra.compare qu qv) with
+    | Ord.Eq ->
+      (let b =
+         match (bu, bv) with
+         | (Interval__Bound.Strict,
+           Interval__Bound.Strict) ->
+           Interval__Bound.Strict
+         | _ -> Interval__Bound.Large in
+       OnEnd (qu, b, union_off_off lu lv))
+    | Ord.Lt -> union_on_off v lu
+    | Ord.Gt -> union_on_off u lv
+    end
+  | (((OnSin (qu, lu) as u1),
+     (OnEnd (qv, bv, lv) as v1)) | ((OnEnd (qv, bv, lv) as v1),
+     (OnSin (qu, lu) as u1))) ->
+    begin match (Q_extra.compare qu qv) with
+    | Ord.Eq ->
+      begin match bv with
+      | Interval__Bound.Strict -> OnSin (qv, union_on_off lu lv)
+      | _ -> union_on_off lu lv
       end
-  and union_off_off (u10: off) (v10: off) : off =
-    match (u10, v10) with
-    | ((u11, OffInf) | (OffInf, u11)) -> u11
-    | (OffSin (qu,
-      lu),
-      OffSin (qv,
-      lv)) ->
-      begin match (Q_extra.compare qu qv) with
-      | Ord.Eq -> OffSin (qu, union_off_off lu lv)
-      | Ord.Lt -> OffSin (qu, union_off_off lu v10)
-      | Ord.Gt -> OffSin (qv, union_off_off u10 lv)
+    | Ord.Lt -> union_on_on lu v1
+    | Ord.Gt -> union_on_off u1 lv
+    end
+and union_on_off (u: on) (v: off) : on =
+  match (u, v) with
+  | (u3, OffInf) -> u3
+  | (OnInf, _) -> OnInf
+  | (OnSin (qu,
+    lu),
+    OffSin (qv,
+    lv)) ->
+    begin match (Q_extra.compare qu qv) with
+    | Ord.Eq -> union_on_off lu lv
+    | Ord.Lt -> OnSin (qu, union_on_off lu v)
+    | Ord.Gt -> union_on_off u lv
+    end
+  | (OnEnd (qu,
+    bu,
+    lu),
+    OffEnd (qv,
+    bv,
+    lv)) ->
+    begin match (Q_extra.compare qu qv) with
+    | Ord.Eq ->
+      begin match (bu, bv) with
+      | (Interval__Bound.Strict,
+        Interval__Bound.Strict) ->
+        OnSin (qu, union_on_off lv lu)
+      | _ -> union_on_off lv lu
       end
-    | (OffEnd (qu,
-      bu,
-      lu),
-      OffEnd (qv,
-      bv,
-      lv)) ->
-      begin match (Q_extra.compare qu qv) with
-      | Ord.Eq ->
-        (let b =
-           match (bu, bv) with
-           | (Interval__Bound.Strict,
-             Interval__Bound.Strict) ->
-             Interval__Bound.Strict
-           | _ -> Interval__Bound.Large in
-         OffEnd (qu, b, union_on_on lu lv))
-      | Ord.Lt -> OffEnd (qu, bu, union_on_off lu v10)
-      | Ord.Gt -> OffEnd (qv, bv, union_on_off lv u10)
+    | Ord.Lt -> OnEnd (qu, bu, union_off_off lu v)
+    | Ord.Gt -> union_on_on u lv
+    end
+  | ((OnSin (qu, lu) as u6),
+    (OffEnd (qv, bv, lv) as v3)) ->
+    begin match (Q_extra.compare qu qv) with
+    | Ord.Eq ->
+      begin match bv with
+      | Interval__Bound.Large -> union_on_on lu lv
+      | Interval__Bound.Strict -> OnSin (qu, union_on_on lu lv)
       end
-    | (((OffSin (qu, lu) as u11),
-       (OffEnd (qv, bv, lv) as v11)) | ((OffEnd (qv, bv, lv) as v11),
-       (OffSin (qu, lu) as u11))) ->
-      begin match (Q_extra.compare qu qv) with
-      | Ord.Eq -> OffEnd (qv, Interval__Bound.Large, union_on_off lv lu)
-      | Ord.Lt -> OffSin (qu, union_off_off lu v11)
-      | Ord.Gt -> OffEnd (qv, bv, union_on_off lv u11)
-      end in
+    | Ord.Lt -> OnSin (qu, union_on_off lu v3)
+    | Ord.Gt -> union_on_on u6 lv
+    end
+  | ((OnEnd (qv, bv, lv) as v6),
+    (OffSin (qu, lu) as u8)) ->
+    begin match (Q_extra.compare qu qv) with
+    | Ord.Eq -> OnEnd (qv, Interval__Bound.Large, union_off_off lu lv)
+    | Ord.Lt -> union_on_off v6 lu
+    | Ord.Gt -> OnEnd (qv, bv, union_off_off u8 lv)
+    end
+and union_off_off (u: off) (v: off) : off =
   match (u, v) with
-  | (On u12, On v12) -> On (union_on_on u12 v12)
-  | ((On u12, Off v12) | (Off v12, On u12)) -> On (union_on_off u12 v12)
+  | ((u3, OffInf) | (OffInf, u3)) -> u3
+  | (OffSin (qu,
+    lu),
+    OffSin (qv,
+    lv)) ->
+    begin match (Q_extra.compare qu qv) with
+    | Ord.Eq -> OffSin (qu, union_off_off lu lv)
+    | Ord.Lt -> OffSin (qu, union_off_off lu v)
+    | Ord.Gt -> OffSin (qv, union_off_off u lv)
+    end
+  | (OffEnd (qu,
+    bu,
+    lu),
+    OffEnd (qv,
+    bv,
+    lv)) ->
+    begin match (Q_extra.compare qu qv) with
+    | Ord.Eq ->
+      (let b =
+         match (bu, bv) with
+         | (Interval__Bound.Strict,
+           Interval__Bound.Strict) ->
+           Interval__Bound.Strict
+         | _ -> Interval__Bound.Large in
+       OffEnd (qu, b, union_on_on lu lv))
+    | Ord.Lt -> OffEnd (qu, bu, union_on_off lu v)
+    | Ord.Gt -> OffEnd (qv, bv, union_on_off lv u)
+    end
+  | (((OffSin (qu, lu) as u9),
+     (OffEnd (qv, bv, lv) as v8)) | ((OffEnd (qv, bv, lv) as v8),
+     (OffSin (qu, lu) as u9))) ->
+    begin match (Q_extra.compare qu qv) with
+    | Ord.Eq -> OffEnd (qv, Interval__Bound.Large, union_on_off lv lu)
+    | Ord.Lt -> OffSin (qu, union_off_off lu v8)
+    | Ord.Gt -> OffEnd (qv, bv, union_on_off lv u9)
+    end
+
+let union (u: t') (v: t') : t' =
+  match (u, v) with
+  | (On u3, On v9) -> On (union_on_on u3 v9)
+  | ((On u10, Off v9) | (Off v9, On u10)) -> On (union_on_off u10 v9)
   | (Off u', Off v') -> (let w = union_off_off u' v' in Off w)
 
 let cmp (x: Q.t) (b: Interval__Bound.t) (y: Q.t) : bool =
@@ -459,68 +460,88 @@ let add_bound (b1: Interval__Bound.t) (b2: Interval__Bound.t) :
     Interval__Bound.Strict) ->
     Interval__Bound.Strict
 
+let rec add_interval_on (bu: Interval__Bound.t) (u: Q.t) (v: Q.t)
+                        (bv: Interval__Bound.t) (l: on) : on =
+  match l with
+  | OnSin (qs, l') -> (let res = add_interval_on bu u v bv l' in res)
+  | OnEnd (qs,
+    bq,
+    l') ->
+    (let br = add_bound bq bv in let r = (Q.(+) qs v) in
+     let res = add_interval_off_remain bu u v bv r br l' in res)
+  | OnInf -> OnInf
+and add_interval_off (bu: Interval__Bound.t) (u: Q.t) (v: Q.t)
+                     (bv: Interval__Bound.t) (l: off) : off =
+  match l with
+  | OffSin (qs,
+    l') ->
+    (let r = (Q.(+) qs v) in
+     let res = add_interval_off_remain bu u v bv r bv l' in
+     let res1 = OffEnd ((Q.(+) qs u), bu, res) in res1)
+  | OffEnd (qs,
+    b,
+    l') ->
+    (let bbu = add_bound b bu in let res0 = add_interval_on bu u v bv l' in
+     let res = OffEnd ((Q.(+) qs u), bbu, res0) in res)
+  | OffInf -> OffInf
+and add_interval_off_remain (bu: Interval__Bound.t) (u: Q.t) (v: Q.t)
+                            (bv: Interval__Bound.t) (r: Q.t)
+                            (br: Interval__Bound.t) (l: off) : on =
+  match l with
+  | OffSin (qs,
+    l') ->
+    (let qu = (Q.(+) qs u) in let r' = (Q.(+) qs v) in
+     let res = add_interval_off_remain bu u v bv r' bv l' in
+     match (Q_extra.compare r qu) with
+     | Ord.Lt -> (let res1 = OnEnd (r, br, OffEnd (qu, bu, res)) in res1)
+     | Ord.Gt -> res
+     | Ord.Eq ->
+       begin match (br, bu) with
+       | (Interval__Bound.Strict,
+         Interval__Bound.Strict) ->
+         (let res1 = OnSin (qu, res) in res1)
+       | _ -> res
+       end)
+  | OffEnd (qs,
+    b,
+    l') ->
+    (let qu = (Q.(+) qs u) in let bbu = add_bound b bu in
+     let res = add_interval_on bu u v bv l' in
+     match (Q_extra.compare r qu) with
+     | Ord.Lt -> (let res1 = OnEnd (r, br, OffEnd (qu, bbu, res)) in res1)
+     | Ord.Gt -> res
+     | Ord.Eq ->
+       begin match (br, bbu) with
+       | (Interval__Bound.Strict,
+         Interval__Bound.Strict) ->
+         (let res1 = OnSin (qu, res) in res1)
+       | _ -> res
+       end)
+  | OffInf -> OnEnd (r, br, OffInf)
+
 let add_interval (l: t') (bu: Interval__Bound.t) (u: Q.t) (v: Q.t)
                  (bv: Interval__Bound.t) : t' =
-  let rec add_interval_on (bu1: Interval__Bound.t) (u1: Q.t) (v1: Q.t)
-                          (bv1: Interval__Bound.t) (l1: on) : on =
+  match l with
+  | On l1 -> (let res = add_interval_on bu u v bv l1 in On res)
+  | Off l_off -> (let l1 = add_interval_off bu u v bv l_off in Off l1)
+
+let add_minus_inf_on (v: Q.t) (bv: Interval__Bound.t) (l: t') : t' =
+  let rec add_minus_inf_on (v9: Q.t) (bv1: Interval__Bound.t) (l1: on) : on =
     match l1 with
-    | OnSin (qs, l') -> (let res = add_interval_on bu1 u1 v1 bv1 l' in res)
+    | OnSin (_, l') -> add_minus_inf_on v9 bv1 l'
     | OnEnd (qs,
-      bq,
-      l') ->
-      (let br = add_bound bq bv1 in let r = (Q.(+) qs v1) in
-       let res = add_interval_off_remain bu1 u1 v1 bv1 r br l' in res)
+      bs,
+      OffInf) ->
+      OnEnd ((Q.(+) v9 qs), add_bound bv1 bs, OffInf)
+    | OnEnd (qs, bs, l') -> (let res = add_minus_inf_off v9 bv1 l' in res)
     | OnInf -> OnInf
-  and add_interval_off (bu1: Interval__Bound.t) (u6: Q.t) (v6: Q.t)
-                       (bv1: Interval__Bound.t) (l1: off) : off =
+  and add_minus_inf_off (v9: Q.t) (bv1: Interval__Bound.t) (l1: off) : on =
     match l1 with
-    | OffSin (qs,
-      l') ->
-      (let r = (Q.(+) qs v6) in
-       let res = add_interval_off_remain bu1 u6 v6 bv1 r bv1 l' in
-       let res1 = OffEnd ((Q.(+) qs u6), bu1, res) in res1)
-    | OffEnd (qs,
-      b,
-      l') ->
-      (let bbu = add_bound b bu1 in
-       let res0 = add_interval_on bu1 u6 v6 bv1 l' in
-       let res = OffEnd ((Q.(+) qs u6), bbu, res0) in res)
-    | OffInf -> OffInf
-  and add_interval_off_remain (bu1: Interval__Bound.t) (u10: Q.t) (v10: Q.t)
-                              (bv1: Interval__Bound.t) (r: Q.t)
-                              (br: Interval__Bound.t) (l1: off) : on =
-    match l1 with
-    | OffSin (qs,
-      l') ->
-      (let qu = (Q.(+) qs u10) in let r' = (Q.(+) qs v10) in
-       let res = add_interval_off_remain bu1 u10 v10 bv1 r' bv1 l' in
-       match (Q_extra.compare r qu) with
-       | Ord.Lt -> (let res1 = OnEnd (r, br, OffEnd (qu, bu1, res)) in res1)
-       | Ord.Gt -> res
-       | Ord.Eq ->
-         begin match (br, bu1) with
-         | (Interval__Bound.Strict,
-           Interval__Bound.Strict) ->
-           (let res1 = OnSin (qu, res) in res1)
-         | _ -> res
-         end)
-    | OffEnd (qs,
-      b,
-      l') ->
-      (let qu = (Q.(+) qs u10) in let bbu = add_bound b bu1 in
-       let res = add_interval_on bu1 u10 v10 bv1 l' in
-       match (Q_extra.compare r qu) with
-       | Ord.Lt -> (let res1 = OnEnd (r, br, OffEnd (qu, bbu, res)) in res1)
-       | Ord.Gt -> res
-       | Ord.Eq ->
-         begin match (br, bbu) with
-         | (Interval__Bound.Strict,
-           Interval__Bound.Strict) ->
-           (let res1 = OnSin (qu, res) in res1)
-         | _ -> res
-         end)
-    | OffInf -> OnEnd (r, br, OffInf) in
+    | OffSin (qs, OffInf) -> OnEnd ((Q.(+) v9 qs), bv1, OffInf)
+    | OffSin (_, l') -> add_minus_inf_off v9 bv1 l'
+    | OffEnd (_, _, l') -> add_minus_inf_on v9 bv1 l'
+    | OffInf -> assert false (* absurd *) in
   match l with
-  | On l1 -> (let res = add_interval_on bu u v bv l1 in On res)
-  | Off l_off -> (let l1 = add_interval_off bu u v bv l_off in Off l1)
+  | On l1 -> (let res = add_minus_inf_on v bv l1 in On res)
+  | Off l_off -> (let l1 = add_minus_inf_off v bv l_off in On l1)
 
-- 
GitLab