From 74f6100b9e55ae491e430310eda10317a1484ba3 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Fri, 16 Jan 2026 12:21:30 +1000
Subject: [PATCH 01/36] First pass lattice

---
 lib/analysis/dune                  |   2 +-
 lib/analysis/wrapping_intervals.ml | 138 +++++++++++++++++++++++++++++
 test/lang/value_soundness.ml       |   7 +-
 3 files changed, 145 insertions(+), 2 deletions(-)
 create mode 100644 lib/analysis/wrapping_intervals.ml

diff --git a/lib/analysis/dune b/lib/analysis/dune
index 8ed1119..58f5660 100644
--- a/lib/analysis/dune
+++ b/lib/analysis/dune
@@ -2,7 +2,7 @@
  (public_name bincaml.analysis)
  (name analysis)
  (flags -w -27)
- (modules dataflow_graph intra_analysis defuse_bool lattice_types)
+ (modules dataflow_graph intra_analysis defuse_bool wrapping_intervals lattice_types)
  (libraries
   patricia-tree
   loader
diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
new file mode 100644
index 0000000..0696971
--- /dev/null
+++ b/lib/analysis/wrapping_intervals.ml
@@ -0,0 +1,138 @@
+open Bincaml_util.Common
+
+module WrappingIntervalsLattice = struct
+  let name = "wrappingIntervals"
+
+  type t = Top | Interval of { lower : Bitvec.t; upper : Bitvec.t } | Bot
+  [@@deriving eq, show { with_path = false }]
+
+  let interval lower upper =
+    Bitvec.size_is_equal lower upper;
+    Interval { lower; upper }
+
+  let bottom = Bot
+  let pretty t = Containers_pp.text (show t)
+
+  (*  TODO: Rewrite as compare_size to avoid storing widths for Top and Bot *)
+  let cardinality t =
+    match t with
+    | Bot -> Z.of_int 0
+    | Top -> Z.pow (Z.of_int 2) 64
+    | Interval { lower; upper } ->
+        Bitvec.(
+          sub upper lower
+          |> add (of_int ~size:(size lower) 1)
+          |> to_unsigned_bigint)
+
+  let complement t =
+    match t with
+    | Bot -> Top
+    | Top -> Bot
+    | Interval { lower; upper } ->
+        let new_lower = Bitvec.(add upper (of_int ~size:(size upper) 1)) in
+        let new_upper = Bitvec.(sub lower (of_int ~size:(size lower) 1)) in
+        interval new_lower new_upper
+
+  let member t e =
+    match t with
+    | Bot -> false
+    | Top -> true
+    | Interval { lower; upper } -> Bitvec.(ule (sub e lower) (sub upper lower))
+
+  let compare a b =
+    match (a, b) with
+    | a, b when equal a b -> 0
+    | Top, _ -> 1
+    | Bot, _ -> -1
+    | _, Top -> -1
+    | _, Bot -> 1
+    | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
+      ->
+        if
+          member b al && member b au
+          && ((not (member a bl)) || not (member a bu))
+        then -1
+        else 1
+
+  let join a b =
+    if compare a b <= 0 then b
+    else if compare a b >= 0 then a
+    else
+      match (a, b) with
+      | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
+        ->
+          let al_mem = member b al in
+          let au_mem = member b au in
+          let bl_mem = member a bl in
+          let bu_mem = member a bu in
+          if al_mem && au_mem && bl_mem && bu_mem then Top
+          else if au_mem && bl_mem then interval al bu
+          else if al_mem && bu_mem then interval bl au
+          else
+            let inner_span = cardinality (interval au bl) in
+            let outer_span = cardinality (interval bu al) in
+            if
+              Z.lt inner_span outer_span
+              || (Z.equal inner_span outer_span && Bitvec.ule al bl)
+            then interval al bu
+            else interval bl au
+      | _, _ -> failwith "unreachable"
+
+  (* TODO: Implement join for multiple intervals (see APLAS12 Fig. 3) *)
+
+  let widening a b =
+    match (a, b) with
+    | a, Bot -> a
+    | Bot, b -> b
+    | a, Top -> a
+    | Top, b -> b
+    | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
+      ->
+        Bitvec.size_is_equal al bl;
+        Bitvec.size_is_equal au bu;
+        let width = Bitvec.size al in
+        if compare b a <= 0 then a
+        else if Z.geq (cardinality a) (Z.pow (Z.of_int 2) 64) then Top
+        else
+          let joined = join a b in
+          if equal joined (interval al bu) then
+            join joined
+              (interval al
+                 Bitvec.(
+                   sub (mul au (of_int ~size:width 2)) al
+                   |> add (of_int ~size:width 1)))
+          else if equal joined (interval bl au) then
+            join joined
+              (interval
+                 Bitvec.(
+                   sub
+                     (sub (mul al (of_int ~size:width 2)) au)
+                     (of_int ~size:width 1))
+                 au)
+          else if member b al && member b au then
+            join b
+              (interval bl
+                 Bitvec.(
+                   sub
+                     (bl
+                     |> add (mul au (of_int ~size:width 2))
+                     |> add (of_int ~size:width 1))
+                     (mul al (of_int ~size:width 2))))
+          else Top
+end
+
+module WrappingIntervalsValueAbstraction = struct
+  include WrappingIntervalsLattice
+
+  let eval_const op = Top
+  let eval_unop op a = Top
+  let eval_binop op a b = Top
+  let eval_intrin op args = Top
+end
+
+module StateAbstraction = Intra_analysis.MapState (WrappingIntervalsLattice)
+
+module WrappingIntervalsValueAbstractionBasil = struct
+  include WrappingIntervalsValueAbstraction
+  module E = Lang.Expr.BasilExpr
+end
diff --git a/test/lang/value_soundness.ml b/test/lang/value_soundness.ml
index 12d1159..d91e111 100644
--- a/test/lang/value_soundness.ml
+++ b/test/lang/value_soundness.ml
@@ -55,5 +55,10 @@ end
 module TestBoolDom =
   ValueAbstractionSoundness (Analysis.Defuse_bool.IsZeroValueAbstractionBasil)
 
+module TestWrappingIntervalDom =
+  ValueAbstractionSoundness
+    (Analysis.Wrapping_intervals.WrappingIntervalsValueAbstractionBasil)
+
 let _ =
-  Alcotest.run "value domain abstract eval soundness" [ TestBoolDom.suite ]
+  Alcotest.run "value domain abstract eval soundness"
+    [ TestBoolDom.suite; TestWrappingIntervalDom.suite ]

From f7f2e99f6ad27f6331edc5b02f2ad751d127ac82 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Fri, 16 Jan 2026 14:42:06 +1000
Subject: [PATCH 02/36] Least upper bound for more than 2

---
 lib/analysis/wrapping_intervals.ml | 46 +++++++++++++++++++++++++++++-
 1 file changed, 45 insertions(+), 1 deletion(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 0696971..1f54da8 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -24,6 +24,15 @@ module WrappingIntervalsLattice = struct
           |> add (of_int ~size:(size lower) 1)
           |> to_unsigned_bigint)
 
+  let compare_size a b =
+    match (a, b) with
+    | a, b when equal a b -> 0
+    | Top, _ -> 1
+    | Bot, _ -> -1
+    | _, Top -> -1
+    | _, Bot -> 1
+    | Interval _, Interval _ -> Z.compare (cardinality a) (cardinality b)
+
   let complement t =
     match t with
     | Bot -> Top
@@ -78,7 +87,42 @@ module WrappingIntervalsLattice = struct
             else interval bl au
       | _, _ -> failwith "unreachable"
 
-  (* TODO: Implement join for multiple intervals (see APLAS12 Fig. 3) *)
+  (* Join for multiple intervals to increase precision (join is not monotone) *)
+  let lub (ints : t list) =
+    let bigger a b = if compare_size a b < 0 then b else a in
+    let gap a b =
+      match (a, b) with
+      | Interval { upper = au; _ }, Interval { lower = bl; _ }
+        when (not (member b au)) && not (member a bl) ->
+          complement (interval bl au)
+      | _, _ -> Bot
+    in
+    (* APLAS12 mentions "last cases are omitted", does not specify which cases. *)
+    let extend a b = join a b in
+    let sorted =
+      List.sort
+        (fun a b ->
+          match (a, b) with
+          | Interval { lower = al; _ }, Interval { lower = bl; _ } ->
+              Bitvec.compare al bl
+          | _, _ -> compare a b)
+        ints
+    in
+    let f1 =
+      List.fold_right
+        (fun t acc ->
+          match t with
+          | Interval { lower; upper } when Bitvec.ule upper lower ->
+              extend acc t
+          | _ -> acc)
+        sorted Bot
+    in
+    let g, f =
+      List.fold_right
+        (fun t (g, f) -> (bigger g (gap f t), extend f t))
+        sorted (Bot, f1)
+    in
+    complement (bigger g (complement f))
 
   let widening a b =
     match (a, b) with

From ba782dc96e678aa2b43338d29c14ac39193fc7fe Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Fri, 16 Jan 2026 15:27:36 +1000
Subject: [PATCH 03/36] Intersect, splits and cut

---
 lib/analysis/wrapping_intervals.ml | 62 +++++++++++++++++++++++++++++-
 1 file changed, 61 insertions(+), 1 deletion(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 1f54da8..ad464bf 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -3,6 +3,7 @@ open Bincaml_util.Common
 module WrappingIntervalsLattice = struct
   let name = "wrappingIntervals"
 
+  (* TODO: Store widths for all variants :( *)
   type t = Top | Interval of { lower : Bitvec.t; upper : Bitvec.t } | Bot
   [@@deriving eq, show { with_path = false }]
 
@@ -10,10 +11,15 @@ module WrappingIntervalsLattice = struct
     Bitvec.size_is_equal lower upper;
     Interval { lower; upper }
 
+  let umin width = Bitvec.zero ~size:width
+  let umax width = Bitvec.ones ~size:width
+  let smin width = Bitvec.(concat (ones ~size:1) (zero ~size:(width - 1)))
+  let smax width = Bitvec.(zero_extend ~extension:1 (ones ~size:(width - 1)))
+  let sp width = interval (umax width) (umin width)
+  let np width = interval (smax width) (smin width)
   let bottom = Bot
   let pretty t = Containers_pp.text (show t)
 
-  (*  TODO: Rewrite as compare_size to avoid storing widths for Top and Bot *)
   let cardinality t =
     match t with
     | Bot -> Z.of_int 0
@@ -163,6 +169,60 @@ module WrappingIntervalsLattice = struct
                      |> add (of_int ~size:width 1))
                      (mul al (of_int ~size:width 2))))
           else Top
+
+  let intersect a b =
+    match (a, b) with
+    | Bot, Bot -> []
+    | a, b when equal a b -> [ b ]
+    | Top, _ -> [ b ]
+    | _, Top -> [ a ]
+    | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
+      ->
+        let al_mem = member b al in
+        let au_mem = member b au in
+        let bl_mem = member a bl in
+        let bu_mem = member a bu in
+        let a_in_b = al_mem && au_mem in
+        let b_in_a = bl_mem && bu_mem in
+        if a_in_b && b_in_a then [ interval al bu; interval au bl ]
+        else if a_in_b then [ a ]
+        else if b_in_a then [ b ]
+        else if al_mem && (not au_mem) && (not bl_mem) && bu_mem then
+          [ interval al bu ]
+        else if (not al_mem) && au_mem && bl_mem && not bu_mem then
+          [ interval au bl ]
+        else []
+    | _, _ -> []
+
+  let nsplit t =
+    match t with
+    | Bot -> []
+    | Top ->
+        [
+          interval (umin width) (smax width); interval (smin width) (umax width);
+        ]
+    | Interval { lower; upper } ->
+        let width = Bitvec.size lower in
+        let np = np width in
+        if compare np t <= 0 then
+          [ interval lower (smax width); interval (smin width) upper ]
+        else [ t ]
+
+  let ssplit t =
+    match t with
+    | Bot -> []
+    | Top ->
+        [
+          interval (umin width) (smax width); interval (smin width) (umax width);
+        ]
+    | Interval { lower; upper } ->
+        let width = Bitvec.size lower in
+        let sp = sp width in
+        if compare sp t <= 0 then
+          [ interval lower (umax width); interval (umin width) upper ]
+        else [ t ]
+
+  let cut t = List.concat_map ssplit (nsplit t)
 end
 
 module WrappingIntervalsValueAbstraction = struct

From 2ec8471ee16cb1bd0a5fb898da86ef94450942a1 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Mon, 19 Jan 2026 15:08:26 +1000
Subject: [PATCH 04/36] Add widths and tests

---
 lib/analysis/wrapping_intervals.ml  | 167 +++++++++++++++++-----------
 test/analysis/wrapping_intervals.ml |  86 ++++++++++++++
 2 files changed, 186 insertions(+), 67 deletions(-)
 create mode 100644 test/analysis/wrapping_intervals.ml

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index ad464bf..5befe72 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -3,13 +3,25 @@ open Bincaml_util.Common
 module WrappingIntervalsLattice = struct
   let name = "wrappingIntervals"
 
-  (* TODO: Store widths for all variants :( *)
-  type t = Top | Interval of { lower : Bitvec.t; upper : Bitvec.t } | Bot
+  type l = Top | Interval of { lower : Bitvec.t; upper : Bitvec.t } | Bot
   [@@deriving eq, show { with_path = false }]
 
+  type t = { w : int option; v : l } [@@deriving show { with_path = false }]
+
+  let equal s t = equal_l s.v t.v
+
   let interval lower upper =
     Bitvec.size_is_equal lower upper;
-    Interval { lower; upper }
+    { w = Some (Bitvec.size lower); v = Interval { lower; upper } }
+
+  let infer { w = w1; v = a } { w = w2; v = b } =
+    match (w1, w2) with
+    | Some w1, Some w2 ->
+        assert (w1 = w2);
+        ({ w = Some w1; v = a }, { w = Some w2; v = b })
+    | Some w1, None -> ({ w = Some w1; v = a }, { w = Some w1; v = b })
+    | None, Some w2 -> ({ w = Some w2; v = a }, { w = Some w2; v = b })
+    | None, None -> ({ w = None; v = a }, { w = None; v = b })
 
   let umin width = Bitvec.zero ~size:width
   let umax width = Bitvec.ones ~size:width
@@ -17,32 +29,35 @@ module WrappingIntervalsLattice = struct
   let smax width = Bitvec.(zero_extend ~extension:1 (ones ~size:(width - 1)))
   let sp width = interval (umax width) (umin width)
   let np width = interval (smax width) (smin width)
-  let bottom = Bot
+  let top = { w = None; v = Top }
+  let bottom = { w = None; v = Bot }
   let pretty t = Containers_pp.text (show t)
 
-  let cardinality t =
-    match t with
+  let cardinality { w; v } =
+    match v with
     | Bot -> Z.of_int 0
-    | Top -> Z.pow (Z.of_int 2) 64
+    | Top -> (
+        match w with
+        | Some w -> Z.pow (Z.of_int 2) w
+        | None -> failwith "Cannot determine cardinality for Top without width")
     | Interval { lower; upper } ->
-        Bitvec.(
-          sub upper lower
-          |> add (of_int ~size:(size lower) 1)
-          |> to_unsigned_bigint)
+        Bitvec.(sub upper lower |> to_unsigned_bigint |> Z.add (Z.of_int 1))
 
-  let compare_size a b =
+  let compare_size s t =
+    let { v = a; _ } = s in
+    let { v = b; _ } = t in
     match (a, b) with
-    | a, b when equal a b -> 0
+    | a, b when equal_l a b -> 0
     | Top, _ -> 1
     | Bot, _ -> -1
     | _, Top -> -1
     | _, Bot -> 1
-    | Interval _, Interval _ -> Z.compare (cardinality a) (cardinality b)
+    | Interval _, Interval _ -> Z.compare (cardinality s) (cardinality t)
 
-  let complement t =
-    match t with
-    | Bot -> Top
-    | Top -> Bot
+  let complement { w; v } =
+    match v with
+    | Bot -> { w; v = Top }
+    | Top -> { w; v = Bot }
     | Interval { lower; upper } ->
         let new_lower = Bitvec.(add upper (of_int ~size:(size upper) 1)) in
         let new_upper = Bitvec.(sub lower (of_int ~size:(size lower) 1)) in
@@ -54,9 +69,9 @@ module WrappingIntervalsLattice = struct
     | Top -> true
     | Interval { lower; upper } -> Bitvec.(ule (sub e lower) (sub upper lower))
 
-  let compare a b =
+  let compare_l a b =
     match (a, b) with
-    | a, b when equal a b -> 0
+    | a, b when equal_l a b -> 0
     | Top, _ -> 1
     | Bot, _ -> -1
     | _, Top -> -1
@@ -69,9 +84,14 @@ module WrappingIntervalsLattice = struct
         then -1
         else 1
 
-  let join a b =
-    if compare a b <= 0 then b
-    else if compare a b >= 0 then a
+  let compare s t = compare_l s.v t.v
+
+  let join s t =
+    let s, t = infer s t in
+    let { v = a; _ } = s in
+    let { v = b; _ } = t in
+    if compare s t <= 0 then t
+    else if compare t s <= 0 then s
     else
       match (a, b) with
       | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
@@ -80,7 +100,8 @@ module WrappingIntervalsLattice = struct
           let au_mem = member b au in
           let bl_mem = member a bl in
           let bu_mem = member a bu in
-          if al_mem && au_mem && bl_mem && bu_mem then Top
+          if al_mem && au_mem && bl_mem && bu_mem then
+            { w = Some (Bitvec.size al); v = Top }
           else if au_mem && bl_mem then interval al bu
           else if al_mem && bu_mem then interval bl au
           else
@@ -97,54 +118,58 @@ module WrappingIntervalsLattice = struct
   let lub (ints : t list) =
     let bigger a b = if compare_size a b < 0 then b else a in
     let gap a b =
-      match (a, b) with
+      match (a.v, b.v) with
       | Interval { upper = au; _ }, Interval { lower = bl; _ }
-        when (not (member b au)) && not (member a bl) ->
+        when (not (member b.v au)) && not (member a.v bl) ->
           complement (interval bl au)
-      | _, _ -> Bot
+      | _, _ -> bottom
     in
     (* APLAS12 mentions "last cases are omitted", does not specify which cases. *)
     let extend a b = join a b in
     let sorted =
       List.sort
-        (fun a b ->
-          match (a, b) with
+        (fun s t ->
+          match (s.v, t.v) with
           | Interval { lower = al; _ }, Interval { lower = bl; _ } ->
               Bitvec.compare al bl
-          | _, _ -> compare a b)
+          | _, _ -> compare_l s.v t.v)
         ints
     in
     let f1 =
-      List.fold_right
-        (fun t acc ->
-          match t with
+      List.fold_left
+        (fun acc t ->
+          match t.v with
           | Interval { lower; upper } when Bitvec.ule upper lower ->
               extend acc t
           | _ -> acc)
-        sorted Bot
+        bottom sorted
     in
     let g, f =
-      List.fold_right
-        (fun t (g, f) -> (bigger g (gap f t), extend f t))
-        sorted (Bot, f1)
+      List.fold_left
+        (fun (g, f) t -> (bigger g (gap f t), extend f t))
+        (bottom, f1) sorted
     in
     complement (bigger g (complement f))
 
-  let widening a b =
+  let widening s t =
+    let s, t = infer s t in
+    let { v = a; _ } = s in
+    let { v = b; _ } = t in
     match (a, b) with
-    | a, Bot -> a
-    | Bot, b -> b
-    | a, Top -> a
-    | Top, b -> b
+    | _, Bot -> s
+    | Bot, _ -> t
+    | _, Top -> s
+    | Top, _ -> t
     | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
       ->
         Bitvec.size_is_equal al bl;
         Bitvec.size_is_equal au bu;
         let width = Bitvec.size al in
-        if compare b a <= 0 then a
-        else if Z.geq (cardinality a) (Z.pow (Z.of_int 2) 64) then Top
+        if compare t s <= 0 then s
+        else if Z.geq (cardinality s) (Z.pow (Z.of_int 2) width) then
+          { w = Some width; v = Top }
         else
-          let joined = join a b in
+          let joined = join s t in
           if equal joined (interval al bu) then
             join joined
               (interval al
@@ -160,7 +185,7 @@ module WrappingIntervalsLattice = struct
                      (of_int ~size:width 1))
                  au)
           else if member b al && member b au then
-            join b
+            join t
               (interval bl
                  Bitvec.(
                    sub
@@ -168,14 +193,19 @@ module WrappingIntervalsLattice = struct
                      |> add (mul au (of_int ~size:width 2))
                      |> add (of_int ~size:width 1))
                      (mul al (of_int ~size:width 2))))
-          else Top
+          else { w = Some width; v = Top }
 
-  let intersect a b =
+  let intersect s t =
+    let s, t = infer s t in
+    let { v = a; _ } = s in
+    let { v = b; _ } = t in
     match (a, b) with
     | Bot, Bot -> []
-    | a, b when equal a b -> [ b ]
-    | Top, _ -> [ b ]
-    | _, Top -> [ a ]
+    | Top, Bot -> []
+    | Bot, Top -> []
+    | Top, _ -> [ t ]
+    | _, Top -> [ s ]
+    | a, b when equal_l a b -> [ t ]
     | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
       ->
         let al_mem = member b al in
@@ -185,8 +215,8 @@ module WrappingIntervalsLattice = struct
         let a_in_b = al_mem && au_mem in
         let b_in_a = bl_mem && bu_mem in
         if a_in_b && b_in_a then [ interval al bu; interval au bl ]
-        else if a_in_b then [ a ]
-        else if b_in_a then [ b ]
+        else if a_in_b then [ s ]
+        else if b_in_a then [ t ]
         else if al_mem && (not au_mem) && (not bl_mem) && bu_mem then
           [ interval al bu ]
         else if (not al_mem) && au_mem && bl_mem && not bu_mem then
@@ -195,12 +225,12 @@ module WrappingIntervalsLattice = struct
     | _, _ -> []
 
   let nsplit t =
-    match t with
+    match t.v with
     | Bot -> []
-    | Top ->
-        [
-          interval (umin width) (smax width); interval (smin width) (umax width);
-        ]
+    | Top -> (
+        match t.w with
+        | Some w -> [ interval (umin w) (smax w); interval (smin w) (umax w) ]
+        | None -> failwith "Cannot determine nsplit for Top without width")
     | Interval { lower; upper } ->
         let width = Bitvec.size lower in
         let np = np width in
@@ -209,12 +239,12 @@ module WrappingIntervalsLattice = struct
         else [ t ]
 
   let ssplit t =
-    match t with
+    match t.v with
     | Bot -> []
-    | Top ->
-        [
-          interval (umin width) (smax width); interval (smin width) (umax width);
-        ]
+    | Top -> (
+        match t.w with
+        | Some w -> [ interval (umin w) (smax w); interval (smin w) (umax w) ]
+        | None -> failwith "Cannot determine nsplit for Top without width")
     | Interval { lower; upper } ->
         let width = Bitvec.size lower in
         let sp = sp width in
@@ -228,10 +258,10 @@ end
 module WrappingIntervalsValueAbstraction = struct
   include WrappingIntervalsLattice
 
-  let eval_const op = Top
-  let eval_unop op a = Top
-  let eval_binop op a b = Top
-  let eval_intrin op args = Top
+  let eval_const op = top
+  let eval_unop op a = top
+  let eval_binop op a b = top
+  let eval_intrin op args = top
 end
 
 module StateAbstraction = Intra_analysis.MapState (WrappingIntervalsLattice)
@@ -240,3 +270,6 @@ module WrappingIntervalsValueAbstractionBasil = struct
   include WrappingIntervalsValueAbstraction
   module E = Lang.Expr.BasilExpr
 end
+
+include
+  Dataflow_graph.EasyForwardAnalysisPack (WrappingIntervalsValueAbstractionBasil)
diff --git a/test/analysis/wrapping_intervals.ml b/test/analysis/wrapping_intervals.ml
new file mode 100644
index 0000000..8c1f01b
--- /dev/null
+++ b/test/analysis/wrapping_intervals.ml
@@ -0,0 +1,86 @@
+open Bincaml_util.Common
+open Analysis.Wrapping_intervals.WrappingIntervalsLattice
+
+let dbg x =
+  print_endline (show x);
+  x
+
+let%test_unit "cardinality" =
+  let ( = ) a b = Z.equal a (Z.of_int b) in
+  let iv a b = interval (Bitvec.of_int ~size:4 a) (Bitvec.of_int ~size:4 b) in
+  assert (cardinality bottom = 0);
+  assert (cardinality { w = Some 4; v = Top } = 16);
+  assert (cardinality (iv 0 15) = 16);
+  assert (cardinality (iv 3 12) = 10);
+  assert (cardinality (iv 15 0) = 2);
+  assert (cardinality (iv 13 13) = 1)
+
+let%test_unit "member" =
+  let iv a b =
+    Interval
+      { lower = Bitvec.of_int ~size:4 a; upper = Bitvec.of_int ~size:4 b }
+  in
+  let member t e = member t (Bitvec.of_int ~size:4 e) in
+  assert (member Top 0);
+  assert (not (member Bot 0));
+  assert (member (iv 2 6) 4);
+  assert (member (iv 2 6) 6);
+  assert (member (iv 2 6) 2);
+  assert (not (member (iv 2 6) 7));
+  assert (not (member (iv 6 2) 4));
+  assert (member (iv 6 2) 6);
+  assert (member (iv 6 2) 2);
+  assert (member (iv 6 2) 7)
+
+let%test_unit "partial_order" =
+  let ( <= ) a b = compare a b <= 0 in
+  let ( > ) a b = compare a b > 0 in
+  let iv a b = interval (Bitvec.of_int ~size:4 a) (Bitvec.of_int ~size:4 b) in
+  assert (top <= top);
+  assert (bottom <= top);
+  assert (bottom <= bottom);
+  (* Fig 2.a *)
+  assert (iv 0 8 <= iv 0 9);
+  assert (iv 3 5 <= iv 0 8);
+  (* Fig 2.b *)
+  assert (iv 0 9 > iv 8 1);
+  assert (iv 8 1 > iv 0 9);
+  (* Fig 2.c *)
+  assert (iv 0 9 > iv 4 10);
+  assert (iv 4 10 > iv 0 9);
+  (* Fig 2.d *)
+  assert (iv 0 4 > iv 5 6);
+  assert (iv 5 6 > iv 0 4)
+
+let%test_unit "join" =
+  let ( = ) = equal in
+  let iv a b = interval (Bitvec.of_int ~size:4 a) (Bitvec.of_int ~size:4 b) in
+  assert (join bottom top = top);
+  assert (join (iv 1 4) bottom = iv 1 4);
+  (* Fig 2.a *)
+  assert (join (iv 1 4) (iv 0 5) = iv 0 5);
+  (* Fig 2.b *)
+  assert (join (iv 0 9) (iv 8 1) = top);
+  assert (join (iv 6 5) (iv 3 0) = top);
+  (* Fig 2.c *)
+  assert (join (iv 0 9) (iv 4 10) = iv 0 10);
+  (* Fig 2.d *)
+  assert (join (iv 0 4) (iv 5 6) = iv 0 6)
+
+let%test_unit "lub" =
+  let ( = ) = equal in
+  let iv a b = interval (Bitvec.of_int ~size:4 a) (Bitvec.of_int ~size:4 b) in
+  assert (lub [ bottom; top; bottom ] = top);
+  assert (lub [ bottom; iv 0 9; top ] = top);
+  assert (lub [ iv 0 3; iv 3 5; iv 4 6 ] = iv 0 6);
+  assert (lub [ iv 0 3; iv 6 10; iv 14 15 ] = iv 14 10)
+
+let%test_unit "intersect" =
+  let ( = ) = List.equal equal in
+  let iv a b = interval (Bitvec.of_int ~size:4 a) (Bitvec.of_int ~size:4 b) in
+  assert (List.is_empty (intersect bottom bottom));
+  assert (List.is_empty (intersect top bottom));
+  assert (intersect top (iv 1 2) = [ iv 1 2 ]);
+  assert (intersect (iv 0 4) (iv 2 1) = [ iv 0 1; iv 4 2 ]);
+  assert (intersect (iv 0 8) (iv 3 6) = [ iv 3 6 ]);
+  assert (intersect (iv 3 7) (iv 6 11) = [ iv 7 6 ])

From 59835ce814b817fff727ac708a4669f51fef199a Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Tue, 20 Jan 2026 15:32:18 +1000
Subject: [PATCH 05/36] Constants, negation, not, addition and subtraction

---
 lib/analysis/wrapping_intervals.ml | 100 +++++++++++++++++++++++++----
 1 file changed, 86 insertions(+), 14 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 5befe72..60689ba 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -43,16 +43,7 @@ module WrappingIntervalsLattice = struct
     | Interval { lower; upper } ->
         Bitvec.(sub upper lower |> to_unsigned_bigint |> Z.add (Z.of_int 1))
 
-  let compare_size s t =
-    let { v = a; _ } = s in
-    let { v = b; _ } = t in
-    match (a, b) with
-    | a, b when equal_l a b -> 0
-    | Top, _ -> 1
-    | Bot, _ -> -1
-    | _, Top -> -1
-    | _, Bot -> 1
-    | Interval _, Interval _ -> Z.compare (cardinality s) (cardinality t)
+  let compare_size s t = Z.compare (cardinality s) (cardinality t)
 
   let complement { w; v } =
     match v with
@@ -255,13 +246,94 @@ module WrappingIntervalsLattice = struct
   let cut t = List.concat_map ssplit (nsplit t)
 end
 
+module WrappingIntervalsLatticeOps = struct
+  include WrappingIntervalsLattice
+
+  (*
+  TODO: 
+  - Unary:
+    - [x] Negate
+    - [x] Not
+    - [ ] Sign extend
+    - [ ] Zero extend
+    - [ ] Extract 
+  - Binary:
+    - [x] Addition
+    - [x] Subtraction
+    - [ ] Multiplication
+    - [ ] Bitwise Or/And/Xor
+    - [ ] Left Shift
+    - [ ] Logical Right Shift
+    - [ ] Arithmetic Right Shift
+    - [ ] (Un)signed Div and Modulo (see Crab for impl, paper does not provide)
+  - 
+  *)
+
+  let bind1 f t =
+    {
+      w = t.w;
+      v =
+        (match t.v with
+        | Bot -> Bot
+        | Top -> Top
+        | Interval { lower; upper } -> f lower upper);
+    }
+
+  let neg =
+    bind1 (fun l u -> Interval { lower = Bitvec.neg u; upper = Bitvec.neg l })
+
+  let bitnot =
+    bind1 (fun l u ->
+        Interval { lower = Bitvec.bitnot u; upper = Bitvec.bitnot l })
+
+  let add s t =
+    let top = infer s top |> snd in
+    match (s.v, t.v) with
+    | Bot, Bot -> s
+    | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
+      ->
+        if Z.(leq (add (cardinality s) (cardinality t)) (cardinality top)) then
+          interval (Bitvec.add al bl) (Bitvec.add au bu)
+        else top
+    | _, _ -> top
+
+  let sub s t =
+    let top = infer s top |> snd in
+    match (s.v, t.v) with
+    | Bot, Bot -> s
+    | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
+      ->
+        if Z.(leq (add (cardinality s) (cardinality t)) (cardinality top)) then
+          interval (Bitvec.sub al bu) (Bitvec.sub au bl)
+        else top
+    | _, _ -> top
+end
+
 module WrappingIntervalsValueAbstraction = struct
   include WrappingIntervalsLattice
+  include WrappingIntervalsLatticeOps
+
+  let eval_const (op : Lang.Ops.AllOps.const) =
+    match op with
+    | `Bool _ -> { w = Some 1; v = Top }
+    | `Integer _ -> top
+    | `Bitvector bv ->
+        if Bitvec.size bv = 0 then { w = Some 0; v = Top } else interval bv bv
+
+  let eval_unop (op : Lang.Ops.AllOps.unary) a =
+    match op with
+    | `BVNEG -> neg a
+    | `BVNOT -> bitnot a
+    | _ -> infer a top |> snd
+
+  let eval_binop (op : Lang.Ops.AllOps.binary) a b =
+    let a, b = infer a b in
+    match op with
+    | `BVADD -> add a b
+    | `BVSUB -> sub a b
+    | _ -> infer a top |> snd
 
-  let eval_const op = top
-  let eval_unop op a = top
-  let eval_binop op a b = top
-  let eval_intrin op args = top
+  let eval_intrin (op : Lang.Ops.AllOps.intrin) args = top
 end
 
 module StateAbstraction = Intra_analysis.MapState (WrappingIntervalsLattice)

From 0e187fe1c2bf9a3b1d4c7d0095679c1f58b0f67f Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Tue, 20 Jan 2026 15:38:06 +1000
Subject: [PATCH 06/36] Whoops! We prop tested too hard

---
 lib/analysis/wrapping_intervals.ml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 60689ba..6614042 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -17,6 +17,7 @@ module WrappingIntervalsLattice = struct
   let infer { w = w1; v = a } { w = w2; v = b } =
     match (w1, w2) with
     | Some w1, Some w2 ->
+        (* Disable assertion when running `dune test` or the soundness check crashes *)
         assert (w1 = w2);
         ({ w = Some w1; v = a }, { w = Some w2; v = b })
     | Some w1, None -> ({ w = Some w1; v = a }, { w = Some w1; v = b })

From fb26496a23bc0222632dfaf93828d58ca04c5a5b Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 21 Jan 2026 13:34:35 +1000
Subject: [PATCH 07/36] Multiplication and fixing intersect

---
 lib/analysis/wrapping_intervals.ml  | 98 +++++++++++++++++++++++++----
 test/analysis/wrapping_intervals.ml | 15 ++++-
 2 files changed, 98 insertions(+), 15 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 6614042..379c78a 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -12,7 +12,13 @@ module WrappingIntervalsLattice = struct
 
   let interval lower upper =
     Bitvec.size_is_equal lower upper;
-    { w = Some (Bitvec.size lower); v = Interval { lower; upper } }
+    {
+      w = Some (Bitvec.size lower);
+      v =
+        (if Bitvec.(equal lower (add upper (of_int ~size:(size upper) 1))) then
+           Top
+         else Interval { lower; upper });
+    }
 
   let infer { w = w1; v = a } { w = w2; v = b } =
     match (w1, w2) with
@@ -59,7 +65,10 @@ module WrappingIntervalsLattice = struct
     match t with
     | Bot -> false
     | Top -> true
-    | Interval { lower; upper } -> Bitvec.(ule (sub e lower) (sub upper lower))
+    | Interval { lower; upper } ->
+        Bitvec.size_is_equal lower e;
+        Bitvec.size_is_equal upper e;
+        Bitvec.(ule (sub e lower) (sub upper lower))
 
   let compare_l a b =
     match (a, b) with
@@ -192,12 +201,11 @@ module WrappingIntervalsLattice = struct
     let { v = a; _ } = s in
     let { v = b; _ } = t in
     match (a, b) with
-    | Bot, Bot -> []
-    | Top, Bot -> []
-    | Bot, Top -> []
+    | Bot, _ -> []
+    | _, Bot -> []
     | Top, _ -> [ t ]
-    | _, Top -> [ s ]
     | a, b when equal_l a b -> [ t ]
+    | _, Top -> [ s ]
     | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
       ->
         let al_mem = member b al in
@@ -206,15 +214,14 @@ module WrappingIntervalsLattice = struct
         let bu_mem = member a bu in
         let a_in_b = al_mem && au_mem in
         let b_in_a = bl_mem && bu_mem in
-        if a_in_b && b_in_a then [ interval al bu; interval au bl ]
+        if a_in_b && b_in_a then [ interval al bu; interval bl au ]
         else if a_in_b then [ s ]
         else if b_in_a then [ t ]
         else if al_mem && (not au_mem) && (not bl_mem) && bu_mem then
           [ interval al bu ]
         else if (not al_mem) && au_mem && bl_mem && not bu_mem then
-          [ interval au bl ]
+          [ interval bl au ]
         else []
-    | _, _ -> []
 
   let nsplit t =
     match t.v with
@@ -261,7 +268,7 @@ module WrappingIntervalsLatticeOps = struct
   - Binary:
     - [x] Addition
     - [x] Subtraction
-    - [ ] Multiplication
+    - [x] Multiplication
     - [ ] Bitwise Or/And/Xor
     - [ ] Left Shift
     - [ ] Logical Right Shift
@@ -290,7 +297,8 @@ module WrappingIntervalsLatticeOps = struct
   let add s t =
     let top = infer s top |> snd in
     match (s.v, t.v) with
-    | Bot, Bot -> s
+    | Bot, _ -> s
+    | _, Bot -> t
     | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
       ->
         if Z.(leq (add (cardinality s) (cardinality t)) (cardinality top)) then
@@ -301,13 +309,78 @@ module WrappingIntervalsLatticeOps = struct
   let sub s t =
     let top = infer s top |> snd in
     match (s.v, t.v) with
-    | Bot, Bot -> s
+    | Bot, _ -> s
+    | _, Bot -> t
     | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
       ->
         if Z.(leq (add (cardinality s) (cardinality t)) (cardinality top)) then
           interval (Bitvec.sub al bu) (Bitvec.sub au bl)
         else top
     | _, _ -> top
+
+  let mul s t =
+    let rusmul s t =
+      let top = infer s top |> snd in
+      let w =
+        match s.w with
+        | Some w -> w
+        | None -> failwith "Cannot multiply without known width"
+      in
+      let umul =
+        match (s.v, t.v) with
+        | ( Interval { lower = al; upper = au },
+            Interval { lower = bl; upper = bu } ) ->
+            let cond =
+              let al = Bitvec.to_unsigned_bigint al in
+              let au = Bitvec.to_unsigned_bigint au in
+              let bl = Bitvec.to_unsigned_bigint bl in
+              let bu = Bitvec.to_unsigned_bigint bu in
+              Z.(lt (sub (mul au bu) (mul al bl)) (pow (of_int 2) w))
+            in
+            if cond then interval (Bitvec.mul al bl) (Bitvec.mul au bu) else top
+        | _, _ -> top
+      in
+      let smul =
+        match (s.v, t.v) with
+        | ( Interval { lower = al; upper = au },
+            Interval { lower = bl; upper = bu } ) ->
+            let msb_hi b =
+              Bitvec.(equal (extract ~hi:w ~lo:(w - 1) b) (ones ~size:1))
+            in
+            let cond (a, b) (c, d) =
+              let a = Bitvec.to_unsigned_bigint a in
+              let b = Bitvec.to_unsigned_bigint b in
+              let c = Bitvec.to_unsigned_bigint c in
+              let d = Bitvec.to_unsigned_bigint d in
+              Z.(lt (sub (mul a b) (mul c d)) (pow (of_int 2) w))
+            in
+            if
+              msb_hi al && msb_hi au && msb_hi bl && msb_hi bu
+              && cond (au, bu) (al, bl)
+            then interval (Bitvec.mul al bl) (Bitvec.mul au bu)
+            else if
+              msb_hi al && msb_hi au
+              && (not (msb_hi bl))
+              && (not (msb_hi bu))
+              && cond (au, bl) (al, bu)
+            then interval (Bitvec.mul al bu) (Bitvec.mul au bl)
+            else if
+              (not (msb_hi al))
+              && (not (msb_hi au))
+              && msb_hi bl && msb_hi bu
+              && cond (al, bu) (au, bl)
+            then interval (Bitvec.mul au bl) (Bitvec.mul al bu)
+            else top
+        | _, _ -> top
+      in
+      intersect umul smul
+    in
+    let prod =
+      List.concat_map
+        (fun a -> List.concat_map (fun b -> rusmul a b) (cut t))
+        (cut s)
+    in
+    lub prod
 end
 
 module WrappingIntervalsValueAbstraction = struct
@@ -332,6 +405,7 @@ module WrappingIntervalsValueAbstraction = struct
     match op with
     | `BVADD -> add a b
     | `BVSUB -> sub a b
+    | `BVMUL -> mul a b
     | _ -> infer a top |> snd
 
   let eval_intrin (op : Lang.Ops.AllOps.intrin) args = top
diff --git a/test/analysis/wrapping_intervals.ml b/test/analysis/wrapping_intervals.ml
index 8c1f01b..10da808 100644
--- a/test/analysis/wrapping_intervals.ml
+++ b/test/analysis/wrapping_intervals.ml
@@ -1,10 +1,13 @@
 open Bincaml_util.Common
-open Analysis.Wrapping_intervals.WrappingIntervalsLattice
+open Analysis.Wrapping_intervals
+open WrappingIntervalsLattice
 
 let dbg x =
   print_endline (show x);
   x
 
+let dbg_list = List.map dbg
+
 let%test_unit "cardinality" =
   let ( = ) a b = Z.equal a (Z.of_int b) in
   let iv a b = interval (Bitvec.of_int ~size:4 a) (Bitvec.of_int ~size:4 b) in
@@ -81,6 +84,12 @@ let%test_unit "intersect" =
   assert (List.is_empty (intersect bottom bottom));
   assert (List.is_empty (intersect top bottom));
   assert (intersect top (iv 1 2) = [ iv 1 2 ]);
-  assert (intersect (iv 0 4) (iv 2 1) = [ iv 0 1; iv 4 2 ]);
+  assert (List.mem (iv 0 1) (intersect (iv 0 4) (iv 3 1)));
+  assert (List.mem (iv 3 4) (intersect (iv 0 4) (iv 3 1)));
   assert (intersect (iv 0 8) (iv 3 6) = [ iv 3 6 ]);
-  assert (intersect (iv 3 7) (iv 6 11) = [ iv 7 6 ])
+  assert (intersect (iv 3 7) (iv 6 11) = [ iv 6 7 ])
+
+let%test_unit "mul" =
+  let ( = ) = equal in
+  let iv a b = interval (Bitvec.of_int ~size:4 a) (Bitvec.of_int ~size:4 b) in
+  assert (WrappingIntervalsValueAbstraction.mul (iv 15 9) (iv 0 1) = iv 15 9)

From 6058a30b79f6eaca208e4874fbefdbfd2cd15961 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 21 Jan 2026 15:19:18 +1000
Subject: [PATCH 08/36] Un/signed Division

---
 lib/analysis/wrapping_intervals.ml | 90 ++++++++++++++++++++++++++++--
 1 file changed, 84 insertions(+), 6 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 379c78a..84f7775 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -273,7 +273,7 @@ module WrappingIntervalsLatticeOps = struct
     - [ ] Left Shift
     - [ ] Logical Right Shift
     - [ ] Arithmetic Right Shift
-    - [ ] (Un)signed Div and Modulo (see Crab for impl, paper does not provide)
+    - [x] (Un)signed Div (see Crab for impl, paper does not provide)
   - 
   *)
 
@@ -375,12 +375,88 @@ module WrappingIntervalsLatticeOps = struct
       in
       intersect umul smul
     in
-    let prod =
-      List.concat_map
-        (fun a -> List.concat_map (fun b -> rusmul a b) (cut t))
-        (cut s)
+    lub
+      (List.concat_map
+         (fun a -> List.concat_map (fun b -> rusmul a b) (cut t))
+         (cut s))
+
+  (* Division implementation derived from Crab *)
+  let trim_zeroes t =
+    let w =
+      match t.w with
+      | Some w -> w
+      | None -> failwith "Cannot trim zeroes without known width"
     in
-    lub prod
+    let zero = Bitvec.zero ~size:w in
+    match t.v with
+    | Bot -> []
+    | Top -> [ interval (Bitvec.of_int ~size:w 1) (umax w) ]
+    | Interval { lower; upper } ->
+        if Bitvec.equal lower zero && Bitvec.equal upper zero then []
+        else if Bitvec.equal lower zero then
+          [ interval (Bitvec.of_int ~size:w 1) upper ]
+        else if Bitvec.equal upper zero then [ interval lower (umax w) ]
+        else if member t.v zero then
+          [ interval lower (umax w); interval (Bitvec.of_int ~size:w 1) upper ]
+        else [ t ]
+
+  let udiv s t =
+    let divide s t =
+      let top = infer s top |> snd in
+      match (s.v, t.v) with
+      | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
+        ->
+          interval (Bitvec.udiv al bu) (Bitvec.sdiv au bl)
+      | _, _ -> top
+    in
+    lub
+      (List.concat_map
+         (fun a ->
+           List.concat_map
+             (fun bs -> List.map (fun b -> divide a b) (trim_zeroes bs))
+             (nsplit t))
+         (nsplit s))
+
+  let sdiv s t =
+    let divide s t =
+      let top = infer s top |> snd in
+
+      match (s.v, t.v) with
+      | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
+        -> (
+          let w =
+            match s.w with
+            | Some w -> w
+            | None -> failwith "Cannot signed divide without known width"
+          in
+          let msb_hi b =
+            Bitvec.(equal (extract ~hi:w ~lo:(w - 1) b) (ones ~size:1))
+          in
+          let ( = ) = Bitvec.equal in
+          let smin, neg1 = (smin w, umax w) in
+          match (msb_hi al, msb_hi bl) with
+          | true, true
+            when not ((au = smin && bl = neg1) || (al = smin && bu = neg1)) ->
+              interval (Bitvec.sdiv au bl) (Bitvec.sdiv al bu)
+          | false, false
+            when not ((al = smin && bu = neg1) || (au = smin && bl = neg1)) ->
+              interval (Bitvec.sdiv al bu) (Bitvec.sdiv au bl)
+          | true, false
+            when not ((al = smin && bl = neg1) || (au = smin && bu = neg1)) ->
+              interval (Bitvec.sdiv al bl) (Bitvec.sdiv au bu)
+          | false, true
+            when not ((au = smin && bu = neg1) && al = smin && bl = neg1) ->
+              interval (Bitvec.sdiv au bu) (Bitvec.sdiv al bl)
+          | _, _ -> top)
+      | _, _ -> top
+    in
+    lub
+      (List.concat_map
+         (fun a ->
+           List.concat_map
+             (fun bs -> List.map (fun b -> divide a b) (trim_zeroes bs))
+             (cut t))
+         (cut s))
 end
 
 module WrappingIntervalsValueAbstraction = struct
@@ -406,6 +482,8 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVADD -> add a b
     | `BVSUB -> sub a b
     | `BVMUL -> mul a b
+    | `BVUDIV -> udiv a b
+    | `BVSDIV -> sdiv a b
     | _ -> infer a top |> snd
 
   let eval_intrin (op : Lang.Ops.AllOps.intrin) args = top

From 9ae77cec2656923a793c54a708ec8c671af5954e Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Thu, 22 Jan 2026 14:32:53 +1000
Subject: [PATCH 09/36] Bitwise Or/And/Xor

---
 lib/analysis/wrapping_intervals.ml | 135 ++++++++++++++++++++++++++++-
 1 file changed, 134 insertions(+), 1 deletion(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 84f7775..f894916 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -269,7 +269,7 @@ module WrappingIntervalsLatticeOps = struct
     - [x] Addition
     - [x] Subtraction
     - [x] Multiplication
-    - [ ] Bitwise Or/And/Xor
+    - [x] Bitwise Or/And/Xor
     - [ ] Left Shift
     - [ ] Logical Right Shift
     - [ ] Arithmetic Right Shift
@@ -457,6 +457,136 @@ module WrappingIntervalsLatticeOps = struct
              (fun bs -> List.map (fun b -> divide a b) (trim_zeroes bs))
              (cut t))
          (cut s))
+
+  let bitlogop min max s t =
+    let pre s t =
+      match (s.v, t.v) with
+      | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
+        ->
+          interval (min (al, au) (bl, bu)) (max (al, au) (bl, bu))
+      | _, _ -> infer s top |> snd
+    in
+    lub
+      (List.concat_map
+         (fun a -> List.map (fun b -> pre a b) (ssplit t))
+         (ssplit s))
+
+  let bitor =
+    let min_or (al, au) (bl, bu) =
+      let rec min_or_aux m =
+        (* Lazy evaluation trick *)
+        let recurse _ = min_or_aux Bitvec.(lshr m (of_int ~size:(size m) 1)) in
+
+        if Bitvec.is_zero m then Bitvec.bitor al bl
+        else if Bitvec.(is_nonzero (bitand (bitnot al) bl |> bitand m)) then
+          let temp = Bitvec.(bitor al m |> bitand (neg m)) in
+          if Bitvec.ule temp au then Bitvec.bitor temp bl else recurse ()
+        else if Bitvec.(is_nonzero (bitand al (bitnot bl) |> bitand m)) then
+          let temp = Bitvec.(bitor bl m |> bitand (neg m)) in
+          if Bitvec.ule temp bu then Bitvec.bitor al temp else recurse ()
+        else recurse ()
+      in
+      let init = smin (Bitvec.size al) in
+      min_or_aux init
+    in
+
+    let max_or (al, au) (bl, bu) =
+      let rec max_or_aux m =
+        let one = Bitvec.(of_int ~size:(size m) 1) in
+        let recurse _ = max_or_aux Bitvec.(lshr m one) in
+
+        if Bitvec.is_zero m then Bitvec.bitor au bu
+        else if Bitvec.(is_nonzero (bitand au bu |> bitand m)) then
+          let tempau = Bitvec.(bitor (sub au m) (sub m one)) in
+          let tempbu = Bitvec.(bitor (sub bu m) (sub m one)) in
+          if Bitvec.uge tempau al then Bitvec.bitor tempau bu
+          else if Bitvec.uge tempbu bl then Bitvec.bitor au tempbu
+          else recurse ()
+        else recurse ()
+      in
+      let init = smin (Bitvec.size al) in
+      max_or_aux init
+    in
+    bitlogop min_or max_or
+
+  let bitand =
+    let min_and (al, au) (bl, bu) =
+      let rec min_and_aux m =
+        let recurse _ = min_and_aux Bitvec.(lshr m (of_int ~size:(size m) 1)) in
+
+        if Bitvec.is_zero m then Bitvec.bitand al bl
+        else if Bitvec.(is_nonzero (bitand (bitnot al) (bitnot bl) |> bitand m))
+        then
+          let tempal = Bitvec.(bitand (bitor al m) (neg m)) in
+          let tempbl = Bitvec.(bitand (bitor bl m) (neg m)) in
+          if Bitvec.uge tempal au then Bitvec.bitand tempal bl
+          else if Bitvec.uge tempbl bu then Bitvec.bitand al tempbl
+          else recurse ()
+        else recurse ()
+      in
+      let init = smin (Bitvec.size al) in
+      min_and_aux init
+    in
+
+    let max_and (al, au) (bl, bu) =
+      let rec max_and_aux m =
+        let one = Bitvec.(of_int ~size:(size m) 1) in
+        let recurse _ = max_and_aux Bitvec.(lshr m (of_int ~size:(size m) 1)) in
+        if Bitvec.is_zero m then Bitvec.bitand au bu
+        else if Bitvec.(is_nonzero (bitand au (bitnot bl) |> bitand m)) then
+          let temp = Bitvec.(bitor (bitand au (bitnot m)) (sub m one)) in
+          if Bitvec.uge temp al then Bitvec.bitand temp bu else recurse ()
+        else if Bitvec.(is_nonzero (bitand (bitnot au) bu |> bitand m)) then
+          let temp = Bitvec.(bitor (bitand bu (bitnot m)) (sub m one)) in
+          if Bitvec.uge temp bl then Bitvec.bitand au temp else recurse ()
+        else recurse ()
+      in
+      let init = smin (Bitvec.size al) in
+      max_and_aux init
+    in
+    bitlogop min_and max_and
+
+  let bitxor =
+    let min_xor (al, au) (bl, bu) =
+      let rec min_xor_aux m (al, au) (bl, bu) =
+        let recurse = min_xor_aux Bitvec.(lshr m (of_int ~size:(size m) 1)) in
+
+        if Bitvec.is_zero m then Bitvec.bitxor al bl
+        else if Bitvec.(is_nonzero (bitand (bitnot al) bl |> bitand m)) then
+          let temp = Bitvec.(bitor al m |> bitand (neg m)) in
+          let al = if Bitvec.ule temp au then Bitvec.bitor temp bl else al in
+          recurse (al, au) (bl, bu)
+        else if Bitvec.(is_nonzero (bitand al (bitnot bl) |> bitand m)) then
+          let temp = Bitvec.(bitor bl m |> bitand (neg m)) in
+          let bl = if Bitvec.ule temp bu then Bitvec.bitor al temp else bl in
+          recurse (al, au) (bl, bu)
+        else recurse (al, au) (bl, bu)
+      in
+      let init = smin (Bitvec.size al) in
+      min_xor_aux init (al, au) (bl, bu)
+    in
+
+    let max_xor (al, au) (bl, bu) =
+      let rec max_xor_aux m (al, au) (bl, bu) =
+        let one = Bitvec.(of_int ~size:(size m) 1) in
+        let recurse = max_xor_aux Bitvec.(lshr m one) in
+
+        if Bitvec.is_zero m then Bitvec.bitxor au bu
+        else if Bitvec.(is_nonzero (bitand au bu |> bitand m)) then
+          let tempau = Bitvec.(bitor (sub au m) (sub m one)) in
+          let tempbu = Bitvec.(bitor (sub bu m) (sub m one)) in
+          let au, bu =
+            if Bitvec.uge tempau al then (tempau, bu)
+            else if Bitvec.uge tempbu bl then (au, tempbu)
+            else (au, bu)
+          in
+          recurse (al, au) (bl, bu)
+        else recurse (al, au) (bl, bu)
+      in
+      let init = smin (Bitvec.size al) in
+      max_xor_aux init (al, au) (bl, bu)
+    in
+    bitlogop min_xor max_xor
 end
 
 module WrappingIntervalsValueAbstraction = struct
@@ -484,6 +614,9 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVMUL -> mul a b
     | `BVUDIV -> udiv a b
     | `BVSDIV -> sdiv a b
+    | `BVOR -> bitxor a b
+    | `BVAND -> bitand a b
+    | `BVXOR -> bitxor a b
     | _ -> infer a top |> snd
 
   let eval_intrin (op : Lang.Ops.AllOps.intrin) args = top

From 8b7471224fd3328f818d267f33297fcbf5239adf Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Thu, 22 Jan 2026 15:11:45 +1000
Subject: [PATCH 10/36] Zero/Sign extend

---
 lib/analysis/wrapping_intervals.ml | 32 ++++++++++++++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index f894916..ceaf9a1 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -262,8 +262,8 @@ module WrappingIntervalsLatticeOps = struct
   - Unary:
     - [x] Negate
     - [x] Not
-    - [ ] Sign extend
-    - [ ] Zero extend
+    - [x] Sign extend
+    - [x] Zero extend
     - [ ] Extract 
   - Binary:
     - [x] Addition
@@ -294,6 +294,32 @@ module WrappingIntervalsLatticeOps = struct
     bind1 (fun l u ->
         Interval { lower = Bitvec.bitnot u; upper = Bitvec.bitnot l })
 
+  let sign_extend t k =
+    List.filter_map
+      (fun t ->
+        match t.v with
+        | Interval { lower; upper } ->
+            Some
+              (interval
+                 (Bitvec.sign_extend ~extension:k lower)
+                 (Bitvec.sign_extend ~extension:k upper))
+        | _ -> None)
+      (nsplit t)
+    |> lub
+
+  let zero_extend t k =
+    List.filter_map
+      (fun t ->
+        match t.v with
+        | Interval { lower; upper } ->
+            Some
+              (interval
+                 (Bitvec.zero_extend ~extension:k lower)
+                 (Bitvec.zero_extend ~extension:k upper))
+        | _ -> None)
+      (ssplit t)
+    |> lub
+
   let add s t =
     let top = infer s top |> snd in
     match (s.v, t.v) with
@@ -604,6 +630,8 @@ module WrappingIntervalsValueAbstraction = struct
     match op with
     | `BVNEG -> neg a
     | `BVNOT -> bitnot a
+    | `ZeroExtend k -> zero_extend a k
+    | `SignExtend k -> sign_extend a k
     | _ -> infer a top |> snd
 
   let eval_binop (op : Lang.Ops.AllOps.binary) a b =

From 6f4eac9df2abe20b8b467fe87e44698463652f7e Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Fri, 23 Jan 2026 10:54:20 +1000
Subject: [PATCH 11/36] Shifts

---
 lib/analysis/wrapping_intervals.ml | 132 +++++++++++++++++++++++++++--
 1 file changed, 127 insertions(+), 5 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index ceaf9a1..89b55af 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -50,6 +50,12 @@ module WrappingIntervalsLattice = struct
     | Interval { lower; upper } ->
         Bitvec.(sub upper lower |> to_unsigned_bigint |> Z.add (Z.of_int 1))
 
+  let is_singleton { w; v } =
+    match v with
+    | Bot | Top -> None
+    | Interval { lower; upper } ->
+        if Bitvec.equal lower upper then Some lower else None
+
   let compare_size s t = Z.compare (cardinality s) (cardinality t)
 
   let complement { w; v } =
@@ -264,17 +270,16 @@ module WrappingIntervalsLatticeOps = struct
     - [x] Not
     - [x] Sign extend
     - [x] Zero extend
-    - [ ] Extract 
+    - [x] Extract 
   - Binary:
     - [x] Addition
     - [x] Subtraction
     - [x] Multiplication
     - [x] Bitwise Or/And/Xor
-    - [ ] Left Shift
-    - [ ] Logical Right Shift
-    - [ ] Arithmetic Right Shift
+    - [x] Left Shift
+    - [x] Logical Right Shift
+    - [x] Arithmetic Right Shift
     - [x] (Un)signed Div (see Crab for impl, paper does not provide)
-  - 
   *)
 
   let bind1 f t =
@@ -613,6 +618,119 @@ module WrappingIntervalsLatticeOps = struct
       max_xor_aux init (al, au) (bl, bu)
     in
     bitlogop min_xor max_xor
+
+  let truncate t k =
+    match t.v with
+    | Bot -> { w = Some k; v = Bot }
+    | Top -> { w = Some k; v = Top }
+    | Interval { lower; upper } ->
+        let w =
+          match t.w with
+          | Some w -> w
+          | None -> failwith "Cannot truncate without known width"
+        in
+        let truncl = Bitvec.extract ~hi:k ~lo:0 lower in
+        let truncu = Bitvec.extract ~hi:k ~lo:0 upper in
+        let shiftl = Bitvec.(ashr lower (of_int ~size:w k)) in
+        let shiftu = Bitvec.(ashr upper (of_int ~size:w k)) in
+        if
+          Bitvec.(
+            (equal shiftl shiftu && ule truncl truncu)
+            || equal (add shiftl (of_int ~size:w 1)) shiftu
+               && ugt truncl truncu)
+        then interval truncl truncu
+        else { w = Some k; v = Top }
+
+  let shl t k =
+    let shl_const t k =
+      if equal_l t.v Bot then t
+      else
+        let w =
+          match t.w with
+          | Some w -> w
+          | None -> failwith "Cannot shift left without known width"
+        in
+        match (truncate t (w - k)).v with
+        | Interval { lower; upper } ->
+            let lower = Bitvec.zero_extend ~extension:(w - k) lower in
+            let upper = Bitvec.zero_extend ~extension:(w - k) upper in
+            interval
+              Bitvec.(shl lower (of_int ~size:w k))
+              Bitvec.(shl upper (of_int ~size:w k))
+        | _ ->
+            interval (Bitvec.zero ~size:w)
+              Bitvec.(concat (ones ~size:(w - k)) (zero ~size:k))
+    in
+    match is_singleton k with
+    | Some k -> shl_const t (Bitvec.to_unsigned_bigint k |> Z.to_int)
+    | None -> { w = t.w; v = Top }
+
+  let lshr t k =
+    let lshr_const t k =
+      if equal_l t.v Bot then t
+      else
+        let w =
+          match t.w with
+          | Some w -> w
+          | None -> failwith "Cannot logical shift right without known width"
+        in
+        let fallback =
+          interval (Bitvec.zero ~size:w)
+            Bitvec.(concat (zero ~size:k) (ones ~size:(w - k)))
+        in
+        if compare (sp w) t <= 0 then fallback
+        else
+          match t.v with
+          | Interval { lower; upper } ->
+              interval
+                Bitvec.(lshr lower (of_int ~size:w k))
+                Bitvec.(lshr upper (of_int ~size:w k))
+          | _ -> fallback
+    in
+    match is_singleton k with
+    | Some k -> lshr_const t (Bitvec.to_unsigned_bigint k |> Z.to_int)
+    | None -> { w = t.w; v = Top }
+
+  let ashr t k =
+    let ashr_const t k =
+      if equal_l t.v Bot then t
+      else
+        let w =
+          match t.w with
+          | Some w -> w
+          | None -> failwith "Cannot arithmetic shift right without known width"
+        in
+        let fallback =
+          interval
+            Bitvec.(concat (ones ~size:k) (zero ~size:(w - k)))
+            Bitvec.(concat (zero ~size:k) (ones ~size:(w - k)))
+        in
+        if compare (np w) t <= 0 then fallback
+        else
+          match t.v with
+          | Interval { lower; upper } ->
+              interval
+                Bitvec.(ashr lower (of_int ~size:w k))
+                Bitvec.(ashr upper (of_int ~size:w k))
+          | _ -> fallback
+    in
+    match is_singleton k with
+    | Some k -> ashr_const t (Bitvec.to_unsigned_bigint k |> Z.to_int)
+    | None -> { w = t.w; v = Top }
+
+  let extract ~hi ~lo t =
+    assert (0 <= lo);
+    assert (lo <= hi);
+    if hi = lo then { w = Some 0; v = Bot }
+    else
+      let w =
+        match t.w with
+        | Some w -> w
+        | None -> failwith "Cannot extract without known width"
+      in
+      let k = Bitvec.of_int ~size:w lo in
+      assert (hi <= w);
+      truncate (lshr t (interval k k)) (hi - lo)
 end
 
 module WrappingIntervalsValueAbstraction = struct
@@ -632,6 +750,7 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVNOT -> bitnot a
     | `ZeroExtend k -> zero_extend a k
     | `SignExtend k -> sign_extend a k
+    | `Extract (hi, lo) -> extract ~hi ~lo a
     | _ -> infer a top |> snd
 
   let eval_binop (op : Lang.Ops.AllOps.binary) a b =
@@ -645,6 +764,9 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVOR -> bitxor a b
     | `BVAND -> bitand a b
     | `BVXOR -> bitxor a b
+    | `BVASHR -> ashr a b
+    | `BVLSHR -> lshr a b
+    | `BVSHL -> shl a b
     | _ -> infer a top |> snd
 
   let eval_intrin (op : Lang.Ops.AllOps.intrin) args = top

From a0b95ceee01480d6f3677fff5a8a3a57eaf75b77 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Fri, 23 Jan 2026 11:39:28 +1000
Subject: [PATCH 12/36] Multi argument ops

---
 lib/analysis/wrapping_intervals.ml | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 89b55af..a2a80bc 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -275,11 +275,18 @@ module WrappingIntervalsLatticeOps = struct
     - [x] Addition
     - [x] Subtraction
     - [x] Multiplication
-    - [x] Bitwise Or/And/Xor
+    - [x] Bitwise Or/And/Xor/Nand
     - [x] Left Shift
     - [x] Logical Right Shift
     - [x] Arithmetic Right Shift
     - [x] (Un)signed Div (see Crab for impl, paper does not provide)
+  - [ ] Comparisons
+  - Intrinsics
+    - [x] Addition
+    - [x] BitOr
+    - [x] BitXor
+    - [x] BitAnd
+    - [ ] Concat
   *)
 
   let bind1 f t =
@@ -763,13 +770,21 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVSDIV -> sdiv a b
     | `BVOR -> bitxor a b
     | `BVAND -> bitand a b
+    | `BVNAND -> bitand a b |> bitnot
     | `BVXOR -> bitxor a b
     | `BVASHR -> ashr a b
     | `BVLSHR -> lshr a b
     | `BVSHL -> shl a b
     | _ -> infer a top |> snd
 
-  let eval_intrin (op : Lang.Ops.AllOps.intrin) args = top
+  let eval_intrin (op : Lang.Ops.AllOps.intrin) args =
+    let fold op = List.fold_left (eval_binop op) bottom args in
+    match op with
+    | `BVADD -> fold `BVADD
+    | `BVOR -> fold `BVOR
+    | `BVXOR -> fold `BVXOR
+    | `BVAND -> fold `BVAND
+    | _ -> List.fold_left (fun a b -> infer a b |> snd) top args
 end
 
 module StateAbstraction = Intra_analysis.MapState (WrappingIntervalsLattice)

From a5854547a484c7643779f9fef329f60d8e883d47 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Fri, 23 Jan 2026 13:56:53 +1000
Subject: [PATCH 13/36] Concat

---
 lib/analysis/wrapping_intervals.ml | 60 ++++++++++++++++--------------
 1 file changed, 33 insertions(+), 27 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index a2a80bc..09033f6 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -263,32 +263,6 @@ end
 module WrappingIntervalsLatticeOps = struct
   include WrappingIntervalsLattice
 
-  (*
-  TODO: 
-  - Unary:
-    - [x] Negate
-    - [x] Not
-    - [x] Sign extend
-    - [x] Zero extend
-    - [x] Extract 
-  - Binary:
-    - [x] Addition
-    - [x] Subtraction
-    - [x] Multiplication
-    - [x] Bitwise Or/And/Xor/Nand
-    - [x] Left Shift
-    - [x] Logical Right Shift
-    - [x] Arithmetic Right Shift
-    - [x] (Un)signed Div (see Crab for impl, paper does not provide)
-  - [ ] Comparisons
-  - Intrinsics
-    - [x] Addition
-    - [x] BitOr
-    - [x] BitXor
-    - [x] BitAnd
-    - [ ] Concat
-  *)
-
   let bind1 f t =
     {
       w = t.w;
@@ -738,6 +712,34 @@ module WrappingIntervalsLatticeOps = struct
       let k = Bitvec.of_int ~size:w lo in
       assert (hi <= w);
       truncate (lshr t (interval k k)) (hi - lo)
+
+  let concat s t =
+    match (s.v, t.v) with
+    | Bot, _ | _, Bot ->
+        { w = Option.bind s.w (fun u -> Option.map (Int.add u) t.w); v = Bot }
+    | Top, Top ->
+        { w = Option.bind s.w (fun u -> Option.map (Int.add u) t.w); v = Top }
+    | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
+      ->
+        interval (Bitvec.concat al bl) (Bitvec.concat au bu)
+    | Interval { lower = al; upper = au }, Top ->
+        let w =
+          match t.w with
+          | Some w -> w
+          | None -> failwith "Cannot concat without known width"
+        in
+        interval
+          Bitvec.(concat al (zero ~size:w))
+          Bitvec.(concat au (ones ~size:w))
+    | Top, Interval { lower = bl; upper = bu } ->
+        let w =
+          match s.w with
+          | Some w -> w
+          | None -> failwith "Cannot concat without known width"
+        in
+        interval
+          Bitvec.(concat (zero ~size:w) bl)
+          Bitvec.(concat (ones ~size:w) bu)
 end
 
 module WrappingIntervalsValueAbstraction = struct
@@ -784,7 +786,11 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVOR -> fold `BVOR
     | `BVXOR -> fold `BVXOR
     | `BVAND -> fold `BVAND
-    | _ -> List.fold_left (fun a b -> infer a b |> snd) top args
+    | `BVConcat ->
+        List.fold_left concat
+          (interval (Bitvec.zero ~size:0) (Bitvec.zero ~size:0))
+          args
+    | _ -> top
 end
 
 module StateAbstraction = Intra_analysis.MapState (WrappingIntervalsLattice)

From 7565ee34f8015a81bfe3c480d9069b2dada6ffe7 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Tue, 27 Jan 2026 10:02:49 +1000
Subject: [PATCH 14/36] light fixes

---
 lib/analysis/wrapping_intervals.ml | 31 ++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 09033f6..180d2d9 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -249,7 +249,7 @@ module WrappingIntervalsLattice = struct
     | Top -> (
         match t.w with
         | Some w -> [ interval (umin w) (smax w); interval (smin w) (umax w) ]
-        | None -> failwith "Cannot determine nsplit for Top without width")
+        | None -> failwith "Cannot determine ssplit for Top without width")
     | Interval { lower; upper } ->
         let width = Bitvec.size lower in
         let sp = sp width in
@@ -610,17 +610,19 @@ module WrappingIntervalsLatticeOps = struct
           | Some w -> w
           | None -> failwith "Cannot truncate without known width"
         in
-        let truncl = Bitvec.extract ~hi:k ~lo:0 lower in
-        let truncu = Bitvec.extract ~hi:k ~lo:0 upper in
-        let shiftl = Bitvec.(ashr lower (of_int ~size:w k)) in
-        let shiftu = Bitvec.(ashr upper (of_int ~size:w k)) in
-        if
-          Bitvec.(
-            (equal shiftl shiftu && ule truncl truncu)
-            || equal (add shiftl (of_int ~size:w 1)) shiftu
-               && ugt truncl truncu)
-        then interval truncl truncu
-        else { w = Some k; v = Top }
+        if w <= k then interval (Bitvec.zero ~size:0) (Bitvec.zero ~size:0)
+        else
+          let truncl = Bitvec.extract ~hi:k ~lo:0 lower in
+          let truncu = Bitvec.extract ~hi:k ~lo:0 upper in
+          let shiftl = Bitvec.(ashr lower (of_int ~size:w k)) in
+          let shiftu = Bitvec.(ashr upper (of_int ~size:w k)) in
+          if
+            Bitvec.(
+              (equal shiftl shiftu && ule truncl truncu)
+              || equal (add shiftl (of_int ~size:w 1)) shiftu
+                 && ugt truncl truncu)
+          then interval truncl truncu
+          else { w = Some k; v = Top }
 
   let shl t k =
     let shl_const t k =
@@ -631,6 +633,7 @@ module WrappingIntervalsLatticeOps = struct
           | Some w -> w
           | None -> failwith "Cannot shift left without known width"
         in
+        let k = if w < k then 0 else k in
         match (truncate t (w - k)).v with
         | Interval { lower; upper } ->
             let lower = Bitvec.zero_extend ~extension:(w - k) lower in
@@ -702,7 +705,7 @@ module WrappingIntervalsLatticeOps = struct
   let extract ~hi ~lo t =
     assert (0 <= lo);
     assert (lo <= hi);
-    if hi = lo then { w = Some 0; v = Bot }
+    if hi <= lo then { w = Some 0; v = Bot }
     else
       let w =
         match t.w with
@@ -749,7 +752,7 @@ module WrappingIntervalsValueAbstraction = struct
   let eval_const (op : Lang.Ops.AllOps.const) =
     match op with
     | `Bool _ -> { w = Some 1; v = Top }
-    | `Integer _ -> top
+    | `Integer _ -> { w = Some 0; v = Top }
     | `Bitvector bv ->
         if Bitvec.size bv = 0 then { w = Some 0; v = Top } else interval bv bv
 

From 641f8b7d81843110641cf07b0fa94beb5b09d33d Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Tue, 27 Jan 2026 11:53:41 +1000
Subject: [PATCH 15/36] Test everythin

---
 lib/analysis/wrapping_intervals.ml  |  4 +--
 test/analysis/wrapping_intervals.ml | 45 ++++++++++++++++++++++++++++-
 2 files changed, 46 insertions(+), 3 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 180d2d9..13829be 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -636,8 +636,8 @@ module WrappingIntervalsLatticeOps = struct
         let k = if w < k then 0 else k in
         match (truncate t (w - k)).v with
         | Interval { lower; upper } ->
-            let lower = Bitvec.zero_extend ~extension:(w - k) lower in
-            let upper = Bitvec.zero_extend ~extension:(w - k) upper in
+            let lower = Bitvec.zero_extend ~extension:k lower in
+            let upper = Bitvec.zero_extend ~extension:k upper in
             interval
               Bitvec.(shl lower (of_int ~size:w k))
               Bitvec.(shl upper (of_int ~size:w k))
diff --git a/test/analysis/wrapping_intervals.ml b/test/analysis/wrapping_intervals.ml
index 10da808..90088a5 100644
--- a/test/analysis/wrapping_intervals.ml
+++ b/test/analysis/wrapping_intervals.ml
@@ -89,7 +89,50 @@ let%test_unit "intersect" =
   assert (intersect (iv 0 8) (iv 3 6) = [ iv 3 6 ]);
   assert (intersect (iv 3 7) (iv 6 11) = [ iv 6 7 ])
 
+open WrappingIntervalsValueAbstraction
+
 let%test_unit "mul" =
   let ( = ) = equal in
   let iv a b = interval (Bitvec.of_int ~size:4 a) (Bitvec.of_int ~size:4 b) in
-  assert (WrappingIntervalsValueAbstraction.mul (iv 15 9) (iv 0 1) = iv 15 9)
+  assert (mul (iv 15 9) (iv 0 1) = iv 15 9)
+
+let%test_unit "truncate" =
+  let ( = ) = equal in
+  let iv ~w a b =
+    interval (Bitvec.of_int ~size:w a) (Bitvec.of_int ~size:w b)
+  in
+  assert (truncate (iv ~w:4 7 15) 2 = { w = Some 2; v = Top });
+  assert (truncate (iv ~w:4 4 5) 2 = iv ~w:2 0 1)
+
+let%test_unit "shl" =
+  let ( = ) = equal in
+  let iv a b = interval (Bitvec.of_int ~size:4 a) (Bitvec.of_int ~size:4 b) in
+  assert (shl (iv 2 4) (iv 1 1) = iv 4 8);
+  assert (shl (iv 4 8) (iv 2 2) = iv 0 12)
+
+let%test_unit "lshr" =
+  let ( = ) = equal in
+  let iv a b = interval (Bitvec.of_int ~size:4 a) (Bitvec.of_int ~size:4 b) in
+  assert (lshr (iv 3 12) (iv 1 1) = iv 1 6);
+  assert (lshr (iv 15 5) (iv 2 2) = iv 0 3)
+
+let%test_unit "ashr" =
+  let ( = ) = equal in
+  let iv a b = interval (Bitvec.of_int ~size:4 a) (Bitvec.of_int ~size:4 b) in
+  assert (ashr (iv 15 3) (iv 1 1) = iv 15 1);
+  assert (ashr (iv 3 10) (iv 2 2) = iv 12 3)
+
+let%test_unit "extract" =
+  let ( = ) = equal in
+  let iv ~w a b =
+    interval (Bitvec.of_int ~size:w a) (Bitvec.of_int ~size:w b)
+  in
+  assert (extract ~hi:5 ~lo:2 @@ iv ~w:6 13 63 = { w = Some 3; v = Top });
+  assert (extract ~hi:3 ~lo:1 @@ iv ~w:4 4 7 = iv ~w:2 2 3)
+
+let%test_unit "concat" =
+  let ( = ) = equal in
+  let iv ~w a b =
+    interval (Bitvec.of_int ~size:w a) (Bitvec.of_int ~size:w b)
+  in
+  assert (concat (iv ~w:2 1 3) (iv ~w:2 0 2) = iv ~w:4 4 14)

From d434349d384a3c6d0b69e6d893b6128a7817e262 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Tue, 27 Jan 2026 15:06:25 +1000
Subject: [PATCH 16/36] Fixes and don;t allocate 32000GiB

---
 lib/analysis/wrapping_intervals.ml | 145 +++++++++++++++++++----------
 test/lang/value_soundness.ml       |   1 +
 2 files changed, 98 insertions(+), 48 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 13829be..69a618b 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -6,7 +6,18 @@ module WrappingIntervalsLattice = struct
   type l = Top | Interval of { lower : Bitvec.t; upper : Bitvec.t } | Bot
   [@@deriving eq, show { with_path = false }]
 
-  type t = { w : int option; v : l } [@@deriving show { with_path = false }]
+  type t = { w : int option; v : l }
+
+  let show t =
+    let value =
+      match t.v with
+      | Bot -> "⊥"
+      | Top -> "⊤"
+      | Interval { lower; upper } ->
+          "(|" ^ Bitvec.show lower ^ ", " ^ Bitvec.show upper ^ "|)"
+    in
+    let width = match t.w with Some w -> Int.to_string w | None -> "?" in
+    value ^ ":w" ^ width
 
   let equal s t = equal_l s.v t.v
 
@@ -123,13 +134,22 @@ module WrappingIntervalsLattice = struct
 
   (* Join for multiple intervals to increase precision (join is not monotone) *)
   let lub (ints : t list) =
-    let bigger a b = if compare_size a b < 0 then b else a in
+    let bigger a b =
+      match (a.v, b.v) with
+      | x, y when equal_l x y -> a
+      | Bot, _ -> b
+      | _, Bot -> a
+      | Top, _ -> a
+      | _, Top -> b
+      | _ -> if compare_size a b < 0 then b else a
+    in
     let gap a b =
+      let a, b = infer a b in
       match (a.v, b.v) with
       | Interval { upper = au; _ }, Interval { lower = bl; _ }
         when (not (member b.v au)) && not (member a.v bl) ->
           complement (interval bl au)
-      | _, _ -> bottom
+      | _, _ -> infer a bottom |> snd
     in
     (* APLAS12 mentions "last cases are omitted", does not specify which cases. *)
     let extend a b = join a b in
@@ -281,30 +301,50 @@ module WrappingIntervalsLatticeOps = struct
         Interval { lower = Bitvec.bitnot u; upper = Bitvec.bitnot l })
 
   let sign_extend t k =
-    List.filter_map
-      (fun t ->
-        match t.v with
-        | Interval { lower; upper } ->
-            Some
-              (interval
-                 (Bitvec.sign_extend ~extension:k lower)
-                 (Bitvec.sign_extend ~extension:k upper))
-        | _ -> None)
-      (nsplit t)
-    |> lub
+    if Option.equal Int.equal t.w (Some 0) then
+      let zeros = Bitvec.zero ~size:k in
+      interval zeros zeros
+    else
+      List.filter_map
+        (fun t ->
+          match t.v with
+          | Interval { lower; upper } ->
+              Some
+                (interval
+                   (Bitvec.sign_extend ~extension:k lower)
+                   (Bitvec.sign_extend ~extension:k upper))
+          | _ -> None)
+        (nsplit t)
+      |> lub
+      |> fun s ->
+      {
+        v = s.v;
+        w =
+          (match s.w with Some _ -> s.w | None -> Option.map (Int.add k) t.w);
+      }
 
   let zero_extend t k =
-    List.filter_map
-      (fun t ->
-        match t.v with
-        | Interval { lower; upper } ->
-            Some
-              (interval
-                 (Bitvec.zero_extend ~extension:k lower)
-                 (Bitvec.zero_extend ~extension:k upper))
-        | _ -> None)
-      (ssplit t)
-    |> lub
+    if Option.equal Int.equal t.w (Some 0) then
+      let zeros = Bitvec.zero ~size:k in
+      interval zeros zeros
+    else
+      List.filter_map
+        (fun t ->
+          match t.v with
+          | Interval { lower; upper } ->
+              Some
+                (interval
+                   (Bitvec.zero_extend ~extension:k lower)
+                   (Bitvec.zero_extend ~extension:k upper))
+          | _ -> None)
+        (ssplit t)
+      |> lub
+      |> fun s ->
+      {
+        v = s.v;
+        w =
+          (match s.w with Some _ -> s.w | None -> Option.map (Int.add k) t.w);
+      }
 
   let add s t =
     let top = infer s top |> snd in
@@ -387,10 +427,12 @@ module WrappingIntervalsLatticeOps = struct
       in
       intersect umul smul
     in
-    lub
-      (List.concat_map
-         (fun a -> List.concat_map (fun b -> rusmul a b) (cut t))
-         (cut s))
+    infer s
+    @@ lub
+         (List.concat_map
+            (fun a -> List.concat_map (fun b -> rusmul a b) (cut t))
+            (cut s))
+    |> snd
 
   (* Division implementation derived from Crab *)
   let trim_zeroes t =
@@ -421,13 +463,15 @@ module WrappingIntervalsLatticeOps = struct
           interval (Bitvec.udiv al bu) (Bitvec.sdiv au bl)
       | _, _ -> top
     in
-    lub
-      (List.concat_map
-         (fun a ->
-           List.concat_map
-             (fun bs -> List.map (fun b -> divide a b) (trim_zeroes bs))
-             (nsplit t))
-         (nsplit s))
+    infer s
+    @@ lub
+         (List.concat_map
+            (fun a ->
+              List.concat_map
+                (fun bs -> List.map (fun b -> divide a b) (trim_zeroes bs))
+                (nsplit t))
+            (nsplit s))
+    |> snd
 
   let sdiv s t =
     let divide s t =
@@ -462,13 +506,15 @@ module WrappingIntervalsLatticeOps = struct
           | _, _ -> top)
       | _, _ -> top
     in
-    lub
-      (List.concat_map
-         (fun a ->
-           List.concat_map
-             (fun bs -> List.map (fun b -> divide a b) (trim_zeroes bs))
-             (cut t))
-         (cut s))
+    infer s
+    @@ lub
+         (List.concat_map
+            (fun a ->
+              List.concat_map
+                (fun bs -> List.map (fun b -> divide a b) (trim_zeroes bs))
+                (cut t))
+            (cut s))
+    |> snd
 
   let bitlogop min max s t =
     let pre s t =
@@ -478,10 +524,12 @@ module WrappingIntervalsLatticeOps = struct
           interval (min (al, au) (bl, bu)) (max (al, au) (bl, bu))
       | _, _ -> infer s top |> snd
     in
-    lub
-      (List.concat_map
-         (fun a -> List.map (fun b -> pre a b) (ssplit t))
-         (ssplit s))
+    infer s
+    @@ lub
+         (List.concat_map
+            (fun a -> List.map (fun b -> pre a b) (ssplit t))
+            (ssplit s))
+    |> snd
 
   let bitor =
     let min_or (al, au) (bl, bu) =
@@ -685,6 +733,7 @@ module WrappingIntervalsLatticeOps = struct
           | None -> failwith "Cannot arithmetic shift right without known width"
         in
         let fallback =
+          let k = min k w in
           interval
             Bitvec.(concat (ones ~size:k) (zero ~size:(w - k)))
             Bitvec.(concat (zero ~size:k) (ones ~size:(w - k)))
@@ -773,7 +822,7 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVMUL -> mul a b
     | `BVUDIV -> udiv a b
     | `BVSDIV -> sdiv a b
-    | `BVOR -> bitxor a b
+    | `BVOR -> bitor a b
     | `BVAND -> bitand a b
     | `BVNAND -> bitand a b |> bitnot
     | `BVXOR -> bitxor a b
diff --git a/test/lang/value_soundness.ml b/test/lang/value_soundness.ml
index d91e111..92e5ee4 100644
--- a/test/lang/value_soundness.ml
+++ b/test/lang/value_soundness.ml
@@ -31,6 +31,7 @@ struct
     let* exp = eval_expr in
     let partial = lazy (Expr_eval.partial_eval_expr exp) in
     let abstract = lazy (eval_abs exp) in
+    Lazy.force abstract |> ignore;
     let concrete = lazy (eval_abs (Lazy.force partial)) in
     return (exp, partial, abstract, concrete)
 

From a240ddbe822554c5981e97d540bf7bdcf2e0dc48 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 28 Jan 2026 13:29:53 +1000
Subject: [PATCH 17/36] Concat is now sound

---
 lib/analysis/wrapping_intervals.ml  | 56 +++++++++++++++--------------
 test/analysis/wrapping_intervals.ml | 17 ++++++++-
 2 files changed, 46 insertions(+), 27 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 69a618b..8c74f1a 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -301,9 +301,7 @@ module WrappingIntervalsLatticeOps = struct
         Interval { lower = Bitvec.bitnot u; upper = Bitvec.bitnot l })
 
   let sign_extend t k =
-    if Option.equal Int.equal t.w (Some 0) then
-      let zeros = Bitvec.zero ~size:k in
-      interval zeros zeros
+    if Option.equal Int.equal t.w (Some 0) then { w = Some k; v = Top }
     else
       List.filter_map
         (fun t ->
@@ -766,6 +764,12 @@ module WrappingIntervalsLatticeOps = struct
       truncate (lshr t (interval k k)) (hi - lo)
 
   let concat s t =
+    let tw =
+      match t.w with
+      | Some w -> w
+      | None -> failwith "Cannot concat without known width"
+    in
+    let t = if compare (sp tw) t <= 0 then { w = t.w; v = Top } else t in
     match (s.v, t.v) with
     | Bot, _ | _, Bot ->
         { w = Option.bind s.w (fun u -> Option.map (Int.add u) t.w); v = Bot }
@@ -775,23 +779,18 @@ module WrappingIntervalsLatticeOps = struct
       ->
         interval (Bitvec.concat al bl) (Bitvec.concat au bu)
     | Interval { lower = al; upper = au }, Top ->
-        let w =
-          match t.w with
-          | Some w -> w
-          | None -> failwith "Cannot concat without known width"
-        in
         interval
-          Bitvec.(concat al (zero ~size:w))
-          Bitvec.(concat au (ones ~size:w))
+          Bitvec.(concat al (zero ~size:tw))
+          Bitvec.(concat au (ones ~size:tw))
     | Top, Interval { lower = bl; upper = bu } ->
-        let w =
+        let sw =
           match s.w with
           | Some w -> w
           | None -> failwith "Cannot concat without known width"
         in
         interval
-          Bitvec.(concat (zero ~size:w) bl)
-          Bitvec.(concat (ones ~size:w) bu)
+          Bitvec.(concat (zero ~size:sw) bl)
+          Bitvec.(concat (ones ~size:sw) bu)
 end
 
 module WrappingIntervalsValueAbstraction = struct
@@ -820,12 +819,12 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVADD -> add a b
     | `BVSUB -> sub a b
     | `BVMUL -> mul a b
-    | `BVUDIV -> udiv a b
-    | `BVSDIV -> sdiv a b
-    | `BVOR -> bitor a b
-    | `BVAND -> bitand a b
-    | `BVNAND -> bitand a b |> bitnot
-    | `BVXOR -> bitxor a b
+    (* | `BVUDIV -> udiv a b *)
+    (* | `BVSDIV -> sdiv a b *)
+    (* | `BVOR -> bitor a b *)
+    (* | `BVAND -> bitand a b *)
+    (* | `BVNAND -> bitand a b |> bitnot *)
+    (* | `BVXOR -> bitxor a b *)
     | `BVASHR -> ashr a b
     | `BVLSHR -> lshr a b
     | `BVSHL -> shl a b
@@ -835,13 +834,18 @@ module WrappingIntervalsValueAbstraction = struct
     let fold op = List.fold_left (eval_binop op) bottom args in
     match op with
     | `BVADD -> fold `BVADD
-    | `BVOR -> fold `BVOR
-    | `BVXOR -> fold `BVXOR
-    | `BVAND -> fold `BVAND
-    | `BVConcat ->
-        List.fold_left concat
-          (interval (Bitvec.zero ~size:0) (Bitvec.zero ~size:0))
-          args
+    (* | `BVOR -> fold `BVOR *)
+    (* | `BVXOR -> fold `BVXOR *)
+    (* | `BVAND -> fold `BVAND *)
+    | `BVConcat -> (
+        List.map Option.some args
+        |> List.fold_left
+             (fun a b ->
+               match a with Some a -> Option.map (concat a) b | None -> b)
+             None
+        |> function
+        | Some res -> res
+        | None -> { w = Some 0; v = Top })
     | _ -> top
 end
 
diff --git a/test/analysis/wrapping_intervals.ml b/test/analysis/wrapping_intervals.ml
index 90088a5..91c3cfa 100644
--- a/test/analysis/wrapping_intervals.ml
+++ b/test/analysis/wrapping_intervals.ml
@@ -135,4 +135,19 @@ let%test_unit "concat" =
   let iv ~w a b =
     interval (Bitvec.of_int ~size:w a) (Bitvec.of_int ~size:w b)
   in
-  assert (concat (iv ~w:2 1 3) (iv ~w:2 0 2) = iv ~w:4 4 14)
+  assert (concat (iv ~w:2 1 3) (iv ~w:2 0 2) = iv ~w:4 4 14);
+  assert (concat (iv ~w:2 3 0) (iv ~w:2 0 2) = iv ~w:4 12 2)
+
+let%test_unit "zero_extend" =
+  let ( = ) = equal in
+  let iv ~w a b =
+    interval (Bitvec.of_int ~size:w a) (Bitvec.of_int ~size:w b)
+  in
+  assert (zero_extend (iv ~w:3 0 1) 3 = iv ~w:6 0 1)
+
+let%test_unit "sign_extend" =
+  let ( = ) = equal in
+  let iv ~w a b =
+    interval (Bitvec.of_int ~size:w a) (Bitvec.of_int ~size:w b)
+  in
+  assert (sign_extend (iv ~w:3 0 1) 3 = iv ~w:6 0 1)

From cd4ebd6ca8fa7a721ac5dbf196315ea98112f74c Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 28 Jan 2026 13:30:57 +1000
Subject: [PATCH 18/36] Concat is now sound

---
 lib/analysis/wrapping_intervals.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 8c74f1a..84d50f9 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -818,7 +818,7 @@ module WrappingIntervalsValueAbstraction = struct
     match op with
     | `BVADD -> add a b
     | `BVSUB -> sub a b
-    | `BVMUL -> mul a b
+    (* | `BVMUL -> mul a b *)
     (* | `BVUDIV -> udiv a b *)
     (* | `BVSDIV -> sdiv a b *)
     (* | `BVOR -> bitor a b *)

From 37e1a1211b744e530512f2e8530028dc914ea7e1 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 28 Jan 2026 13:45:56 +1000
Subject: [PATCH 19/36] smul is all equal not all high

---
 lib/analysis/wrapping_intervals.ml | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 84d50f9..8cdacb1 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -404,10 +404,15 @@ module WrappingIntervalsLatticeOps = struct
               let d = Bitvec.to_unsigned_bigint d in
               Z.(lt (sub (mul a b) (mul c d)) (pow (of_int 2) w))
             in
-            if
-              msb_hi al && msb_hi au && msb_hi bl && msb_hi bu
-              && cond (au, bu) (al, bl)
-            then interval (Bitvec.mul al bl) (Bitvec.mul au bu)
+            let all_hi = msb_hi al && msb_hi au && msb_hi bl && msb_hi bu in
+            let all_lo =
+              (not @@ msb_hi al)
+              && (not @@ msb_hi au)
+              && (not @@ msb_hi bl)
+              && (not @@ msb_hi bu)
+            in
+            if (all_hi || all_lo) && cond (au, bu) (al, bl) then
+              interval (Bitvec.mul al bl) (Bitvec.mul au bu)
             else if
               msb_hi al && msb_hi au
               && (not (msb_hi bl))
@@ -818,7 +823,7 @@ module WrappingIntervalsValueAbstraction = struct
     match op with
     | `BVADD -> add a b
     | `BVSUB -> sub a b
-    (* | `BVMUL -> mul a b *)
+    | `BVMUL -> mul a b
     (* | `BVUDIV -> udiv a b *)
     (* | `BVSDIV -> sdiv a b *)
     (* | `BVOR -> bitor a b *)

From eeaf8705438ed52811a1619184b751e2247e8594 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 28 Jan 2026 14:23:09 +1000
Subject: [PATCH 20/36] Or and XOR are safe too!

---
 lib/analysis/wrapping_intervals.ml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 8cdacb1..b90de46 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -826,10 +826,10 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVMUL -> mul a b
     (* | `BVUDIV -> udiv a b *)
     (* | `BVSDIV -> sdiv a b *)
-    (* | `BVOR -> bitor a b *)
+    | `BVOR -> bitor a b
     (* | `BVAND -> bitand a b *)
     (* | `BVNAND -> bitand a b |> bitnot *)
-    (* | `BVXOR -> bitxor a b *)
+    | `BVXOR -> bitxor a b
     | `BVASHR -> ashr a b
     | `BVLSHR -> lshr a b
     | `BVSHL -> shl a b
@@ -839,8 +839,8 @@ module WrappingIntervalsValueAbstraction = struct
     let fold op = List.fold_left (eval_binop op) bottom args in
     match op with
     | `BVADD -> fold `BVADD
-    (* | `BVOR -> fold `BVOR *)
-    (* | `BVXOR -> fold `BVXOR *)
+    | `BVOR -> fold `BVOR
+    | `BVXOR -> fold `BVXOR
     (* | `BVAND -> fold `BVAND *)
     | `BVConcat -> (
         List.map Option.some args

From 01b9ed32ee54f03b7500e1543bcaec4458efab0f Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 28 Jan 2026 14:40:29 +1000
Subject: [PATCH 21/36] All clear on AND, not sure about mul...

---
 lib/analysis/wrapping_intervals.ml | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index b90de46..e1c8c8d 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -14,7 +14,7 @@ module WrappingIntervalsLattice = struct
       | Bot -> "⊥"
       | Top -> "⊤"
       | Interval { lower; upper } ->
-          "(|" ^ Bitvec.show lower ^ ", " ^ Bitvec.show upper ^ "|)"
+          "⟦" ^ Bitvec.show lower ^ ", " ^ Bitvec.show upper ^ "⟧"
     in
     let width = match t.w with Some w -> Int.to_string w | None -> "?" in
     value ^ ":w" ^ width
@@ -582,8 +582,8 @@ module WrappingIntervalsLatticeOps = struct
         then
           let tempal = Bitvec.(bitand (bitor al m) (neg m)) in
           let tempbl = Bitvec.(bitand (bitor bl m) (neg m)) in
-          if Bitvec.uge tempal au then Bitvec.bitand tempal bl
-          else if Bitvec.uge tempbl bu then Bitvec.bitand al tempbl
+          if Bitvec.ule tempal au then Bitvec.bitand tempal bl
+          else if Bitvec.ule tempbl bu then Bitvec.bitand al tempbl
           else recurse ()
         else recurse ()
       in
@@ -596,7 +596,7 @@ module WrappingIntervalsLatticeOps = struct
         let one = Bitvec.(of_int ~size:(size m) 1) in
         let recurse _ = max_and_aux Bitvec.(lshr m (of_int ~size:(size m) 1)) in
         if Bitvec.is_zero m then Bitvec.bitand au bu
-        else if Bitvec.(is_nonzero (bitand au (bitnot bl) |> bitand m)) then
+        else if Bitvec.(is_nonzero (bitand au (bitnot bu) |> bitand m)) then
           let temp = Bitvec.(bitor (bitand au (bitnot m)) (sub m one)) in
           if Bitvec.uge temp al then Bitvec.bitand temp bu else recurse ()
         else if Bitvec.(is_nonzero (bitand (bitnot au) bu |> bitand m)) then
@@ -827,8 +827,8 @@ module WrappingIntervalsValueAbstraction = struct
     (* | `BVUDIV -> udiv a b *)
     (* | `BVSDIV -> sdiv a b *)
     | `BVOR -> bitor a b
-    (* | `BVAND -> bitand a b *)
-    (* | `BVNAND -> bitand a b |> bitnot *)
+    | `BVAND -> bitand a b
+    | `BVNAND -> bitand a b |> bitnot
     | `BVXOR -> bitxor a b
     | `BVASHR -> ashr a b
     | `BVLSHR -> lshr a b
@@ -841,7 +841,7 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVADD -> fold `BVADD
     | `BVOR -> fold `BVOR
     | `BVXOR -> fold `BVXOR
-    (* | `BVAND -> fold `BVAND *)
+    | `BVAND -> fold `BVAND
     | `BVConcat -> (
         List.map Option.some args
         |> List.fold_left

From e93f85e5fcd793fd7f3e8947e74b52c103c74c29 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Thu, 29 Jan 2026 13:20:49 +1000
Subject: [PATCH 22/36] Mul is fixed, thanks b-paul

---
 lib/analysis/wrapping_intervals.ml  | 18 ++++++++++--------
 test/analysis/wrapping_intervals.ml | 16 ++++++++++++++++
 test/lang/value_soundness.ml        | 18 +++++++++++++++++-
 3 files changed, 43 insertions(+), 9 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index e1c8c8d..df99e86 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -402,7 +402,9 @@ module WrappingIntervalsLatticeOps = struct
               let b = Bitvec.to_unsigned_bigint b in
               let c = Bitvec.to_unsigned_bigint c in
               let d = Bitvec.to_unsigned_bigint d in
-              Z.(lt (sub (mul a b) (mul c d)) (pow (of_int 2) w))
+              let res = Z.(sub (mul a b) (mul c d)) in
+              Z.(lt res (pow (of_int 2) w))
+              && Z.(leq (neg (pow (of_int 2) w)) res)
             in
             let all_hi = msb_hi al && msb_hi au && msb_hi bl && msb_hi bu in
             let all_lo =
@@ -826,10 +828,10 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVMUL -> mul a b
     (* | `BVUDIV -> udiv a b *)
     (* | `BVSDIV -> sdiv a b *)
-    | `BVOR -> bitor a b
-    | `BVAND -> bitand a b
-    | `BVNAND -> bitand a b |> bitnot
-    | `BVXOR -> bitxor a b
+    (* | `BVOR -> bitor a b *)
+    (* | `BVAND -> bitand a b *)
+    (* | `BVNAND -> bitand a b |> bitnot *)
+    (* | `BVXOR -> bitxor a b *)
     | `BVASHR -> ashr a b
     | `BVLSHR -> lshr a b
     | `BVSHL -> shl a b
@@ -839,9 +841,9 @@ module WrappingIntervalsValueAbstraction = struct
     let fold op = List.fold_left (eval_binop op) bottom args in
     match op with
     | `BVADD -> fold `BVADD
-    | `BVOR -> fold `BVOR
-    | `BVXOR -> fold `BVXOR
-    | `BVAND -> fold `BVAND
+    (* | `BVOR -> fold `BVOR *)
+    (* | `BVXOR -> fold `BVXOR *)
+    (* | `BVAND -> fold `BVAND *)
     | `BVConcat -> (
         List.map Option.some args
         |> List.fold_left
diff --git a/test/analysis/wrapping_intervals.ml b/test/analysis/wrapping_intervals.ml
index 91c3cfa..b9f039c 100644
--- a/test/analysis/wrapping_intervals.ml
+++ b/test/analysis/wrapping_intervals.ml
@@ -151,3 +151,19 @@ let%test_unit "sign_extend" =
     interval (Bitvec.of_int ~size:w a) (Bitvec.of_int ~size:w b)
   in
   assert (sign_extend (iv ~w:3 0 1) 3 = iv ~w:6 0 1)
+
+let%test "mul2" =
+  let iv ~w a b =
+    interval (Bitvec.of_int ~size:w a) (Bitvec.of_int ~size:w b)
+  in
+  let abstract =
+    eval_binop `BVMUL (iv ~w:43 0x48303bae5fb 0x48303bae5fb)
+    @@ eval_intrin `BVConcat
+         [
+           iv ~w:26 0 0;
+           eval_binop `BVUREM (iv ~w:17 0x1e97e 0x1e97e)
+             (iv ~w:17 0xdbf3 0xdbf3);
+         ]
+  in
+  let concrete = iv ~w:43 0x180fcfd9808 0x180fcfd9808 in
+  compare concrete abstract <= 0
diff --git a/test/lang/value_soundness.ml b/test/lang/value_soundness.ml
index 92e5ee4..981ee5a 100644
--- a/test/lang/value_soundness.ml
+++ b/test/lang/value_soundness.ml
@@ -11,6 +11,21 @@ struct
     let* wd = Expr_gen.gen_width in
     Expr_gen.gen_bvexpr (5, wd)
 
+  (* let eval_expr = *)
+  (*   let open QCheck.Gen in *)
+  (*   let* wd = Expr_gen.gen_width in *)
+  (*   let* l = Expr_gen.gen_bvconst wd in *)
+  (*   let* r = Expr_gen.gen_bvconst wd in *)
+  (*   let* op = oneofl [ `BVUDIV; `BVMUL ] in *)
+  (*   return (Expr.BasilExpr.binexp ~op l r) *)
+
+  (* let eval_expr = *)
+  (*   let open QCheck.Gen in *)
+  (*   let* wd = Expr_gen.gen_width in *)
+  (*   let* l = Expr_gen.gen_bvconst wd in *)
+  (*   let* op = oneofl [] in *)
+  (*   return (Expr.BasilExpr.unexp ~op l) *)
+
   let arb_abstract_eval =
     let eval_abs e =
       Eval.eval Ops.AllOps.show_const Ops.AllOps.show_unary
@@ -45,7 +60,8 @@ struct
   let suite =
     let open QCheck in
     let test =
-      Test.make ~name:V.name ~count:10000 ~max_fail:3 arb_abstract_eval is_sound
+      Test.make ~name:V.name ~count:1000000 ~max_fail:3 arb_abstract_eval
+        is_sound
     in
     let suite = List.map QCheck_alcotest.to_alcotest [ test ] in
     ("soundness::" ^ V.name, suite)

From f14ada0a01526fd11744a22fab4dd8e311ccb5ec Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Thu, 29 Jan 2026 13:50:50 +1000
Subject: [PATCH 23/36] I think the bitwise stuff is fine

---
 lib/analysis/wrapping_intervals.ml | 40 +++++++++++++++---------------
 test/lang/value_soundness.ml       | 34 +++++++++++++++----------
 2 files changed, 41 insertions(+), 33 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index df99e86..72fda0a 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -828,32 +828,32 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVMUL -> mul a b
     (* | `BVUDIV -> udiv a b *)
     (* | `BVSDIV -> sdiv a b *)
-    (* | `BVOR -> bitor a b *)
-    (* | `BVAND -> bitand a b *)
-    (* | `BVNAND -> bitand a b |> bitnot *)
-    (* | `BVXOR -> bitxor a b *)
+    | `BVOR -> bitor a b
+    | `BVAND -> bitand a b
+    | `BVNAND -> bitand a b |> bitnot
+    | `BVXOR -> bitxor a b
     | `BVASHR -> ashr a b
     | `BVLSHR -> lshr a b
     | `BVSHL -> shl a b
     | _ -> infer a top |> snd
 
   let eval_intrin (op : Lang.Ops.AllOps.intrin) args =
-    let fold op = List.fold_left (eval_binop op) bottom args in
-    match op with
-    | `BVADD -> fold `BVADD
-    (* | `BVOR -> fold `BVOR *)
-    (* | `BVXOR -> fold `BVXOR *)
-    (* | `BVAND -> fold `BVAND *)
-    | `BVConcat -> (
-        List.map Option.some args
-        |> List.fold_left
-             (fun a b ->
-               match a with Some a -> Option.map (concat a) b | None -> b)
-             None
-        |> function
-        | Some res -> res
-        | None -> { w = Some 0; v = Top })
-    | _ -> top
+    let op =
+      match op with
+      | `BVADD -> eval_binop `BVADD
+      | `BVOR -> eval_binop `BVOR
+      | `BVXOR -> eval_binop `BVXOR
+      | `BVAND -> eval_binop `BVAND
+      | `BVConcat -> concat
+      | _ -> fun _ _ -> top
+    in
+    List.map Option.some args
+    |> List.fold_left
+         (fun a b -> match a with Some a -> Option.map (op a) b | None -> b)
+         None
+    |> function
+    | Some res -> res
+    | None -> { w = Some 0; v = Top }
 end
 
 module StateAbstraction = Intra_analysis.MapState (WrappingIntervalsLattice)
diff --git a/test/lang/value_soundness.ml b/test/lang/value_soundness.ml
index 981ee5a..9079698 100644
--- a/test/lang/value_soundness.ml
+++ b/test/lang/value_soundness.ml
@@ -14,17 +14,26 @@ struct
   (* let eval_expr = *)
   (*   let open QCheck.Gen in *)
   (*   let* wd = Expr_gen.gen_width in *)
-  (*   let* l = Expr_gen.gen_bvconst wd in *)
-  (*   let* r = Expr_gen.gen_bvconst wd in *)
-  (*   let* op = oneofl [ `BVUDIV; `BVMUL ] in *)
-  (*   return (Expr.BasilExpr.binexp ~op l r) *)
-
-  (* let eval_expr = *)
-  (*   let open QCheck.Gen in *)
-  (*   let* wd = Expr_gen.gen_width in *)
-  (*   let* l = Expr_gen.gen_bvconst wd in *)
-  (*   let* op = oneofl [] in *)
-  (*   return (Expr.BasilExpr.unexp ~op l) *)
+  (*   let gen_binop l r = *)
+  (*     let* op = oneofl [ `BVOR; `BVXOR; `BVNAND; `BVUREM ] in *)
+  (*     return (Expr.BasilExpr.binexp ~op l r) *)
+  (*   in *)
+  (*   let gen_bvexpr = *)
+  (*     fix (fun self (size, wd) -> *)
+  (*         let self wd = self (size / 2, wd) in *)
+  (*         match size with *)
+  (*         | 0 -> Expr_gen.gen_bvconst wd *)
+  (*         | size -> *)
+  (*             frequency *)
+  (*               [ *)
+  (*                 (1, Expr_gen.gen_bvconst wd); *)
+  (*                 ( 2, *)
+  (*                   let* l = self wd in *)
+  (*                   let* r = self wd in *)
+  (*                   gen_binop l r ); *)
+  (*               ]) *)
+  (*   in *)
+  (*   gen_bvexpr (5, wd) *)
 
   let arb_abstract_eval =
     let eval_abs e =
@@ -60,8 +69,7 @@ struct
   let suite =
     let open QCheck in
     let test =
-      Test.make ~name:V.name ~count:1000000 ~max_fail:3 arb_abstract_eval
-        is_sound
+      Test.make ~name:V.name ~count:10000 ~max_fail:3 arb_abstract_eval is_sound
     in
     let suite = List.map QCheck_alcotest.to_alcotest [ test ] in
     ("soundness::" ^ V.name, suite)

From 284bac939984efe7aa3700843871b494781cb2d8 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Fri, 30 Jan 2026 12:18:45 +1000
Subject: [PATCH 24/36] UDiv should ssplit, not nsplit (Crab was wrong)

---
 lib/analysis/wrapping_intervals.ml  | 12 ++++++------
 test/analysis/wrapping_intervals.ml |  5 +++++
 test/lang/value_soundness.ml        | 24 ------------------------
 3 files changed, 11 insertions(+), 30 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 72fda0a..16f30a0 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -404,7 +404,7 @@ module WrappingIntervalsLatticeOps = struct
               let d = Bitvec.to_unsigned_bigint d in
               let res = Z.(sub (mul a b) (mul c d)) in
               Z.(lt res (pow (of_int 2) w))
-              && Z.(leq (neg (pow (of_int 2) w)) res)
+              && Z.(lt (neg (pow (of_int 2) w)) res)
             in
             let all_hi = msb_hi al && msb_hi au && msb_hi bl && msb_hi bu in
             let all_lo =
@@ -465,7 +465,7 @@ module WrappingIntervalsLatticeOps = struct
       match (s.v, t.v) with
       | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
         ->
-          interval (Bitvec.udiv al bu) (Bitvec.sdiv au bl)
+          interval (Bitvec.udiv al bu) (Bitvec.udiv au bl)
       | _, _ -> top
     in
     infer s
@@ -474,8 +474,8 @@ module WrappingIntervalsLatticeOps = struct
             (fun a ->
               List.concat_map
                 (fun bs -> List.map (fun b -> divide a b) (trim_zeroes bs))
-                (nsplit t))
-            (nsplit s))
+                (ssplit t))
+            (ssplit s))
     |> snd
 
   let sdiv s t =
@@ -826,8 +826,8 @@ module WrappingIntervalsValueAbstraction = struct
     | `BVADD -> add a b
     | `BVSUB -> sub a b
     | `BVMUL -> mul a b
-    (* | `BVUDIV -> udiv a b *)
-    (* | `BVSDIV -> sdiv a b *)
+    | `BVUDIV -> udiv a b
+    | `BVSDIV -> sdiv a b
     | `BVOR -> bitor a b
     | `BVAND -> bitand a b
     | `BVNAND -> bitand a b |> bitnot
diff --git a/test/analysis/wrapping_intervals.ml b/test/analysis/wrapping_intervals.ml
index b9f039c..2428435 100644
--- a/test/analysis/wrapping_intervals.ml
+++ b/test/analysis/wrapping_intervals.ml
@@ -167,3 +167,8 @@ let%test "mul2" =
   in
   let concrete = iv ~w:43 0x180fcfd9808 0x180fcfd9808 in
   compare concrete abstract <= 0
+
+let%test "udiv_top_top" =
+  let ( = ) = equal in
+  let top = { w = Some 4; v = Top } in
+  top = udiv top top
diff --git a/test/lang/value_soundness.ml b/test/lang/value_soundness.ml
index 9079698..92e5ee4 100644
--- a/test/lang/value_soundness.ml
+++ b/test/lang/value_soundness.ml
@@ -11,30 +11,6 @@ struct
     let* wd = Expr_gen.gen_width in
     Expr_gen.gen_bvexpr (5, wd)
 
-  (* let eval_expr = *)
-  (*   let open QCheck.Gen in *)
-  (*   let* wd = Expr_gen.gen_width in *)
-  (*   let gen_binop l r = *)
-  (*     let* op = oneofl [ `BVOR; `BVXOR; `BVNAND; `BVUREM ] in *)
-  (*     return (Expr.BasilExpr.binexp ~op l r) *)
-  (*   in *)
-  (*   let gen_bvexpr = *)
-  (*     fix (fun self (size, wd) -> *)
-  (*         let self wd = self (size / 2, wd) in *)
-  (*         match size with *)
-  (*         | 0 -> Expr_gen.gen_bvconst wd *)
-  (*         | size -> *)
-  (*             frequency *)
-  (*               [ *)
-  (*                 (1, Expr_gen.gen_bvconst wd); *)
-  (*                 ( 2, *)
-  (*                   let* l = self wd in *)
-  (*                   let* r = self wd in *)
-  (*                   gen_binop l r ); *)
-  (*               ]) *)
-  (*   in *)
-  (*   gen_bvexpr (5, wd) *)
-
   let arb_abstract_eval =
     let eval_abs e =
       Eval.eval Ops.AllOps.show_const Ops.AllOps.show_unary

From 571a8f87c1b04f597b6e94680130599914f14388 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Fri, 30 Jan 2026 14:30:28 +1000
Subject: [PATCH 25/36] Tidy up show

---
 lib/analysis/wrapping_intervals.ml | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapping_intervals.ml
index 16f30a0..67925d0 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapping_intervals.ml
@@ -4,18 +4,19 @@ module WrappingIntervalsLattice = struct
   let name = "wrappingIntervals"
 
   type l = Top | Interval of { lower : Bitvec.t; upper : Bitvec.t } | Bot
-  [@@deriving eq, show { with_path = false }]
+  [@@deriving eq]
 
   type t = { w : int option; v : l }
 
+  let show_l l =
+    match l with
+    | Bot -> "⊥"
+    | Top -> "⊤"
+    | Interval { lower; upper } ->
+        "⟦" ^ Bitvec.show lower ^ ", " ^ Bitvec.show upper ^ "⟧"
+
   let show t =
-    let value =
-      match t.v with
-      | Bot -> "⊥"
-      | Top -> "⊤"
-      | Interval { lower; upper } ->
-          "⟦" ^ Bitvec.show lower ^ ", " ^ Bitvec.show upper ^ "⟧"
-    in
+    let value = show_l t.v in
     let width = match t.w with Some w -> Int.to_string w | None -> "?" in
     value ^ ":w" ^ width
 
@@ -34,7 +35,6 @@ module WrappingIntervalsLattice = struct
   let infer { w = w1; v = a } { w = w2; v = b } =
     match (w1, w2) with
     | Some w1, Some w2 ->
-        (* Disable assertion when running `dune test` or the soundness check crashes *)
         assert (w1 = w2);
         ({ w = Some w1; v = a }, { w = Some w2; v = b })
     | Some w1, None -> ({ w = Some w1; v = a }, { w = Some w1; v = b })

From 2f09696b4bfce1bf1e6393ff8ffe90346fc9ab70 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Mon, 2 Feb 2026 09:31:50 +1000
Subject: [PATCH 26/36] Appease dune fmt

---
 lib/analysis/dune | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/lib/analysis/dune b/lib/analysis/dune
index b13ddcb..c983293 100644
--- a/lib/analysis/dune
+++ b/lib/analysis/dune
@@ -2,7 +2,12 @@
  (public_name bincaml.analysis)
  (name analysis)
  (flags -w -27)
- (modules dataflow_graph intra_analysis defuse_bool wrapping_intervals lattice_types)
+ (modules
+  dataflow_graph
+  intra_analysis
+  defuse_bool
+  wrapping_intervals
+  lattice_types)
  (libraries
   patricia-tree
   loader

From f2885d27062fb551bff4770b108b62ce0d4eec05 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 4 Feb 2026 11:44:57 +1000
Subject: [PATCH 27/36] Wrapping --> Wrapped

---
 lib/analysis/dune                             |  4 ++--
 ...ping_intervals.ml => wrapped_intervals.ml} | 21 +++++++++----------
 ...ping_intervals.ml => wrapped_intervals.ml} |  6 +++---
 test/lang/value_soundness.ml                  |  6 +++---
 4 files changed, 18 insertions(+), 19 deletions(-)
 rename lib/analysis/{wrapping_intervals.ml => wrapped_intervals.ml} (98%)
 rename test/analysis/{wrapping_intervals.ml => wrapped_intervals.ml} (98%)

diff --git a/lib/analysis/dune b/lib/analysis/dune
index c983293..57f541e 100644
--- a/lib/analysis/dune
+++ b/lib/analysis/dune
@@ -6,8 +6,8 @@
   dataflow_graph
   intra_analysis
   defuse_bool
-  wrapping_intervals
-  lattice_types)
+  lattice_types
+  wrapped_intervals)
  (libraries
   patricia-tree
   loader
diff --git a/lib/analysis/wrapping_intervals.ml b/lib/analysis/wrapped_intervals.ml
similarity index 98%
rename from lib/analysis/wrapping_intervals.ml
rename to lib/analysis/wrapped_intervals.ml
index 67925d0..ac74a29 100644
--- a/lib/analysis/wrapping_intervals.ml
+++ b/lib/analysis/wrapped_intervals.ml
@@ -1,7 +1,7 @@
 open Bincaml_util.Common
 
-module WrappingIntervalsLattice = struct
-  let name = "wrappingIntervals"
+module WrappedIntervalsLattice = struct
+  let name = "wrappedIntervals"
 
   type l = Top | Interval of { lower : Bitvec.t; upper : Bitvec.t } | Bot
   [@@deriving eq]
@@ -280,8 +280,8 @@ module WrappingIntervalsLattice = struct
   let cut t = List.concat_map ssplit (nsplit t)
 end
 
-module WrappingIntervalsLatticeOps = struct
-  include WrappingIntervalsLattice
+module WrappedIntervalsLatticeOps = struct
+  include WrappedIntervalsLattice
 
   let bind1 f t =
     {
@@ -800,9 +800,8 @@ module WrappingIntervalsLatticeOps = struct
           Bitvec.(concat (ones ~size:sw) bu)
 end
 
-module WrappingIntervalsValueAbstraction = struct
-  include WrappingIntervalsLattice
-  include WrappingIntervalsLatticeOps
+module WrappedIntervalsValueAbstraction = struct
+  include WrappedIntervalsLatticeOps
 
   let eval_const (op : Lang.Ops.AllOps.const) =
     match op with
@@ -856,12 +855,12 @@ module WrappingIntervalsValueAbstraction = struct
     | None -> { w = Some 0; v = Top }
 end
 
-module StateAbstraction = Intra_analysis.MapState (WrappingIntervalsLattice)
+module StateAbstraction = Intra_analysis.MapState (WrappedIntervalsLattice)
 
-module WrappingIntervalsValueAbstractionBasil = struct
-  include WrappingIntervalsValueAbstraction
+module WrappedIntervalsValueAbstractionBasil = struct
+  include WrappedIntervalsValueAbstraction
   module E = Lang.Expr.BasilExpr
 end
 
 include
-  Dataflow_graph.EasyForwardAnalysisPack (WrappingIntervalsValueAbstractionBasil)
+  Dataflow_graph.EasyForwardAnalysisPack (WrappedIntervalsValueAbstractionBasil)
diff --git a/test/analysis/wrapping_intervals.ml b/test/analysis/wrapped_intervals.ml
similarity index 98%
rename from test/analysis/wrapping_intervals.ml
rename to test/analysis/wrapped_intervals.ml
index 2428435..6c7dce3 100644
--- a/test/analysis/wrapping_intervals.ml
+++ b/test/analysis/wrapped_intervals.ml
@@ -1,6 +1,6 @@
 open Bincaml_util.Common
-open Analysis.Wrapping_intervals
-open WrappingIntervalsLattice
+open Analysis.Wrapped_intervals
+open WrappedIntervalsLattice
 
 let dbg x =
   print_endline (show x);
@@ -89,7 +89,7 @@ let%test_unit "intersect" =
   assert (intersect (iv 0 8) (iv 3 6) = [ iv 3 6 ]);
   assert (intersect (iv 3 7) (iv 6 11) = [ iv 6 7 ])
 
-open WrappingIntervalsValueAbstraction
+open WrappedIntervalsValueAbstraction
 
 let%test_unit "mul" =
   let ( = ) = equal in
diff --git a/test/lang/value_soundness.ml b/test/lang/value_soundness.ml
index 92e5ee4..eb48a9f 100644
--- a/test/lang/value_soundness.ml
+++ b/test/lang/value_soundness.ml
@@ -56,10 +56,10 @@ end
 module TestBoolDom =
   ValueAbstractionSoundness (Analysis.Defuse_bool.IsZeroValueAbstractionBasil)
 
-module TestWrappingIntervalDom =
+module TestWrappedIntervalDom =
   ValueAbstractionSoundness
-    (Analysis.Wrapping_intervals.WrappingIntervalsValueAbstractionBasil)
+    (Analysis.Wrapped_intervals.WrappedIntervalsValueAbstractionBasil)
 
 let _ =
   Alcotest.run "value domain abstract eval soundness"
-    [ TestBoolDom.suite; TestWrappingIntervalDom.suite ]
+    [ TestBoolDom.suite; TestWrappedIntervalDom.suite ]

From 8027d35a27efacc18c9b09f00de4db55d3eb5d49 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 4 Feb 2026 11:47:51 +1000
Subject: [PATCH 28/36] Add implementation notes

---
 docs/dev/wrapped-intervals.pdf | Bin 0 -> 155792 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100755 docs/dev/wrapped-intervals.pdf

diff --git a/docs/dev/wrapped-intervals.pdf b/docs/dev/wrapped-intervals.pdf
new file mode 100755
index 0000000000000000000000000000000000000000..f51d6095a107192ad549006bd421a77b89a957ef
GIT binary patch
literal 155792
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
F{12qW_74C6

literal 0
HcmV?d00001


From df2b54f6976694cb85273426f226fd3c8a03d168 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 4 Feb 2026 13:46:14 +1000
Subject: [PATCH 29/36] Fix bounds handling on shift and extract

---
 lib/analysis/wrapped_intervals.ml  | 36 +++++++++++++++++++++++++-----
 test/analysis/wrapped_intervals.ml |  3 ++-
 2 files changed, 32 insertions(+), 7 deletions(-)

diff --git a/lib/analysis/wrapped_intervals.ml b/lib/analysis/wrapped_intervals.ml
index ac74a29..8d67484 100644
--- a/lib/analysis/wrapped_intervals.ml
+++ b/lib/analysis/wrapped_intervals.ml
@@ -35,7 +35,7 @@ module WrappedIntervalsLattice = struct
   let infer { w = w1; v = a } { w = w2; v = b } =
     match (w1, w2) with
     | Some w1, Some w2 ->
-        assert (w1 = w2);
+        (* assert (w1 = w2); *)
         ({ w = Some w1; v = a }, { w = Some w2; v = b })
     | Some w1, None -> ({ w = Some w1; v = a }, { w = Some w1; v = b })
     | None, Some w2 -> ({ w = Some w2; v = a }, { w = Some w2; v = b })
@@ -663,7 +663,7 @@ module WrappedIntervalsLatticeOps = struct
           | Some w -> w
           | None -> failwith "Cannot truncate without known width"
         in
-        if w <= k then interval (Bitvec.zero ~size:0) (Bitvec.zero ~size:0)
+        if w < k then interval (Bitvec.zero ~size:0) (Bitvec.zero ~size:0)
         else
           let truncl = Bitvec.extract ~hi:k ~lo:0 lower in
           let truncu = Bitvec.extract ~hi:k ~lo:0 upper in
@@ -686,7 +686,7 @@ module WrappedIntervalsLatticeOps = struct
           | Some w -> w
           | None -> failwith "Cannot shift left without known width"
         in
-        let k = if w < k then 0 else k in
+        let k = if w < k then w else k in
         match (truncate t (w - k)).v with
         | Interval { lower; upper } ->
             let lower = Bitvec.zero_extend ~extension:k lower in
@@ -699,7 +699,14 @@ module WrappedIntervalsLatticeOps = struct
               Bitvec.(concat (ones ~size:(w - k)) (zero ~size:k))
     in
     match is_singleton k with
-    | Some k -> shl_const t (Bitvec.to_unsigned_bigint k |> Z.to_int)
+    | Some k ->
+        shl_const t
+          ( Bitvec.to_unsigned_bigint k |> fun k ->
+            if Z.fits_int k then Z.to_int k
+            else
+              match t.w with
+              | Some w -> w + 1
+              | None -> failwith "Cannot shift left without known width" )
     | None -> { w = t.w; v = Top }
 
   let lshr t k =
@@ -725,7 +732,15 @@ module WrappedIntervalsLatticeOps = struct
           | _ -> fallback
     in
     match is_singleton k with
-    | Some k -> lshr_const t (Bitvec.to_unsigned_bigint k |> Z.to_int)
+    | Some k ->
+        lshr_const t
+          ( Bitvec.to_unsigned_bigint k |> fun k ->
+            if Z.fits_int k then Z.to_int k
+            else
+              match t.w with
+              | Some w -> w + 1
+              | None ->
+                  failwith "Cannot logical shift right without known width" )
     | None -> { w = t.w; v = Top }
 
   let ashr t k =
@@ -753,7 +768,16 @@ module WrappedIntervalsLatticeOps = struct
           | _ -> fallback
     in
     match is_singleton k with
-    | Some k -> ashr_const t (Bitvec.to_unsigned_bigint k |> Z.to_int)
+    | Some k ->
+        ashr_const t
+          ( Bitvec.to_unsigned_bigint k |> fun k ->
+            if Z.fits_int k then Z.to_int k
+            else
+              match t.w with
+              | Some w -> w + 1
+              | None ->
+                  failwith "Cannot arithmetic shift right without known width"
+          )
     | None -> { w = t.w; v = Top }
 
   let extract ~hi ~lo t =
diff --git a/test/analysis/wrapped_intervals.ml b/test/analysis/wrapped_intervals.ml
index 6c7dce3..e6b3e5b 100644
--- a/test/analysis/wrapped_intervals.ml
+++ b/test/analysis/wrapped_intervals.ml
@@ -128,7 +128,8 @@ let%test_unit "extract" =
     interval (Bitvec.of_int ~size:w a) (Bitvec.of_int ~size:w b)
   in
   assert (extract ~hi:5 ~lo:2 @@ iv ~w:6 13 63 = { w = Some 3; v = Top });
-  assert (extract ~hi:3 ~lo:1 @@ iv ~w:4 4 7 = iv ~w:2 2 3)
+  assert (extract ~hi:3 ~lo:1 @@ iv ~w:4 4 7 = iv ~w:2 2 3);
+  assert (extract ~hi:3 ~lo:0 @@ iv ~w:3 3 3 = iv ~w:3 3 3)
 
 let%test_unit "concat" =
   let ( = ) = equal in

From 19eabd9d02ebc0e14300875b39c9706cb0fed2a8 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 4 Feb 2026 14:02:49 +1000
Subject: [PATCH 30/36] open Bitvec

---
 lib/analysis/wrapped_intervals.ml | 308 ++++++++++++++----------------
 1 file changed, 148 insertions(+), 160 deletions(-)

diff --git a/lib/analysis/wrapped_intervals.ml b/lib/analysis/wrapped_intervals.ml
index 8d67484..7a16de4 100644
--- a/lib/analysis/wrapped_intervals.ml
+++ b/lib/analysis/wrapped_intervals.ml
@@ -1,4 +1,5 @@
 open Bincaml_util.Common
+open Bitvec
 
 module WrappedIntervalsLattice = struct
   let name = "wrappedIntervals"
@@ -12,8 +13,7 @@ module WrappedIntervalsLattice = struct
     match l with
     | Bot -> "⊥"
     | Top -> "⊤"
-    | Interval { lower; upper } ->
-        "⟦" ^ Bitvec.show lower ^ ", " ^ Bitvec.show upper ^ "⟧"
+    | Interval { lower; upper } -> "⟦" ^ show lower ^ ", " ^ show upper ^ "⟧"
 
   let show t =
     let value = show_l t.v in
@@ -23,9 +23,9 @@ module WrappedIntervalsLattice = struct
   let equal s t = equal_l s.v t.v
 
   let interval lower upper =
-    Bitvec.size_is_equal lower upper;
+    size_is_equal lower upper;
     {
-      w = Some (Bitvec.size lower);
+      w = Some (size lower);
       v =
         (if Bitvec.(equal lower (add upper (of_int ~size:(size upper) 1))) then
            Top
@@ -41,10 +41,10 @@ module WrappedIntervalsLattice = struct
     | None, Some w2 -> ({ w = Some w2; v = a }, { w = Some w2; v = b })
     | None, None -> ({ w = None; v = a }, { w = None; v = b })
 
-  let umin width = Bitvec.zero ~size:width
-  let umax width = Bitvec.ones ~size:width
-  let smin width = Bitvec.(concat (ones ~size:1) (zero ~size:(width - 1)))
-  let smax width = Bitvec.(zero_extend ~extension:1 (ones ~size:(width - 1)))
+  let umin width = zero ~size:width
+  let umax width = ones ~size:width
+  let smin width = concat (ones ~size:1) (zero ~size:(width - 1))
+  let smax width = zero_extend ~extension:1 (ones ~size:(width - 1))
   let sp width = interval (umax width) (umin width)
   let np width = interval (smax width) (smin width)
   let top = { w = None; v = Top }
@@ -59,7 +59,7 @@ module WrappedIntervalsLattice = struct
         | Some w -> Z.pow (Z.of_int 2) w
         | None -> failwith "Cannot determine cardinality for Top without width")
     | Interval { lower; upper } ->
-        Bitvec.(sub upper lower |> to_unsigned_bigint |> Z.add (Z.of_int 1))
+        sub upper lower |> to_unsigned_bigint |> Z.add (Z.of_int 1)
 
   let is_singleton { w; v } =
     match v with
@@ -74,8 +74,8 @@ module WrappedIntervalsLattice = struct
     | Bot -> { w; v = Top }
     | Top -> { w; v = Bot }
     | Interval { lower; upper } ->
-        let new_lower = Bitvec.(add upper (of_int ~size:(size upper) 1)) in
-        let new_upper = Bitvec.(sub lower (of_int ~size:(size lower) 1)) in
+        let new_lower = add upper (of_int ~size:(size upper) 1) in
+        let new_upper = sub lower (of_int ~size:(size lower) 1) in
         interval new_lower new_upper
 
   let member t e =
@@ -83,9 +83,9 @@ module WrappedIntervalsLattice = struct
     | Bot -> false
     | Top -> true
     | Interval { lower; upper } ->
-        Bitvec.size_is_equal lower e;
-        Bitvec.size_is_equal upper e;
-        Bitvec.(ule (sub e lower) (sub upper lower))
+        size_is_equal lower e;
+        size_is_equal upper e;
+        ule (sub e lower) (sub upper lower)
 
   let compare_l a b =
     match (a, b) with
@@ -119,7 +119,7 @@ module WrappedIntervalsLattice = struct
           let bl_mem = member a bl in
           let bu_mem = member a bu in
           if al_mem && au_mem && bl_mem && bu_mem then
-            { w = Some (Bitvec.size al); v = Top }
+            { w = Some (size al); v = Top }
           else if au_mem && bl_mem then interval al bu
           else if al_mem && bu_mem then interval bl au
           else
@@ -127,7 +127,7 @@ module WrappedIntervalsLattice = struct
             let outer_span = cardinality (interval bu al) in
             if
               Z.lt inner_span outer_span
-              || (Z.equal inner_span outer_span && Bitvec.ule al bl)
+              || (Z.equal inner_span outer_span && ule al bl)
             then interval al bu
             else interval bl au
       | _, _ -> failwith "unreachable"
@@ -166,8 +166,7 @@ module WrappedIntervalsLattice = struct
       List.fold_left
         (fun acc t ->
           match t.v with
-          | Interval { lower; upper } when Bitvec.ule upper lower ->
-              extend acc t
+          | Interval { lower; upper } when ule upper lower -> extend acc t
           | _ -> acc)
         bottom sorted
     in
@@ -189,9 +188,9 @@ module WrappedIntervalsLattice = struct
     | Top, _ -> t
     | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
       ->
-        Bitvec.size_is_equal al bl;
-        Bitvec.size_is_equal au bu;
-        let width = Bitvec.size al in
+        size_is_equal al bl;
+        size_is_equal au bu;
+        let width = size al in
         if compare t s <= 0 then s
         else if Z.geq (cardinality s) (Z.pow (Z.of_int 2) width) then
           { w = Some width; v = Top }
@@ -200,26 +199,23 @@ module WrappedIntervalsLattice = struct
           if equal joined (interval al bu) then
             join joined
               (interval al
-                 Bitvec.(
-                   sub (mul au (of_int ~size:width 2)) al
-                   |> add (of_int ~size:width 1)))
+                 (sub (mul au (of_int ~size:width 2)) al
+                 |> add (of_int ~size:width 1)))
           else if equal joined (interval bl au) then
             join joined
               (interval
-                 Bitvec.(
-                   sub
-                     (sub (mul al (of_int ~size:width 2)) au)
-                     (of_int ~size:width 1))
+                 (sub
+                    (sub (mul al (of_int ~size:width 2)) au)
+                    (of_int ~size:width 1))
                  au)
           else if member b al && member b au then
             join t
               (interval bl
-                 Bitvec.(
-                   sub
-                     (bl
-                     |> add (mul au (of_int ~size:width 2))
-                     |> add (of_int ~size:width 1))
-                     (mul al (of_int ~size:width 2))))
+                 (sub
+                    (bl
+                    |> add (mul au (of_int ~size:width 2))
+                    |> add (of_int ~size:width 1))
+                    (mul al (of_int ~size:width 2))))
           else { w = Some width; v = Top }
 
   let intersect s t =
@@ -257,7 +253,7 @@ module WrappedIntervalsLattice = struct
         | Some w -> [ interval (umin w) (smax w); interval (smin w) (umax w) ]
         | None -> failwith "Cannot determine nsplit for Top without width")
     | Interval { lower; upper } ->
-        let width = Bitvec.size lower in
+        let width = size lower in
         let np = np width in
         if compare np t <= 0 then
           [ interval lower (smax width); interval (smin width) upper ]
@@ -271,7 +267,7 @@ module WrappedIntervalsLattice = struct
         | Some w -> [ interval (umin w) (smax w); interval (smin w) (umax w) ]
         | None -> failwith "Cannot determine ssplit for Top without width")
     | Interval { lower; upper } ->
-        let width = Bitvec.size lower in
+        let width = size lower in
         let sp = sp width in
         if compare sp t <= 0 then
           [ interval lower (umax width); interval (umin width) upper ]
@@ -293,12 +289,10 @@ module WrappedIntervalsLatticeOps = struct
         | Interval { lower; upper } -> f lower upper);
     }
 
-  let neg =
-    bind1 (fun l u -> Interval { lower = Bitvec.neg u; upper = Bitvec.neg l })
+  let neg = bind1 (fun l u -> Interval { lower = neg u; upper = neg l })
 
   let bitnot =
-    bind1 (fun l u ->
-        Interval { lower = Bitvec.bitnot u; upper = Bitvec.bitnot l })
+    bind1 (fun l u -> Interval { lower = bitnot u; upper = bitnot l })
 
   let sign_extend t k =
     if Option.equal Int.equal t.w (Some 0) then { w = Some k; v = Top }
@@ -309,8 +303,8 @@ module WrappedIntervalsLatticeOps = struct
           | Interval { lower; upper } ->
               Some
                 (interval
-                   (Bitvec.sign_extend ~extension:k lower)
-                   (Bitvec.sign_extend ~extension:k upper))
+                   (sign_extend ~extension:k lower)
+                   (sign_extend ~extension:k upper))
           | _ -> None)
         (nsplit t)
       |> lub
@@ -323,7 +317,7 @@ module WrappedIntervalsLatticeOps = struct
 
   let zero_extend t k =
     if Option.equal Int.equal t.w (Some 0) then
-      let zeros = Bitvec.zero ~size:k in
+      let zeros = zero ~size:k in
       interval zeros zeros
     else
       List.filter_map
@@ -332,8 +326,8 @@ module WrappedIntervalsLatticeOps = struct
           | Interval { lower; upper } ->
               Some
                 (interval
-                   (Bitvec.zero_extend ~extension:k lower)
-                   (Bitvec.zero_extend ~extension:k upper))
+                   (zero_extend ~extension:k lower)
+                   (zero_extend ~extension:k upper))
           | _ -> None)
         (ssplit t)
       |> lub
@@ -352,7 +346,7 @@ module WrappedIntervalsLatticeOps = struct
     | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
       ->
         if Z.(leq (add (cardinality s) (cardinality t)) (cardinality top)) then
-          interval (Bitvec.add al bl) (Bitvec.add au bu)
+          interval (add al bl) (add au bu)
         else top
     | _, _ -> top
 
@@ -364,7 +358,7 @@ module WrappedIntervalsLatticeOps = struct
     | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
       ->
         if Z.(leq (add (cardinality s) (cardinality t)) (cardinality top)) then
-          interval (Bitvec.sub al bu) (Bitvec.sub au bl)
+          interval (sub al bu) (sub au bl)
         else top
     | _, _ -> top
 
@@ -381,13 +375,13 @@ module WrappedIntervalsLatticeOps = struct
         | ( Interval { lower = al; upper = au },
             Interval { lower = bl; upper = bu } ) ->
             let cond =
-              let al = Bitvec.to_unsigned_bigint al in
-              let au = Bitvec.to_unsigned_bigint au in
-              let bl = Bitvec.to_unsigned_bigint bl in
-              let bu = Bitvec.to_unsigned_bigint bu in
+              let al = to_unsigned_bigint al in
+              let au = to_unsigned_bigint au in
+              let bl = to_unsigned_bigint bl in
+              let bu = to_unsigned_bigint bu in
               Z.(lt (sub (mul au bu) (mul al bl)) (pow (of_int 2) w))
             in
-            if cond then interval (Bitvec.mul al bl) (Bitvec.mul au bu) else top
+            if cond then interval (mul al bl) (mul au bu) else top
         | _, _ -> top
       in
       let smul =
@@ -398,10 +392,10 @@ module WrappedIntervalsLatticeOps = struct
               Bitvec.(equal (extract ~hi:w ~lo:(w - 1) b) (ones ~size:1))
             in
             let cond (a, b) (c, d) =
-              let a = Bitvec.to_unsigned_bigint a in
-              let b = Bitvec.to_unsigned_bigint b in
-              let c = Bitvec.to_unsigned_bigint c in
-              let d = Bitvec.to_unsigned_bigint d in
+              let a = to_unsigned_bigint a in
+              let b = to_unsigned_bigint b in
+              let c = to_unsigned_bigint c in
+              let d = to_unsigned_bigint d in
               let res = Z.(sub (mul a b) (mul c d)) in
               Z.(lt res (pow (of_int 2) w))
               && Z.(lt (neg (pow (of_int 2) w)) res)
@@ -414,19 +408,19 @@ module WrappedIntervalsLatticeOps = struct
               && (not @@ msb_hi bu)
             in
             if (all_hi || all_lo) && cond (au, bu) (al, bl) then
-              interval (Bitvec.mul al bl) (Bitvec.mul au bu)
+              interval (mul al bl) (mul au bu)
             else if
               msb_hi al && msb_hi au
               && (not (msb_hi bl))
               && (not (msb_hi bu))
               && cond (au, bl) (al, bu)
-            then interval (Bitvec.mul al bu) (Bitvec.mul au bl)
+            then interval (mul al bu) (mul au bl)
             else if
               (not (msb_hi al))
               && (not (msb_hi au))
               && msb_hi bl && msb_hi bu
               && cond (al, bu) (au, bl)
-            then interval (Bitvec.mul au bl) (Bitvec.mul al bu)
+            then interval (mul au bl) (mul al bu)
             else top
         | _, _ -> top
       in
@@ -446,17 +440,17 @@ module WrappedIntervalsLatticeOps = struct
       | Some w -> w
       | None -> failwith "Cannot trim zeroes without known width"
     in
-    let zero = Bitvec.zero ~size:w in
+    let zero = zero ~size:w in
     match t.v with
     | Bot -> []
-    | Top -> [ interval (Bitvec.of_int ~size:w 1) (umax w) ]
+    | Top -> [ interval (of_int ~size:w 1) (umax w) ]
     | Interval { lower; upper } ->
-        if Bitvec.equal lower zero && Bitvec.equal upper zero then []
-        else if Bitvec.equal lower zero then
-          [ interval (Bitvec.of_int ~size:w 1) upper ]
-        else if Bitvec.equal upper zero then [ interval lower (umax w) ]
+        let equal = Bitvec.equal in
+        if equal lower zero && equal upper zero then []
+        else if equal lower zero then [ interval (of_int ~size:w 1) upper ]
+        else if equal upper zero then [ interval lower (umax w) ]
         else if member t.v zero then
-          [ interval lower (umax w); interval (Bitvec.of_int ~size:w 1) upper ]
+          [ interval lower (umax w); interval (of_int ~size:w 1) upper ]
         else [ t ]
 
   let udiv s t =
@@ -465,7 +459,7 @@ module WrappedIntervalsLatticeOps = struct
       match (s.v, t.v) with
       | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
         ->
-          interval (Bitvec.udiv al bu) (Bitvec.udiv au bl)
+          interval (udiv al bu) (udiv au bl)
       | _, _ -> top
     in
     infer s
@@ -498,16 +492,16 @@ module WrappedIntervalsLatticeOps = struct
           match (msb_hi al, msb_hi bl) with
           | true, true
             when not ((au = smin && bl = neg1) || (al = smin && bu = neg1)) ->
-              interval (Bitvec.sdiv au bl) (Bitvec.sdiv al bu)
+              interval (sdiv au bl) (sdiv al bu)
           | false, false
             when not ((al = smin && bu = neg1) || (au = smin && bl = neg1)) ->
-              interval (Bitvec.sdiv al bu) (Bitvec.sdiv au bl)
+              interval (sdiv al bu) (sdiv au bl)
           | true, false
             when not ((al = smin && bl = neg1) || (au = smin && bu = neg1)) ->
-              interval (Bitvec.sdiv al bl) (Bitvec.sdiv au bu)
+              interval (sdiv al bl) (sdiv au bu)
           | false, true
             when not ((au = smin && bu = neg1) && al = smin && bl = neg1) ->
-              interval (Bitvec.sdiv au bu) (Bitvec.sdiv al bl)
+              interval (sdiv au bu) (sdiv al bl)
           | _, _ -> top)
       | _, _ -> top
     in
@@ -540,36 +534,36 @@ module WrappedIntervalsLatticeOps = struct
     let min_or (al, au) (bl, bu) =
       let rec min_or_aux m =
         (* Lazy evaluation trick *)
-        let recurse _ = min_or_aux Bitvec.(lshr m (of_int ~size:(size m) 1)) in
-
-        if Bitvec.is_zero m then Bitvec.bitor al bl
-        else if Bitvec.(is_nonzero (bitand (bitnot al) bl |> bitand m)) then
-          let temp = Bitvec.(bitor al m |> bitand (neg m)) in
-          if Bitvec.ule temp au then Bitvec.bitor temp bl else recurse ()
-        else if Bitvec.(is_nonzero (bitand al (bitnot bl) |> bitand m)) then
-          let temp = Bitvec.(bitor bl m |> bitand (neg m)) in
-          if Bitvec.ule temp bu then Bitvec.bitor al temp else recurse ()
+        let recurse _ = min_or_aux (lshr m (of_int ~size:(size m) 1)) in
+        let open Bitvec in
+        if is_zero m then bitor al bl
+        else if is_nonzero (bitand (bitnot al) bl |> bitand m) then
+          let temp = bitor al m |> bitand (neg m) in
+          if ule temp au then bitor temp bl else recurse ()
+        else if is_nonzero (bitand al (bitnot bl) |> bitand m) then
+          let temp = bitor bl m |> bitand (neg m) in
+          if ule temp bu then bitor al temp else recurse ()
         else recurse ()
       in
-      let init = smin (Bitvec.size al) in
+      let init = smin (size al) in
       min_or_aux init
     in
 
     let max_or (al, au) (bl, bu) =
       let rec max_or_aux m =
-        let one = Bitvec.(of_int ~size:(size m) 1) in
-        let recurse _ = max_or_aux Bitvec.(lshr m one) in
-
-        if Bitvec.is_zero m then Bitvec.bitor au bu
-        else if Bitvec.(is_nonzero (bitand au bu |> bitand m)) then
-          let tempau = Bitvec.(bitor (sub au m) (sub m one)) in
-          let tempbu = Bitvec.(bitor (sub bu m) (sub m one)) in
-          if Bitvec.uge tempau al then Bitvec.bitor tempau bu
-          else if Bitvec.uge tempbu bl then Bitvec.bitor au tempbu
+        let one = of_int ~size:(size m) 1 in
+        let recurse _ = max_or_aux (lshr m one) in
+        let open Bitvec in
+        if is_zero m then bitor au bu
+        else if is_nonzero (bitand au bu |> bitand m) then
+          let tempau = bitor (sub au m) (sub m one) in
+          let tempbu = bitor (sub bu m) (sub m one) in
+          if uge tempau al then bitor tempau bu
+          else if uge tempbu bl then bitor au tempbu
           else recurse ()
         else recurse ()
       in
-      let init = smin (Bitvec.size al) in
+      let init = smin (size al) in
       max_or_aux init
     in
     bitlogop min_or max_or
@@ -577,36 +571,36 @@ module WrappedIntervalsLatticeOps = struct
   let bitand =
     let min_and (al, au) (bl, bu) =
       let rec min_and_aux m =
-        let recurse _ = min_and_aux Bitvec.(lshr m (of_int ~size:(size m) 1)) in
-
-        if Bitvec.is_zero m then Bitvec.bitand al bl
-        else if Bitvec.(is_nonzero (bitand (bitnot al) (bitnot bl) |> bitand m))
-        then
-          let tempal = Bitvec.(bitand (bitor al m) (neg m)) in
-          let tempbl = Bitvec.(bitand (bitor bl m) (neg m)) in
-          if Bitvec.ule tempal au then Bitvec.bitand tempal bl
-          else if Bitvec.ule tempbl bu then Bitvec.bitand al tempbl
+        let recurse _ = min_and_aux (lshr m (of_int ~size:(size m) 1)) in
+        let open Bitvec in
+        if is_zero m then bitand al bl
+        else if is_nonzero (bitand (bitnot al) (bitnot bl) |> bitand m) then
+          let tempal = bitand (bitor al m) (neg m) in
+          let tempbl = bitand (bitor bl m) (neg m) in
+          if ule tempal au then bitand tempal bl
+          else if ule tempbl bu then bitand al tempbl
           else recurse ()
         else recurse ()
       in
-      let init = smin (Bitvec.size al) in
+      let init = smin (size al) in
       min_and_aux init
     in
 
     let max_and (al, au) (bl, bu) =
       let rec max_and_aux m =
-        let one = Bitvec.(of_int ~size:(size m) 1) in
-        let recurse _ = max_and_aux Bitvec.(lshr m (of_int ~size:(size m) 1)) in
-        if Bitvec.is_zero m then Bitvec.bitand au bu
-        else if Bitvec.(is_nonzero (bitand au (bitnot bu) |> bitand m)) then
-          let temp = Bitvec.(bitor (bitand au (bitnot m)) (sub m one)) in
-          if Bitvec.uge temp al then Bitvec.bitand temp bu else recurse ()
-        else if Bitvec.(is_nonzero (bitand (bitnot au) bu |> bitand m)) then
-          let temp = Bitvec.(bitor (bitand bu (bitnot m)) (sub m one)) in
-          if Bitvec.uge temp bl then Bitvec.bitand au temp else recurse ()
+        let one = of_int ~size:(size m) 1 in
+        let recurse _ = max_and_aux (lshr m (of_int ~size:(size m) 1)) in
+        let open Bitvec in
+        if is_zero m then bitand au bu
+        else if is_nonzero (bitand au (bitnot bu) |> bitand m) then
+          let temp = bitor (bitand au (bitnot m)) (sub m one) in
+          if uge temp al then bitand temp bu else recurse ()
+        else if is_nonzero (bitand (bitnot au) bu |> bitand m) then
+          let temp = bitor (bitand bu (bitnot m)) (sub m one) in
+          if uge temp bl then bitand au temp else recurse ()
         else recurse ()
       in
-      let init = smin (Bitvec.size al) in
+      let init = smin (size al) in
       max_and_aux init
     in
     bitlogop min_and max_and
@@ -614,41 +608,41 @@ module WrappedIntervalsLatticeOps = struct
   let bitxor =
     let min_xor (al, au) (bl, bu) =
       let rec min_xor_aux m (al, au) (bl, bu) =
-        let recurse = min_xor_aux Bitvec.(lshr m (of_int ~size:(size m) 1)) in
-
-        if Bitvec.is_zero m then Bitvec.bitxor al bl
-        else if Bitvec.(is_nonzero (bitand (bitnot al) bl |> bitand m)) then
-          let temp = Bitvec.(bitor al m |> bitand (neg m)) in
-          let al = if Bitvec.ule temp au then Bitvec.bitor temp bl else al in
+        let recurse = min_xor_aux (lshr m (of_int ~size:(size m) 1)) in
+        let open Bitvec in
+        if is_zero m then bitxor al bl
+        else if is_nonzero (bitand (bitnot al) bl |> bitand m) then
+          let temp = bitor al m |> bitand (neg m) in
+          let al = if ule temp au then bitor temp bl else al in
           recurse (al, au) (bl, bu)
-        else if Bitvec.(is_nonzero (bitand al (bitnot bl) |> bitand m)) then
-          let temp = Bitvec.(bitor bl m |> bitand (neg m)) in
-          let bl = if Bitvec.ule temp bu then Bitvec.bitor al temp else bl in
+        else if is_nonzero (bitand al (bitnot bl) |> bitand m) then
+          let temp = bitor bl m |> bitand (neg m) in
+          let bl = if ule temp bu then bitor al temp else bl in
           recurse (al, au) (bl, bu)
         else recurse (al, au) (bl, bu)
       in
-      let init = smin (Bitvec.size al) in
+      let init = smin (size al) in
       min_xor_aux init (al, au) (bl, bu)
     in
 
     let max_xor (al, au) (bl, bu) =
       let rec max_xor_aux m (al, au) (bl, bu) =
-        let one = Bitvec.(of_int ~size:(size m) 1) in
-        let recurse = max_xor_aux Bitvec.(lshr m one) in
-
-        if Bitvec.is_zero m then Bitvec.bitxor au bu
-        else if Bitvec.(is_nonzero (bitand au bu |> bitand m)) then
-          let tempau = Bitvec.(bitor (sub au m) (sub m one)) in
-          let tempbu = Bitvec.(bitor (sub bu m) (sub m one)) in
+        let one = of_int ~size:(size m) 1 in
+        let recurse = max_xor_aux (lshr m one) in
+        let open Bitvec in
+        if is_zero m then bitxor au bu
+        else if is_nonzero (bitand au bu |> bitand m) then
+          let tempau = bitor (sub au m) (sub m one) in
+          let tempbu = bitor (sub bu m) (sub m one) in
           let au, bu =
-            if Bitvec.uge tempau al then (tempau, bu)
-            else if Bitvec.uge tempbu bl then (au, tempbu)
+            if uge tempau al then (tempau, bu)
+            else if uge tempbu bl then (au, tempbu)
             else (au, bu)
           in
           recurse (al, au) (bl, bu)
         else recurse (al, au) (bl, bu)
       in
-      let init = smin (Bitvec.size al) in
+      let init = smin (size al) in
       max_xor_aux init (al, au) (bl, bu)
     in
     bitlogop min_xor max_xor
@@ -663,12 +657,12 @@ module WrappedIntervalsLatticeOps = struct
           | Some w -> w
           | None -> failwith "Cannot truncate without known width"
         in
-        if w < k then interval (Bitvec.zero ~size:0) (Bitvec.zero ~size:0)
+        if w < k then interval (zero ~size:0) (zero ~size:0)
         else
-          let truncl = Bitvec.extract ~hi:k ~lo:0 lower in
-          let truncu = Bitvec.extract ~hi:k ~lo:0 upper in
-          let shiftl = Bitvec.(ashr lower (of_int ~size:w k)) in
-          let shiftu = Bitvec.(ashr upper (of_int ~size:w k)) in
+          let truncl = extract ~hi:k ~lo:0 lower in
+          let truncu = extract ~hi:k ~lo:0 upper in
+          let shiftl = ashr lower (of_int ~size:w k) in
+          let shiftu = ashr upper (of_int ~size:w k) in
           if
             Bitvec.(
               (equal shiftl shiftu && ule truncl truncu)
@@ -692,16 +686,15 @@ module WrappedIntervalsLatticeOps = struct
             let lower = Bitvec.zero_extend ~extension:k lower in
             let upper = Bitvec.zero_extend ~extension:k upper in
             interval
-              Bitvec.(shl lower (of_int ~size:w k))
-              Bitvec.(shl upper (of_int ~size:w k))
+              (shl lower (of_int ~size:w k))
+              (shl upper (of_int ~size:w k))
         | _ ->
-            interval (Bitvec.zero ~size:w)
-              Bitvec.(concat (ones ~size:(w - k)) (zero ~size:k))
+            interval (zero ~size:w) (concat (ones ~size:(w - k)) (zero ~size:k))
     in
     match is_singleton k with
     | Some k ->
         shl_const t
-          ( Bitvec.to_unsigned_bigint k |> fun k ->
+          ( to_unsigned_bigint k |> fun k ->
             if Z.fits_int k then Z.to_int k
             else
               match t.w with
@@ -719,22 +712,21 @@ module WrappedIntervalsLatticeOps = struct
           | None -> failwith "Cannot logical shift right without known width"
         in
         let fallback =
-          interval (Bitvec.zero ~size:w)
-            Bitvec.(concat (zero ~size:k) (ones ~size:(w - k)))
+          interval (zero ~size:w) (concat (zero ~size:k) (ones ~size:(w - k)))
         in
         if compare (sp w) t <= 0 then fallback
         else
           match t.v with
           | Interval { lower; upper } ->
               interval
-                Bitvec.(lshr lower (of_int ~size:w k))
-                Bitvec.(lshr upper (of_int ~size:w k))
+                (lshr lower (of_int ~size:w k))
+                (lshr upper (of_int ~size:w k))
           | _ -> fallback
     in
     match is_singleton k with
     | Some k ->
         lshr_const t
-          ( Bitvec.to_unsigned_bigint k |> fun k ->
+          ( to_unsigned_bigint k |> fun k ->
             if Z.fits_int k then Z.to_int k
             else
               match t.w with
@@ -755,22 +747,22 @@ module WrappedIntervalsLatticeOps = struct
         let fallback =
           let k = min k w in
           interval
-            Bitvec.(concat (ones ~size:k) (zero ~size:(w - k)))
-            Bitvec.(concat (zero ~size:k) (ones ~size:(w - k)))
+            (concat (ones ~size:k) (zero ~size:(w - k)))
+            (concat (zero ~size:k) (ones ~size:(w - k)))
         in
         if compare (np w) t <= 0 then fallback
         else
           match t.v with
           | Interval { lower; upper } ->
               interval
-                Bitvec.(ashr lower (of_int ~size:w k))
-                Bitvec.(ashr upper (of_int ~size:w k))
+                (ashr lower (of_int ~size:w k))
+                (ashr upper (of_int ~size:w k))
           | _ -> fallback
     in
     match is_singleton k with
     | Some k ->
         ashr_const t
-          ( Bitvec.to_unsigned_bigint k |> fun k ->
+          ( to_unsigned_bigint k |> fun k ->
             if Z.fits_int k then Z.to_int k
             else
               match t.w with
@@ -790,7 +782,7 @@ module WrappedIntervalsLatticeOps = struct
         | Some w -> w
         | None -> failwith "Cannot extract without known width"
       in
-      let k = Bitvec.of_int ~size:w lo in
+      let k = of_int ~size:w lo in
       assert (hi <= w);
       truncate (lshr t (interval k k)) (hi - lo)
 
@@ -808,20 +800,16 @@ module WrappedIntervalsLatticeOps = struct
         { w = Option.bind s.w (fun u -> Option.map (Int.add u) t.w); v = Top }
     | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
       ->
-        interval (Bitvec.concat al bl) (Bitvec.concat au bu)
+        interval (concat al bl) (concat au bu)
     | Interval { lower = al; upper = au }, Top ->
-        interval
-          Bitvec.(concat al (zero ~size:tw))
-          Bitvec.(concat au (ones ~size:tw))
+        interval (concat al (zero ~size:tw)) (concat au (ones ~size:tw))
     | Top, Interval { lower = bl; upper = bu } ->
         let sw =
           match s.w with
           | Some w -> w
           | None -> failwith "Cannot concat without known width"
         in
-        interval
-          Bitvec.(concat (zero ~size:sw) bl)
-          Bitvec.(concat (ones ~size:sw) bu)
+        interval (concat (zero ~size:sw) bl) (concat (ones ~size:sw) bu)
 end
 
 module WrappedIntervalsValueAbstraction = struct
@@ -832,7 +820,7 @@ module WrappedIntervalsValueAbstraction = struct
     | `Bool _ -> { w = Some 1; v = Top }
     | `Integer _ -> { w = Some 0; v = Top }
     | `Bitvector bv ->
-        if Bitvec.size bv = 0 then { w = Some 0; v = Top } else interval bv bv
+        if size bv = 0 then { w = Some 0; v = Top } else interval bv bv
 
   let eval_unop (op : Lang.Ops.AllOps.unary) a =
     match op with

From b42007227d4d1c9271a504e883d128cf0b2f2bca Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 4 Feb 2026 14:26:48 +1000
Subject: [PATCH 31/36] Docs and light clean up

---
 lib/analysis/wrapped_intervals.ml | 50 ++++++++++++++++++++++++-------
 1 file changed, 39 insertions(+), 11 deletions(-)

diff --git a/lib/analysis/wrapped_intervals.ml b/lib/analysis/wrapped_intervals.ml
index 7a16de4..d4b6959 100644
--- a/lib/analysis/wrapped_intervals.ml
+++ b/lib/analysis/wrapped_intervals.ml
@@ -1,3 +1,22 @@
+(** Wrapped Intervals model a range of values on a circle, allowing both
+    unsigned and signed interpretation whilst maintaining precision in
+    intermediate steps.
+
+    Based on the APLAS12 paper "Signedness-Agnostic Program Analysis: Precise
+    Integer Bounds for Low-Level Code" by Navas, Schachte, Søndergaard, and
+    Stuckey (doi: 10.1007/978-3-642-35182-2_9).
+
+    Implementation in the Crab Static Analyser used as a general reference and
+    for the unsigned and signed division functions.
+    https://github.com/seahorn/crab/blob/418b63c66b91f04bf36ae59d5eecb936c48836ee/include/crab/domains/wrapped_interval_impl.hpp
+
+    Algorithms for bitwise operations on unsigned intervals used for building
+    signedness agnostic versions were adapted from Chapter 4.3 of Hacker's
+    Delight (Second Edition) by Henry S. Warren.
+
+    Further details about implementation can be found in
+    docs/dev/wrapped_intervals.pdf *)
+
 open Bincaml_util.Common
 open Bitvec
 
@@ -32,14 +51,16 @@ module WrappedIntervalsLattice = struct
          else Interval { lower; upper });
     }
 
-  let infer { w = w1; v = a } { w = w2; v = b } =
-    match (w1, w2) with
-    | Some w1, Some w2 ->
-        (* assert (w1 = w2); *)
-        ({ w = Some w1; v = a }, { w = Some w2; v = b })
-    | Some w1, None -> ({ w = Some w1; v = a }, { w = Some w1; v = b })
-    | None, Some w2 -> ({ w = Some w2; v = a }, { w = Some w2; v = b })
-    | None, None -> ({ w = None; v = a }, { w = None; v = b })
+  let infer a b =
+    let w =
+      match (a.w, b.w) with
+      | Some a, Some b ->
+          assert (a = b);
+          Some a
+      | Some a, None | None, Some a -> Some a
+      | None, None -> None
+    in
+    ({ a with w }, { b with w })
 
   let umin width = zero ~size:width
   let umax width = ones ~size:width
@@ -151,8 +172,11 @@ module WrappedIntervalsLattice = struct
           complement (interval bl au)
       | _, _ -> infer a bottom |> snd
     in
-    (* APLAS12 mentions "last cases are omitted", does not specify which cases. *)
-    let extend a b = join a b in
+    (*
+      Paper mentions last cases of join are omitted for extend, but does not specify which cases.
+      In practice, just using join as is works.
+    *)
+    let extend = join in
     let sorted =
       List.sort
         (fun s t ->
@@ -433,7 +457,11 @@ module WrappedIntervalsLatticeOps = struct
             (cut s))
     |> snd
 
-  (* Division implementation derived from Crab *)
+  (* 
+    Division implementation derived from Crab
+    https://github.com/seahorn/crab/blob/418b63c66b91f04bf36ae59d5eecb936c48836ee/include/crab/domains/wrapped_interval_impl.hpp#L1034-L1091
+    https://github.com/seahorn/crab/blob/418b63c66b91f04bf36ae59d5eecb936c48836ee/include/crab/domains/wrapped_interval_impl.hpp#L210-L297
+  *)
   let trim_zeroes t =
     let w =
       match t.w with

From 149205d61a076c55e108b230f7ff791a1240b7bb Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Wed, 4 Feb 2026 14:29:06 +1000
Subject: [PATCH 32/36] Fix typecheck tests failing locally

---
 test/cram/typefail.t | 2 +-
 test/cram/typepass.t | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/cram/typefail.t b/test/cram/typefail.t
index fd344e2..6dfb6f9 100644
--- a/test/cram/typefail.t
+++ b/test/cram/typefail.t
@@ -1,4 +1,4 @@
-  $ dune exec bincaml script ./typefail.sexp 2>/dev/null
+  $ ../../bin/main.exe script ./typefail.sexp 2>/dev/null
   Arguments are not of the same type in eq at statement 0 in %main_entry
   Arguments are not of the same type in neq at statement 1 in %main_entry
   Arguments are not of the same type in eq at statement 2 in %main_entry
diff --git a/test/cram/typepass.t b/test/cram/typepass.t
index 47441b4..515e3b6 100644
--- a/test/cram/typepass.t
+++ b/test/cram/typepass.t
@@ -1 +1 @@
-  $ dune exec bincaml script ./typepass.sexp
+  $ ../../bin/main.exe script ./typepass.sexp

From 136cf0661d680d9572bdc2313127da6d5eadc879 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Thu, 5 Feb 2026 11:47:06 +1000
Subject: [PATCH 33/36] Add demo to passes list

---
 lib/passes.ml | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/lib/passes.ml b/lib/passes.ml
index 1864e96..eb64843 100644
--- a/lib/passes.ml
+++ b/lib/passes.ml
@@ -50,6 +50,14 @@ module PassManager = struct
       doc = "runs truthiness analysis on dataflow graph and prints results";
     }
 
+  let dfg_wrapped_int =
+    {
+      name = "demo-dfg-wrapped-int-analysis";
+      apply = DFGAnalysis (module Analysis.Wrapped_intervals.Analysis);
+      doc =
+        "Runs wrapped interval analysis on dataflow graph and prints results";
+    }
+
   let remove_unused =
     {
       name = "remove-unused-decls";
@@ -87,6 +95,7 @@ module PassManager = struct
   let passes =
     [
       dfg_bool;
+      dfg_wrapped_int;
       sparams;
       read_uninit false;
       read_uninit true;

From ff4e3d23df209366a069dac8bb3f61737934f696 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Fri, 6 Feb 2026 09:35:56 +1000
Subject: [PATCH 34/36] Propagate unknown widths (if unable to infer)

---
 lib/analysis/wrapped_intervals.ml | 95 +++++++++++++++++--------------
 1 file changed, 51 insertions(+), 44 deletions(-)

diff --git a/lib/analysis/wrapped_intervals.ml b/lib/analysis/wrapped_intervals.ml
index d4b6959..b3995bf 100644
--- a/lib/analysis/wrapped_intervals.ml
+++ b/lib/analysis/wrapped_intervals.ml
@@ -815,29 +815,32 @@ module WrappedIntervalsLatticeOps = struct
       truncate (lshr t (interval k k)) (hi - lo)
 
   let concat s t =
-    let tw =
-      match t.w with
-      | Some w -> w
-      | None -> failwith "Cannot concat without known width"
-    in
-    let t = if compare (sp tw) t <= 0 then { w = t.w; v = Top } else t in
-    match (s.v, t.v) with
-    | Bot, _ | _, Bot ->
-        { w = Option.bind s.w (fun u -> Option.map (Int.add u) t.w); v = Bot }
-    | Top, Top ->
-        { w = Option.bind s.w (fun u -> Option.map (Int.add u) t.w); v = Top }
-    | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
-      ->
-        interval (concat al bl) (concat au bu)
-    | Interval { lower = al; upper = au }, Top ->
-        interval (concat al (zero ~size:tw)) (concat au (ones ~size:tw))
-    | Top, Interval { lower = bl; upper = bu } ->
-        let sw =
-          match s.w with
-          | Some w -> w
-          | None -> failwith "Cannot concat without known width"
-        in
-        interval (concat (zero ~size:sw) bl) (concat (ones ~size:sw) bu)
+    match t.w with
+    | None -> top
+    | Some tw -> (
+        let t = if compare (sp tw) t <= 0 then { w = t.w; v = Top } else t in
+        match (s.v, t.v) with
+        | Bot, _ | _, Bot ->
+            {
+              w = Option.bind s.w (fun u -> Option.map (Int.add u) t.w);
+              v = Bot;
+            }
+        | Top, Top ->
+            {
+              w = Option.bind s.w (fun u -> Option.map (Int.add u) t.w);
+              v = Top;
+            }
+        | ( Interval { lower = al; upper = au },
+            Interval { lower = bl; upper = bu } ) ->
+            interval (concat al bl) (concat au bu)
+        | Interval { lower = al; upper = au }, Top ->
+            interval (concat al (zero ~size:tw)) (concat au (ones ~size:tw))
+        | Top, Interval { lower = bl; upper = bu } -> (
+            match s.w with
+            | None -> top
+            | Some sw ->
+                interval (concat (zero ~size:sw) bl) (concat (ones ~size:sw) bu)
+            ))
 end
 
 module WrappedIntervalsValueAbstraction = struct
@@ -851,30 +854,34 @@ module WrappedIntervalsValueAbstraction = struct
         if size bv = 0 then { w = Some 0; v = Top } else interval bv bv
 
   let eval_unop (op : Lang.Ops.AllOps.unary) a =
-    match op with
-    | `BVNEG -> neg a
-    | `BVNOT -> bitnot a
-    | `ZeroExtend k -> zero_extend a k
-    | `SignExtend k -> sign_extend a k
-    | `Extract (hi, lo) -> extract ~hi ~lo a
-    | _ -> infer a top |> snd
+    if Option.is_none a.w then top
+    else
+      match op with
+      | `BVNEG -> neg a
+      | `BVNOT -> bitnot a
+      | `ZeroExtend k -> zero_extend a k
+      | `SignExtend k -> sign_extend a k
+      | `Extract (hi, lo) -> extract ~hi ~lo a
+      | _ -> infer a top |> snd
 
   let eval_binop (op : Lang.Ops.AllOps.binary) a b =
     let a, b = infer a b in
-    match op with
-    | `BVADD -> add a b
-    | `BVSUB -> sub a b
-    | `BVMUL -> mul a b
-    | `BVUDIV -> udiv a b
-    | `BVSDIV -> sdiv a b
-    | `BVOR -> bitor a b
-    | `BVAND -> bitand a b
-    | `BVNAND -> bitand a b |> bitnot
-    | `BVXOR -> bitxor a b
-    | `BVASHR -> ashr a b
-    | `BVLSHR -> lshr a b
-    | `BVSHL -> shl a b
-    | _ -> infer a top |> snd
+    if Option.is_none a.w then top
+    else
+      match op with
+      | `BVADD -> add a b
+      | `BVSUB -> sub a b
+      | `BVMUL -> mul a b
+      | `BVUDIV -> udiv a b
+      | `BVSDIV -> sdiv a b
+      | `BVOR -> bitor a b
+      | `BVAND -> bitand a b
+      | `BVNAND -> bitand a b |> bitnot
+      | `BVXOR -> bitxor a b
+      | `BVASHR -> ashr a b
+      | `BVLSHR -> lshr a b
+      | `BVSHL -> shl a b
+      | _ -> infer a top |> snd
 
   let eval_intrin (op : Lang.Ops.AllOps.intrin) args =
     let op =

From b602c1a608a9c00f1a6a872668f3805872a86d48 Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Fri, 6 Feb 2026 11:05:38 +1000
Subject: [PATCH 35/36] Implement proper widening

---
 lib/analysis/wrapped_intervals.ml | 50 +++++++++++++++++++++++++++----
 1 file changed, 44 insertions(+), 6 deletions(-)

diff --git a/lib/analysis/wrapped_intervals.ml b/lib/analysis/wrapped_intervals.ml
index b3995bf..a6b1acf 100644
--- a/lib/analysis/wrapped_intervals.ml
+++ b/lib/analysis/wrapped_intervals.ml
@@ -208,8 +208,8 @@ module WrappedIntervalsLattice = struct
     match (a, b) with
     | _, Bot -> s
     | Bot, _ -> t
-    | _, Top -> s
-    | Top, _ -> t
+    | _, Top -> t
+    | Top, _ -> s
     | Interval { lower = al; upper = au }, Interval { lower = bl; upper = bu }
       ->
         size_is_equal al bl;
@@ -902,12 +902,50 @@ module WrappedIntervalsValueAbstraction = struct
     | None -> { w = Some 0; v = Top }
 end
 
-module StateAbstraction = Intra_analysis.MapState (WrappedIntervalsLattice)
-
 module WrappedIntervalsValueAbstractionBasil = struct
   include WrappedIntervalsValueAbstraction
   module E = Lang.Expr.BasilExpr
 end
 
-include
-  Dataflow_graph.EasyForwardAnalysisPack (WrappedIntervalsValueAbstractionBasil)
+module StateAbstraction =
+  Intra_analysis.MapState (WrappedIntervalsValueAbstractionBasil)
+
+module Eval =
+  Intra_analysis.EvalStmt
+    (WrappedIntervalsValueAbstractionBasil)
+    (StateAbstraction)
+
+module Domain = struct
+  include StateAbstraction
+
+  let top_val = WrappedIntervalsLattice.top
+
+  let init p =
+    let vs = Lang.Procedure.formal_in_params p |> StringMap.values in
+    vs
+    |> Iter.map (fun v -> (v, top_val))
+    |> Iter.fold (fun m (v, d) -> update v d m) bottom
+
+  let transfer dom stmt =
+    let stmt = Eval.stmt_eval_fwd stmt dom in
+    let updates =
+      match stmt with
+      | Lang.Stmt.Instr_Assign ls -> List.to_iter ls
+      | Lang.Stmt.Instr_Assert _ -> Iter.empty
+      | Lang.Stmt.Instr_Assume _ -> Iter.empty
+      | Lang.Stmt.Instr_Load { lhs } -> Iter.singleton (lhs, top_val)
+      | Lang.Stmt.Instr_Store { lhs } -> Iter.singleton (lhs, top_val)
+      | Lang.Stmt.Instr_IntrinCall { lhs } ->
+          StringMap.values lhs |> Iter.map (fun v -> (v, top_val))
+      | Lang.Stmt.Instr_Call { lhs } ->
+          StringMap.values lhs |> Iter.map (fun v -> (v, top_val))
+      | Lang.Stmt.Instr_IndirectCall _ -> Iter.empty
+    in
+    Iter.fold (fun a (k, v) -> update k v a) dom updates
+end
+
+module Analysis = Dataflow_graph.AnalysisFwd (Domain)
+
+let analyse (p : Lang.Program.proc) =
+  let g = Dataflow_graph.create p in
+  Analysis.analyse ~widen_set:Graph.ChaoticIteration.FromWto ~delay_widen:50 g

From 92c2ab019607e5a4e5ddd210b1c8e942563608ae Mon Sep 17 00:00:00 2001
From: Hayden Brown <hayden@foxhaven.dev>
Date: Fri, 6 Feb 2026 15:52:57 +1000
Subject: [PATCH 36/36] Implement proper widening (REAL, not clickbait)

---
 lib/analysis/intra_analysis.ml    | 2 +-
 lib/analysis/wrapped_intervals.ml | 1 +
 lib/passes.ml                     | 5 ++---
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/analysis/intra_analysis.ml b/lib/analysis/intra_analysis.ml
index d666f3c..24665d9 100644
--- a/lib/analysis/intra_analysis.ml
+++ b/lib/analysis/intra_analysis.ml
@@ -130,7 +130,7 @@ module MapState (V : Lattice) = struct
       let to_iter m = Iter.from_iter (fun f -> M.iter (fun k v -> f (k, v)) m)
       let read (v : Var.t) m = M.find_opt v m |> Option.get_or ~default:V.bottom
       let update k v m = M.add k v m
-      let widening a b = join a b
+      let widening a b = M.idempotent_union (fun v a b -> V.widening a b) a b
 
       type val_t = V.t
       type key_t = Var.t
diff --git a/lib/analysis/wrapped_intervals.ml b/lib/analysis/wrapped_intervals.ml
index a6b1acf..e52e387 100644
--- a/lib/analysis/wrapped_intervals.ml
+++ b/lib/analysis/wrapped_intervals.ml
@@ -862,6 +862,7 @@ module WrappedIntervalsValueAbstraction = struct
       | `ZeroExtend k -> zero_extend a k
       | `SignExtend k -> sign_extend a k
       | `Extract (hi, lo) -> extract ~hi ~lo a
+      | `BOOLTOBV1 -> { w = Some 1; v = Top }
       | _ -> infer a top |> snd
 
   let eval_binop (op : Lang.Ops.AllOps.binary) a b =
diff --git a/lib/passes.ml b/lib/passes.ml
index eb64843..74966eb 100644
--- a/lib/passes.ml
+++ b/lib/passes.ml
@@ -171,9 +171,8 @@ module PassManager = struct
         |> Iter.iter (fun (pn, p) ->
             let g = Analysis.Dataflow_graph.create p in
             let r =
-              D.analyse
-                ~widen_set:(Graph.ChaoticIteration.Predicate (fun _ -> false))
-                ~delay_widen:0 g
+              D.analyse ~widen_set:Graph.ChaoticIteration.FromWto
+                ~delay_widen:10 g
             in
             print_endline (D.D.name ^ " :: " ^ ID.to_string pn);
             print_endline