Reorganize the Lean tests

7 files changed, 107 insertions, 176 deletions

diff --git a/tests/lean/hashmap/Hashmap.lean b/tests/lean/Hashmap.lean
index 41630205..41630205 100644
--- a/tests/lean/hashmap/Hashmap.lean
+++ b/tests/lean/Hashmap.lean
diff --git a/tests/lean/hashmap/Hashmap/Funs.lean b/tests/lean/Hashmap/Funs.lean
index 77b1a157..26742d5d 100644
--- a/tests/lean/hashmap/Hashmap/Funs.lean
+++ b/tests/lean/Hashmap/Funs.lean
@@ -1,28 +1,23 @@
 -- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS
 -- [hashmap]: function definitions
-import Base.Primitives
+import Base
 import Hashmap.Types
-import Hashmap.Clauses.Clauses
+open Primitives
 
 /- [hashmap::hash_key] -/
 def hash_key_fwd (k : Usize) : Result Usize :=
   Result.ret k
 
 /- [hashmap::HashMap::{0}::allocate_slots] -/
-def hash_map_allocate_slots_loop_fwd
-  (T : Type) (slots : Vec (list_t T)) (n : Usize) :
-  (Result (Vec (list_t T)))
-  :=
-  if h: n > (Usize.ofInt 0 (by intlit))
+divergent def hash_map_allocate_slots_loop_fwd
+  (T : Type) (slots : Vec (list_t T)) (n : Usize) : Result (Vec (list_t T)) :=
+  if n > (Usize.ofInt 0 (by intlit))
   then
     do
       let slots0 ← vec_push_back (list_t T) slots list_t.Nil
       let n0 ← n - (Usize.ofInt 1 (by intlit))
       hash_map_allocate_slots_loop_fwd T slots0 n0
   else Result.ret slots
-termination_by hash_map_allocate_slots_loop_fwd slots n =>
-  hash_map_allocate_slots_loop_terminates T slots n
-decreasing_by hash_map_allocate_slots_loop_decreases slots n
 
 /- [hashmap::HashMap::{0}::allocate_slots] -/
 def hash_map_allocate_slots_fwd
@@ -54,21 +49,16 @@ def hash_map_new_fwd (T : Type) : Result (hash_map_t T) :=
     (Usize.ofInt 4 (by intlit)) (Usize.ofInt 5 (by intlit))
 
 /- [hashmap::HashMap::{0}::clear] -/
-def hash_map_clear_loop_fwd_back
-  (T : Type) (slots : Vec (list_t T)) (i : Usize) :
-  (Result (Vec (list_t T)))
-  :=
+divergent def hash_map_clear_loop_fwd_back
+  (T : Type) (slots : Vec (list_t T)) (i : Usize) : Result (Vec (list_t T)) :=
   let i0 := vec_len (list_t T) slots
-  if h: i < i0
+  if i < i0
   then
     do
       let i1 ← i + (Usize.ofInt 1 (by intlit))
       let slots0 ← vec_index_mut_back (list_t T) slots i list_t.Nil
       hash_map_clear_loop_fwd_back T slots0 i1
   else Result.ret slots
-termination_by hash_map_clear_loop_fwd_back slots i =>
-  hash_map_clear_loop_terminates T slots i
-decreasing_by hash_map_clear_loop_decreases slots i
 
 /- [hashmap::HashMap::{0}::clear] -/
 def hash_map_clear_fwd_back
@@ -90,17 +80,14 @@ def hash_map_len_fwd (T : Type) (self : hash_map_t T) : Result Usize :=
   Result.ret self.hash_map_num_entries
 
 /- [hashmap::HashMap::{0}::insert_in_list] -/
-def hash_map_insert_in_list_loop_fwd
-  (T : Type) (key : Usize) (value : T) (ls : list_t T) : (Result Bool) :=
+divergent def hash_map_insert_in_list_loop_fwd
+  (T : Type) (key : Usize) (value : T) (ls : list_t T) : Result Bool :=
   match h: ls with
   | list_t.Cons ckey cvalue tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret false
     else hash_map_insert_in_list_loop_fwd T key value tl
   | list_t.Nil => Result.ret true
-termination_by hash_map_insert_in_list_loop_fwd key value ls =>
-  hash_map_insert_in_list_loop_terminates T key value ls
-decreasing_by hash_map_insert_in_list_loop_decreases key value ls
 
 /- [hashmap::HashMap::{0}::insert_in_list] -/
 def hash_map_insert_in_list_fwd
@@ -108,11 +95,11 @@ def hash_map_insert_in_list_fwd
   hash_map_insert_in_list_loop_fwd T key value ls
 
 /- [hashmap::HashMap::{0}::insert_in_list] -/
-def hash_map_insert_in_list_loop_back
-  (T : Type) (key : Usize) (value : T) (ls : list_t T) : (Result (list_t T)) :=
+divergent def hash_map_insert_in_list_loop_back
+  (T : Type) (key : Usize) (value : T) (ls : list_t T) : Result (list_t T) :=
   match h: ls with
   | list_t.Cons ckey cvalue tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret (list_t.Cons ckey value tl)
     else
       do
@@ -120,9 +107,6 @@ def hash_map_insert_in_list_loop_back
         Result.ret (list_t.Cons ckey cvalue tl0)
   | list_t.Nil => let l := list_t.Nil
                   Result.ret (list_t.Cons key value l)
-termination_by hash_map_insert_in_list_loop_back key value ls =>
-  hash_map_insert_in_list_loop_terminates T key value ls
-decreasing_by hash_map_insert_in_list_loop_decreases key value ls
 
 /- [hashmap::HashMap::{0}::insert_in_list] -/
 def hash_map_insert_in_list_back
@@ -140,7 +124,7 @@ def hash_map_insert_no_resize_fwd_back
     let hash_mod ← hash % i
     let l ← vec_index_mut_fwd (list_t T) self.hash_map_slots hash_mod
     let inserted ← hash_map_insert_in_list_fwd T key value l
-    if h: inserted
+    if inserted
     then
       do
         let i0 ← self.hash_map_num_entries + (Usize.ofInt 1 (by intlit))
@@ -160,19 +144,14 @@ def core_num_u32_max_body : Result U32 :=
 def core_num_u32_max_c : U32 := eval_global core_num_u32_max_body (by simp)
 
 /- [hashmap::HashMap::{0}::move_elements_from_list] -/
-def hash_map_move_elements_from_list_loop_fwd_back
-  (T : Type) (ntable : hash_map_t T) (ls : list_t T) :
-  (Result (hash_map_t T))
-  :=
+divergent def hash_map_move_elements_from_list_loop_fwd_back
+  (T : Type) (ntable : hash_map_t T) (ls : list_t T) : Result (hash_map_t T) :=
   match h: ls with
   | list_t.Cons k v tl =>
     do
       let ntable0 ← hash_map_insert_no_resize_fwd_back T ntable k v
       hash_map_move_elements_from_list_loop_fwd_back T ntable0 tl
   | list_t.Nil => Result.ret ntable
-termination_by hash_map_move_elements_from_list_loop_fwd_back ntable ls =>
-  hash_map_move_elements_from_list_loop_terminates T ntable ls
-decreasing_by hash_map_move_elements_from_list_loop_decreases ntable ls
 
 /- [hashmap::HashMap::{0}::move_elements_from_list] -/
 def hash_map_move_elements_from_list_fwd_back
@@ -180,12 +159,12 @@ def hash_map_move_elements_from_list_fwd_back
   hash_map_move_elements_from_list_loop_fwd_back T ntable ls
 
 /- [hashmap::HashMap::{0}::move_elements] -/
-def hash_map_move_elements_loop_fwd_back
+divergent def hash_map_move_elements_loop_fwd_back
   (T : Type) (ntable : hash_map_t T) (slots : Vec (list_t T)) (i : Usize) :
-  (Result ((hash_map_t T) × (Vec (list_t T))))
+  Result ((hash_map_t T) × (Vec (list_t T)))
   :=
   let i0 := vec_len (list_t T) slots
-  if h: i < i0
+  if i < i0
   then
     do
       let l ← vec_index_mut_fwd (list_t T) slots i
@@ -196,9 +175,6 @@ def hash_map_move_elements_loop_fwd_back
       let slots0 ← vec_index_mut_back (list_t T) slots i l0
       hash_map_move_elements_loop_fwd_back T ntable0 slots0 i1
   else Result.ret (ntable, slots)
-termination_by hash_map_move_elements_loop_fwd_back ntable slots i =>
-  hash_map_move_elements_loop_terminates T ntable slots i
-decreasing_by hash_map_move_elements_loop_decreases ntable slots i
 
 /- [hashmap::HashMap::{0}::move_elements] -/
 def hash_map_move_elements_fwd_back
@@ -216,7 +192,7 @@ def hash_map_try_resize_fwd_back
     let n1 ← max_usize / (Usize.ofInt 2 (by intlit))
     let (i, i0) := self.hash_map_max_load_factor
     let i1 ← n1 / i
-    if h: capacity <= i1
+    if capacity <= i1
     then
       do
         let i2 ← capacity * (Usize.ofInt 2 (by intlit))
@@ -241,22 +217,19 @@ def hash_map_insert_fwd_back
   do
     let self0 ← hash_map_insert_no_resize_fwd_back T self key value
     let i ← hash_map_len_fwd T self0
-    if h: i > self0.hash_map_max_load
+    if i > self0.hash_map_max_load
     then hash_map_try_resize_fwd_back T self0
     else Result.ret self0
 
 /- [hashmap::HashMap::{0}::contains_key_in_list] -/
-def hash_map_contains_key_in_list_loop_fwd
-  (T : Type) (key : Usize) (ls : list_t T) : (Result Bool) :=
+divergent def hash_map_contains_key_in_list_loop_fwd
+  (T : Type) (key : Usize) (ls : list_t T) : Result Bool :=
   match h: ls with
   | list_t.Cons ckey t tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret true
     else hash_map_contains_key_in_list_loop_fwd T key tl
   | list_t.Nil => Result.ret false
-termination_by hash_map_contains_key_in_list_loop_fwd key ls =>
-  hash_map_contains_key_in_list_loop_terminates T key ls
-decreasing_by hash_map_contains_key_in_list_loop_decreases key ls
 
 /- [hashmap::HashMap::{0}::contains_key_in_list] -/
 def hash_map_contains_key_in_list_fwd
@@ -274,17 +247,14 @@ def hash_map_contains_key_fwd
     hash_map_contains_key_in_list_fwd T key l
 
 /- [hashmap::HashMap::{0}::get_in_list] -/
-def hash_map_get_in_list_loop_fwd
-  (T : Type) (key : Usize) (ls : list_t T) : (Result T) :=
+divergent def hash_map_get_in_list_loop_fwd
+  (T : Type) (key : Usize) (ls : list_t T) : Result T :=
   match h: ls with
   | list_t.Cons ckey cvalue tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret cvalue
     else hash_map_get_in_list_loop_fwd T key tl
   | list_t.Nil => Result.fail Error.panic
-termination_by hash_map_get_in_list_loop_fwd key ls =>
-  hash_map_get_in_list_loop_terminates T key ls
-decreasing_by hash_map_get_in_list_loop_decreases key ls
 
 /- [hashmap::HashMap::{0}::get_in_list] -/
 def hash_map_get_in_list_fwd
@@ -302,17 +272,14 @@ def hash_map_get_fwd
     hash_map_get_in_list_fwd T key l
 
 /- [hashmap::HashMap::{0}::get_mut_in_list] -/
-def hash_map_get_mut_in_list_loop_fwd
-  (T : Type) (ls : list_t T) (key : Usize) : (Result T) :=
+divergent def hash_map_get_mut_in_list_loop_fwd
+  (T : Type) (ls : list_t T) (key : Usize) : Result T :=
   match h: ls with
   | list_t.Cons ckey cvalue tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret cvalue
     else hash_map_get_mut_in_list_loop_fwd T tl key
   | list_t.Nil => Result.fail Error.panic
-termination_by hash_map_get_mut_in_list_loop_fwd ls key =>
-  hash_map_get_mut_in_list_loop_terminates T ls key
-decreasing_by hash_map_get_mut_in_list_loop_decreases ls key
 
 /- [hashmap::HashMap::{0}::get_mut_in_list] -/
 def hash_map_get_mut_in_list_fwd
@@ -320,20 +287,17 @@ def hash_map_get_mut_in_list_fwd
   hash_map_get_mut_in_list_loop_fwd T ls key
 
 /- [hashmap::HashMap::{0}::get_mut_in_list] -/
-def hash_map_get_mut_in_list_loop_back
-  (T : Type) (ls : list_t T) (key : Usize) (ret0 : T) : (Result (list_t T)) :=
+divergent def hash_map_get_mut_in_list_loop_back
+  (T : Type) (ls : list_t T) (key : Usize) (ret0 : T) : Result (list_t T) :=
   match h: ls with
   | list_t.Cons ckey cvalue tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret (list_t.Cons ckey ret0 tl)
     else
       do
         let tl0 ← hash_map_get_mut_in_list_loop_back T tl key ret0
         Result.ret (list_t.Cons ckey cvalue tl0)
   | list_t.Nil => Result.fail Error.panic
-termination_by hash_map_get_mut_in_list_loop_back ls key ret0 =>
-  hash_map_get_mut_in_list_loop_terminates T ls key
-decreasing_by hash_map_get_mut_in_list_loop_decreases ls key
 
 /- [hashmap::HashMap::{0}::get_mut_in_list] -/
 def hash_map_get_mut_in_list_back
@@ -365,11 +329,11 @@ def hash_map_get_mut_back
     Result.ret { self with hash_map_slots := v }
 
 /- [hashmap::HashMap::{0}::remove_from_list] -/
-def hash_map_remove_from_list_loop_fwd
-  (T : Type) (key : Usize) (ls : list_t T) : (Result (Option T)) :=
+divergent def hash_map_remove_from_list_loop_fwd
+  (T : Type) (key : Usize) (ls : list_t T) : Result (Option T) :=
   match h: ls with
   | list_t.Cons ckey t tl =>
-    if h: ckey = key
+    if ckey = key
     then
       let mv_ls :=
         mem_replace_fwd (list_t T) (list_t.Cons ckey t tl) list_t.Nil
@@ -378,9 +342,6 @@ def hash_map_remove_from_list_loop_fwd
       | list_t.Nil => Result.fail Error.panic
     else hash_map_remove_from_list_loop_fwd T key tl
   | list_t.Nil => Result.ret Option.none
-termination_by hash_map_remove_from_list_loop_fwd key ls =>
-  hash_map_remove_from_list_loop_terminates T key ls
-decreasing_by hash_map_remove_from_list_loop_decreases key ls
 
 /- [hashmap::HashMap::{0}::remove_from_list] -/
 def hash_map_remove_from_list_fwd
@@ -388,11 +349,11 @@ def hash_map_remove_from_list_fwd
   hash_map_remove_from_list_loop_fwd T key ls
 
 /- [hashmap::HashMap::{0}::remove_from_list] -/
-def hash_map_remove_from_list_loop_back
-  (T : Type) (key : Usize) (ls : list_t T) : (Result (list_t T)) :=
+divergent def hash_map_remove_from_list_loop_back
+  (T : Type) (key : Usize) (ls : list_t T) : Result (list_t T) :=
   match h: ls with
   | list_t.Cons ckey t tl =>
-    if h: ckey = key
+    if ckey = key
     then
       let mv_ls :=
         mem_replace_fwd (list_t T) (list_t.Cons ckey t tl) list_t.Nil
@@ -404,9 +365,6 @@ def hash_map_remove_from_list_loop_back
         let tl0 ← hash_map_remove_from_list_loop_back T key tl
         Result.ret (list_t.Cons ckey t tl0)
   | list_t.Nil => Result.ret list_t.Nil
-termination_by hash_map_remove_from_list_loop_back key ls =>
-  hash_map_remove_from_list_loop_terminates T key ls
-decreasing_by hash_map_remove_from_list_loop_decreases key ls
 
 /- [hashmap::HashMap::{0}::remove_from_list] -/
 def hash_map_remove_from_list_back
@@ -469,7 +427,7 @@ def test1_fwd : Result Unit :=
       hash_map_insert_fwd_back U64 hm2 (Usize.ofInt 1056 (by intlit))
         (U64.ofInt 256 (by intlit))
     let i ← hash_map_get_fwd U64 hm3 (Usize.ofInt 128 (by intlit))
-    if h: not (i = (U64.ofInt 18 (by intlit)))
+    if not (i = (U64.ofInt 18 (by intlit)))
     then Result.fail Error.panic
     else
       do
@@ -477,7 +435,7 @@ def test1_fwd : Result Unit :=
           hash_map_get_mut_back U64 hm3 (Usize.ofInt 1024 (by intlit))
             (U64.ofInt 56 (by intlit))
         let i0 ← hash_map_get_fwd U64 hm4 (Usize.ofInt 1024 (by intlit))
-        if h: not (i0 = (U64.ofInt 56 (by intlit)))
+        if not (i0 = (U64.ofInt 56 (by intlit)))
         then Result.fail Error.panic
         else
           do
@@ -486,7 +444,7 @@ def test1_fwd : Result Unit :=
             match h: x with
             | Option.none => Result.fail Error.panic
             | Option.some x0 =>
-              if h: not (x0 = (U64.ofInt 56 (by intlit)))
+              if not (x0 = (U64.ofInt 56 (by intlit)))
               then Result.fail Error.panic
               else
                 do
@@ -494,20 +452,23 @@ def test1_fwd : Result Unit :=
                     hash_map_remove_back U64 hm4 (Usize.ofInt 1024 (by intlit))
                   let i1 ←
                     hash_map_get_fwd U64 hm5 (Usize.ofInt 0 (by intlit))
-                  if h: not (i1 = (U64.ofInt 42 (by intlit)))
+                  if not (i1 = (U64.ofInt 42 (by intlit)))
                   then Result.fail Error.panic
                   else
                     do
                       let i2 ←
                         hash_map_get_fwd U64 hm5 (Usize.ofInt 128 (by intlit))
-                      if h: not (i2 = (U64.ofInt 18 (by intlit)))
+                      if not (i2 = (U64.ofInt 18 (by intlit)))
                       then Result.fail Error.panic
                       else
                         do
                           let i3 ←
                             hash_map_get_fwd U64 hm5
                               (Usize.ofInt 1056 (by intlit))
-                          if h: not (i3 = (U64.ofInt 256 (by intlit)))
+                          if not (i3 = (U64.ofInt 256 (by intlit)))
                           then Result.fail Error.panic
                           else Result.ret ()
 
+/- Unit test for [hashmap::test1] -/
+#assert (test1_fwd == .ret ())
+
diff --git a/tests/lean/hashmap/Hashmap/Types.lean b/tests/lean/Hashmap/Types.lean
index 6eabf7da..af26f363 100644
--- a/tests/lean/hashmap/Hashmap/Types.lean
+++ b/tests/lean/Hashmap/Types.lean
@@ -1,6 +1,7 @@
 -- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS
 -- [hashmap]: type definitions
-import Base.Primitives
+import Base
+open Primitives
 
 /- [hashmap::List] -/
 inductive list_t (T : Type) :=
diff --git a/tests/lean/hashmap_on_disk/HashmapMain.lean b/tests/lean/HashmapMain.lean
index 1a4e7f82..1a4e7f82 100644
--- a/tests/lean/hashmap_on_disk/HashmapMain.lean
+++ b/tests/lean/HashmapMain.lean
diff --git a/tests/lean/hashmap_on_disk/HashmapMain/Funs.lean b/tests/lean/HashmapMain/Funs.lean
index 342c3833..a59a9f26 100644
--- a/tests/lean/hashmap_on_disk/HashmapMain/Funs.lean
+++ b/tests/lean/HashmapMain/Funs.lean
@@ -1,29 +1,26 @@
 -- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS
 -- [hashmap_main]: function definitions
-import Base.Primitives
+import Base
 import HashmapMain.Types
 import HashmapMain.ExternalFuns
-import HashmapMain.Clauses.Clauses
+open Primitives
 
 /- [hashmap_main::hashmap::hash_key] -/
 def hashmap_hash_key_fwd (k : Usize) : Result Usize :=
   Result.ret k
 
 /- [hashmap_main::hashmap::HashMap::{0}::allocate_slots] -/
-def hashmap_hash_map_allocate_slots_loop_fwd
+divergent def hashmap_hash_map_allocate_slots_loop_fwd
   (T : Type) (slots : Vec (hashmap_list_t T)) (n : Usize) :
-  (Result (Vec (hashmap_list_t T)))
+  Result (Vec (hashmap_list_t T))
   :=
-  if h: n > (Usize.ofInt 0 (by intlit))
+  if n > (Usize.ofInt 0 (by intlit))
   then
     do
       let slots0 ← vec_push_back (hashmap_list_t T) slots hashmap_list_t.Nil
       let n0 ← n - (Usize.ofInt 1 (by intlit))
       hashmap_hash_map_allocate_slots_loop_fwd T slots0 n0
   else Result.ret slots
-termination_by hashmap_hash_map_allocate_slots_loop_fwd slots n =>
-  hashmap_hash_map_allocate_slots_loop_terminates T slots n
-decreasing_by hashmap_hash_map_allocate_slots_loop_decreases slots n
 
 /- [hashmap_main::hashmap::HashMap::{0}::allocate_slots] -/
 def hashmap_hash_map_allocate_slots_fwd
@@ -58,12 +55,12 @@ def hashmap_hash_map_new_fwd (T : Type) : Result (hashmap_hash_map_t T) :=
     (Usize.ofInt 4 (by intlit)) (Usize.ofInt 5 (by intlit))
 
 /- [hashmap_main::hashmap::HashMap::{0}::clear] -/
-def hashmap_hash_map_clear_loop_fwd_back
+divergent def hashmap_hash_map_clear_loop_fwd_back
   (T : Type) (slots : Vec (hashmap_list_t T)) (i : Usize) :
-  (Result (Vec (hashmap_list_t T)))
+  Result (Vec (hashmap_list_t T))
   :=
   let i0 := vec_len (hashmap_list_t T) slots
-  if h: i < i0
+  if i < i0
   then
     do
       let i1 ← i + (Usize.ofInt 1 (by intlit))
@@ -71,9 +68,6 @@ def hashmap_hash_map_clear_loop_fwd_back
         vec_index_mut_back (hashmap_list_t T) slots i hashmap_list_t.Nil
       hashmap_hash_map_clear_loop_fwd_back T slots0 i1
   else Result.ret slots
-termination_by hashmap_hash_map_clear_loop_fwd_back slots i =>
-  hashmap_hash_map_clear_loop_terminates T slots i
-decreasing_by hashmap_hash_map_clear_loop_decreases slots i
 
 /- [hashmap_main::hashmap::HashMap::{0}::clear] -/
 def hashmap_hash_map_clear_fwd_back
@@ -96,19 +90,14 @@ def hashmap_hash_map_len_fwd
   Result.ret self.hashmap_hash_map_num_entries
 
 /- [hashmap_main::hashmap::HashMap::{0}::insert_in_list] -/
-def hashmap_hash_map_insert_in_list_loop_fwd
-  (T : Type) (key : Usize) (value : T) (ls : hashmap_list_t T) :
-  (Result Bool)
-  :=
+divergent def hashmap_hash_map_insert_in_list_loop_fwd
+  (T : Type) (key : Usize) (value : T) (ls : hashmap_list_t T) : Result Bool :=
   match h: ls with
   | hashmap_list_t.Cons ckey cvalue tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret false
     else hashmap_hash_map_insert_in_list_loop_fwd T key value tl
   | hashmap_list_t.Nil => Result.ret true
-termination_by hashmap_hash_map_insert_in_list_loop_fwd key value ls =>
-  hashmap_hash_map_insert_in_list_loop_terminates T key value ls
-decreasing_by hashmap_hash_map_insert_in_list_loop_decreases key value ls
 
 /- [hashmap_main::hashmap::HashMap::{0}::insert_in_list] -/
 def hashmap_hash_map_insert_in_list_fwd
@@ -116,13 +105,13 @@ def hashmap_hash_map_insert_in_list_fwd
   hashmap_hash_map_insert_in_list_loop_fwd T key value ls
 
 /- [hashmap_main::hashmap::HashMap::{0}::insert_in_list] -/
-def hashmap_hash_map_insert_in_list_loop_back
+divergent def hashmap_hash_map_insert_in_list_loop_back
   (T : Type) (key : Usize) (value : T) (ls : hashmap_list_t T) :
-  (Result (hashmap_list_t T))
+  Result (hashmap_list_t T)
   :=
   match h: ls with
   | hashmap_list_t.Cons ckey cvalue tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret (hashmap_list_t.Cons ckey value tl)
     else
       do
@@ -131,9 +120,6 @@ def hashmap_hash_map_insert_in_list_loop_back
   | hashmap_list_t.Nil =>
     let l := hashmap_list_t.Nil
     Result.ret (hashmap_list_t.Cons key value l)
-termination_by hashmap_hash_map_insert_in_list_loop_back key value ls =>
-  hashmap_hash_map_insert_in_list_loop_terminates T key value ls
-decreasing_by hashmap_hash_map_insert_in_list_loop_decreases key value ls
 
 /- [hashmap_main::hashmap::HashMap::{0}::insert_in_list] -/
 def hashmap_hash_map_insert_in_list_back
@@ -154,7 +140,7 @@ def hashmap_hash_map_insert_no_resize_fwd_back
     let l ←
       vec_index_mut_fwd (hashmap_list_t T) self.hashmap_hash_map_slots hash_mod
     let inserted ← hashmap_hash_map_insert_in_list_fwd T key value l
-    if h: inserted
+    if inserted
     then
       do
         let i0 ← self.hashmap_hash_map_num_entries +
@@ -183,9 +169,9 @@ def core_num_u32_max_body : Result U32 :=
 def core_num_u32_max_c : U32 := eval_global core_num_u32_max_body (by simp)
 
 /- [hashmap_main::hashmap::HashMap::{0}::move_elements_from_list] -/
-def hashmap_hash_map_move_elements_from_list_loop_fwd_back
+divergent def hashmap_hash_map_move_elements_from_list_loop_fwd_back
   (T : Type) (ntable : hashmap_hash_map_t T) (ls : hashmap_list_t T) :
-  (Result (hashmap_hash_map_t T))
+  Result (hashmap_hash_map_t T)
   :=
   match h: ls with
   | hashmap_list_t.Cons k v tl =>
@@ -193,10 +179,6 @@ def hashmap_hash_map_move_elements_from_list_loop_fwd_back
       let ntable0 ← hashmap_hash_map_insert_no_resize_fwd_back T ntable k v
       hashmap_hash_map_move_elements_from_list_loop_fwd_back T ntable0 tl
   | hashmap_list_t.Nil => Result.ret ntable
-termination_by hashmap_hash_map_move_elements_from_list_loop_fwd_back ntable ls
-  =>
-  hashmap_hash_map_move_elements_from_list_loop_terminates T ntable ls
-decreasing_by hashmap_hash_map_move_elements_from_list_loop_decreases ntable ls
 
 /- [hashmap_main::hashmap::HashMap::{0}::move_elements_from_list] -/
 def hashmap_hash_map_move_elements_from_list_fwd_back
@@ -206,13 +188,13 @@ def hashmap_hash_map_move_elements_from_list_fwd_back
   hashmap_hash_map_move_elements_from_list_loop_fwd_back T ntable ls
 
 /- [hashmap_main::hashmap::HashMap::{0}::move_elements] -/
-def hashmap_hash_map_move_elements_loop_fwd_back
+divergent def hashmap_hash_map_move_elements_loop_fwd_back
   (T : Type) (ntable : hashmap_hash_map_t T) (slots : Vec (hashmap_list_t T))
   (i : Usize) :
-  (Result ((hashmap_hash_map_t T) × (Vec (hashmap_list_t T))))
+  Result ((hashmap_hash_map_t T) × (Vec (hashmap_list_t T)))
   :=
   let i0 := vec_len (hashmap_list_t T) slots
-  if h: i < i0
+  if i < i0
   then
     do
       let l ← vec_index_mut_fwd (hashmap_list_t T) slots i
@@ -224,9 +206,6 @@ def hashmap_hash_map_move_elements_loop_fwd_back
       let slots0 ← vec_index_mut_back (hashmap_list_t T) slots i l0
       hashmap_hash_map_move_elements_loop_fwd_back T ntable0 slots0 i1
   else Result.ret (ntable, slots)
-termination_by hashmap_hash_map_move_elements_loop_fwd_back ntable slots i =>
-  hashmap_hash_map_move_elements_loop_terminates T ntable slots i
-decreasing_by hashmap_hash_map_move_elements_loop_decreases ntable slots i
 
 /- [hashmap_main::hashmap::HashMap::{0}::move_elements] -/
 def hashmap_hash_map_move_elements_fwd_back
@@ -245,7 +224,7 @@ def hashmap_hash_map_try_resize_fwd_back
     let n1 ← max_usize / (Usize.ofInt 2 (by intlit))
     let (i, i0) := self.hashmap_hash_map_max_load_factor
     let i1 ← n1 / i
-    if h: capacity <= i1
+    if capacity <= i1
     then
       do
         let i2 ← capacity * (Usize.ofInt 2 (by intlit))
@@ -270,22 +249,19 @@ def hashmap_hash_map_insert_fwd_back
   do
     let self0 ← hashmap_hash_map_insert_no_resize_fwd_back T self key value
     let i ← hashmap_hash_map_len_fwd T self0
-    if h: i > self0.hashmap_hash_map_max_load
+    if i > self0.hashmap_hash_map_max_load
     then hashmap_hash_map_try_resize_fwd_back T self0
     else Result.ret self0
 
 /- [hashmap_main::hashmap::HashMap::{0}::contains_key_in_list] -/
-def hashmap_hash_map_contains_key_in_list_loop_fwd
-  (T : Type) (key : Usize) (ls : hashmap_list_t T) : (Result Bool) :=
+divergent def hashmap_hash_map_contains_key_in_list_loop_fwd
+  (T : Type) (key : Usize) (ls : hashmap_list_t T) : Result Bool :=
   match h: ls with
   | hashmap_list_t.Cons ckey t tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret true
     else hashmap_hash_map_contains_key_in_list_loop_fwd T key tl
   | hashmap_list_t.Nil => Result.ret false
-termination_by hashmap_hash_map_contains_key_in_list_loop_fwd key ls =>
-  hashmap_hash_map_contains_key_in_list_loop_terminates T key ls
-decreasing_by hashmap_hash_map_contains_key_in_list_loop_decreases key ls
 
 /- [hashmap_main::hashmap::HashMap::{0}::contains_key_in_list] -/
 def hashmap_hash_map_contains_key_in_list_fwd
@@ -304,17 +280,14 @@ def hashmap_hash_map_contains_key_fwd
     hashmap_hash_map_contains_key_in_list_fwd T key l
 
 /- [hashmap_main::hashmap::HashMap::{0}::get_in_list] -/
-def hashmap_hash_map_get_in_list_loop_fwd
-  (T : Type) (key : Usize) (ls : hashmap_list_t T) : (Result T) :=
+divergent def hashmap_hash_map_get_in_list_loop_fwd
+  (T : Type) (key : Usize) (ls : hashmap_list_t T) : Result T :=
   match h: ls with
   | hashmap_list_t.Cons ckey cvalue tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret cvalue
     else hashmap_hash_map_get_in_list_loop_fwd T key tl
   | hashmap_list_t.Nil => Result.fail Error.panic
-termination_by hashmap_hash_map_get_in_list_loop_fwd key ls =>
-  hashmap_hash_map_get_in_list_loop_terminates T key ls
-decreasing_by hashmap_hash_map_get_in_list_loop_decreases key ls
 
 /- [hashmap_main::hashmap::HashMap::{0}::get_in_list] -/
 def hashmap_hash_map_get_in_list_fwd
@@ -333,17 +306,14 @@ def hashmap_hash_map_get_fwd
     hashmap_hash_map_get_in_list_fwd T key l
 
 /- [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list] -/
-def hashmap_hash_map_get_mut_in_list_loop_fwd
-  (T : Type) (ls : hashmap_list_t T) (key : Usize) : (Result T) :=
+divergent def hashmap_hash_map_get_mut_in_list_loop_fwd
+  (T : Type) (ls : hashmap_list_t T) (key : Usize) : Result T :=
   match h: ls with
   | hashmap_list_t.Cons ckey cvalue tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret cvalue
     else hashmap_hash_map_get_mut_in_list_loop_fwd T tl key
   | hashmap_list_t.Nil => Result.fail Error.panic
-termination_by hashmap_hash_map_get_mut_in_list_loop_fwd ls key =>
-  hashmap_hash_map_get_mut_in_list_loop_terminates T ls key
-decreasing_by hashmap_hash_map_get_mut_in_list_loop_decreases ls key
 
 /- [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list] -/
 def hashmap_hash_map_get_mut_in_list_fwd
@@ -351,22 +321,19 @@ def hashmap_hash_map_get_mut_in_list_fwd
   hashmap_hash_map_get_mut_in_list_loop_fwd T ls key
 
 /- [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list] -/
-def hashmap_hash_map_get_mut_in_list_loop_back
+divergent def hashmap_hash_map_get_mut_in_list_loop_back
   (T : Type) (ls : hashmap_list_t T) (key : Usize) (ret0 : T) :
-  (Result (hashmap_list_t T))
+  Result (hashmap_list_t T)
   :=
   match h: ls with
   | hashmap_list_t.Cons ckey cvalue tl =>
-    if h: ckey = key
+    if ckey = key
     then Result.ret (hashmap_list_t.Cons ckey ret0 tl)
     else
       do
         let tl0 ← hashmap_hash_map_get_mut_in_list_loop_back T tl key ret0
         Result.ret (hashmap_list_t.Cons ckey cvalue tl0)
   | hashmap_list_t.Nil => Result.fail Error.panic
-termination_by hashmap_hash_map_get_mut_in_list_loop_back ls key ret0 =>
-  hashmap_hash_map_get_mut_in_list_loop_terminates T ls key
-decreasing_by hashmap_hash_map_get_mut_in_list_loop_decreases ls key
 
 /- [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list] -/
 def hashmap_hash_map_get_mut_in_list_back
@@ -404,11 +371,11 @@ def hashmap_hash_map_get_mut_back
     Result.ret { self with hashmap_hash_map_slots := v }
 
 /- [hashmap_main::hashmap::HashMap::{0}::remove_from_list] -/
-def hashmap_hash_map_remove_from_list_loop_fwd
-  (T : Type) (key : Usize) (ls : hashmap_list_t T) : (Result (Option T)) :=
+divergent def hashmap_hash_map_remove_from_list_loop_fwd
+  (T : Type) (key : Usize) (ls : hashmap_list_t T) : Result (Option T) :=
   match h: ls with
   | hashmap_list_t.Cons ckey t tl =>
-    if h: ckey = key
+    if ckey = key
     then
       let mv_ls :=
         mem_replace_fwd (hashmap_list_t T) (hashmap_list_t.Cons ckey t tl)
@@ -418,9 +385,6 @@ def hashmap_hash_map_remove_from_list_loop_fwd
       | hashmap_list_t.Nil => Result.fail Error.panic
     else hashmap_hash_map_remove_from_list_loop_fwd T key tl
   | hashmap_list_t.Nil => Result.ret Option.none
-termination_by hashmap_hash_map_remove_from_list_loop_fwd key ls =>
-  hashmap_hash_map_remove_from_list_loop_terminates T key ls
-decreasing_by hashmap_hash_map_remove_from_list_loop_decreases key ls
 
 /- [hashmap_main::hashmap::HashMap::{0}::remove_from_list] -/
 def hashmap_hash_map_remove_from_list_fwd
@@ -428,13 +392,13 @@ def hashmap_hash_map_remove_from_list_fwd
   hashmap_hash_map_remove_from_list_loop_fwd T key ls
 
 /- [hashmap_main::hashmap::HashMap::{0}::remove_from_list] -/
-def hashmap_hash_map_remove_from_list_loop_back
+divergent def hashmap_hash_map_remove_from_list_loop_back
   (T : Type) (key : Usize) (ls : hashmap_list_t T) :
-  (Result (hashmap_list_t T))
+  Result (hashmap_list_t T)
   :=
   match h: ls with
   | hashmap_list_t.Cons ckey t tl =>
-    if h: ckey = key
+    if ckey = key
     then
       let mv_ls :=
         mem_replace_fwd (hashmap_list_t T) (hashmap_list_t.Cons ckey t tl)
@@ -447,9 +411,6 @@ def hashmap_hash_map_remove_from_list_loop_back
         let tl0 ← hashmap_hash_map_remove_from_list_loop_back T key tl
         Result.ret (hashmap_list_t.Cons ckey t tl0)
   | hashmap_list_t.Nil => Result.ret hashmap_list_t.Nil
-termination_by hashmap_hash_map_remove_from_list_loop_back key ls =>
-  hashmap_hash_map_remove_from_list_loop_terminates T key ls
-decreasing_by hashmap_hash_map_remove_from_list_loop_decreases key ls
 
 /- [hashmap_main::hashmap::HashMap::{0}::remove_from_list] -/
 def hashmap_hash_map_remove_from_list_back
@@ -528,7 +489,7 @@ def hashmap_test1_fwd : Result Unit :=
       hashmap_hash_map_insert_fwd_back U64 hm2 (Usize.ofInt 1056 (by intlit))
         (U64.ofInt 256 (by intlit))
     let i ← hashmap_hash_map_get_fwd U64 hm3 (Usize.ofInt 128 (by intlit))
-    if h: not (i = (U64.ofInt 18 (by intlit)))
+    if not (i = (U64.ofInt 18 (by intlit)))
     then Result.fail Error.panic
     else
       do
@@ -537,7 +498,7 @@ def hashmap_test1_fwd : Result Unit :=
             (U64.ofInt 56 (by intlit))
         let i0 ←
           hashmap_hash_map_get_fwd U64 hm4 (Usize.ofInt 1024 (by intlit))
-        if h: not (i0 = (U64.ofInt 56 (by intlit)))
+        if not (i0 = (U64.ofInt 56 (by intlit)))
         then Result.fail Error.panic
         else
           do
@@ -547,7 +508,7 @@ def hashmap_test1_fwd : Result Unit :=
             match h: x with
             | Option.none => Result.fail Error.panic
             | Option.some x0 =>
-              if h: not (x0 = (U64.ofInt 56 (by intlit)))
+              if not (x0 = (U64.ofInt 56 (by intlit)))
               then Result.fail Error.panic
               else
                 do
@@ -557,24 +518,27 @@ def hashmap_test1_fwd : Result Unit :=
                   let i1 ←
                     hashmap_hash_map_get_fwd U64 hm5
                       (Usize.ofInt 0 (by intlit))
-                  if h: not (i1 = (U64.ofInt 42 (by intlit)))
+                  if not (i1 = (U64.ofInt 42 (by intlit)))
                   then Result.fail Error.panic
                   else
                     do
                       let i2 ←
                         hashmap_hash_map_get_fwd U64 hm5
                           (Usize.ofInt 128 (by intlit))
-                      if h: not (i2 = (U64.ofInt 18 (by intlit)))
+                      if not (i2 = (U64.ofInt 18 (by intlit)))
                       then Result.fail Error.panic
                       else
                         do
                           let i3 ←
                             hashmap_hash_map_get_fwd U64 hm5
                               (Usize.ofInt 1056 (by intlit))
-                          if h: not (i3 = (U64.ofInt 256 (by intlit)))
+                          if not (i3 = (U64.ofInt 256 (by intlit)))
                           then Result.fail Error.panic
                           else Result.ret ()
 
+/- Unit test for [hashmap_main::hashmap::test1] -/
+#assert (hashmap_test1_fwd == .ret ())
+
 /- [hashmap_main::insert_on_disk] -/
 def insert_on_disk_fwd
   (key : Usize) (value : U64) (st : State) : Result (State × Unit) :=
@@ -588,3 +552,6 @@ def insert_on_disk_fwd
 def main_fwd : Result Unit :=
   Result.ret ()
 
+/- Unit test for [hashmap_main::main] -/
+#assert (main_fwd == .ret ())
+
diff --git a/tests/lean/hashmap_on_disk/HashmapMain/Opaque.lean b/tests/lean/HashmapMain/Opaque.lean
index d98f431a..bef4f3fb 100644
--- a/tests/lean/hashmap_on_disk/HashmapMain/Opaque.lean
+++ b/tests/lean/HashmapMain/Opaque.lean
@@ -1,7 +1,8 @@
 -- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS
 -- [hashmap_main]: opaque function definitions
-import Base.Primitives
+import Base
 import HashmapMain.Types
+open Primitives
 
 structure OpaqueDefs where
   
diff --git a/tests/lean/hashmap_on_disk/HashmapMain/Types.lean b/tests/lean/HashmapMain/Types.lean
index 0509fbbd..858e1c51 100644
--- a/tests/lean/hashmap_on_disk/HashmapMain/Types.lean
+++ b/tests/lean/HashmapMain/Types.lean
@@ -1,6 +1,7 @@
 -- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS
 -- [hashmap_main]: type definitions
-import Base.Primitives
+import Base
+open Primitives
 
 /- [hashmap_main::hashmap::List] -/
 inductive hashmap_list_t (T : Type) :=