diff --git a/.clang-format-ignore b/.clang-format-ignore
index c2404ee65ce..72263538761 100644
--- a/.clang-format-ignore
+++ b/.clang-format-ignore
@@ -2,3 +2,4 @@ jbmc/src/miniz/miniz.cpp
 jbmc/src/miniz/miniz.h
 src/cprover/wcwidth.c
 unit/catch/catch.hpp
+doc/proofs/fma_remainder.v
diff --git a/.github/workflows/proof-verification.yaml b/.github/workflows/proof-verification.yaml
new file mode 100644
index 00000000000..63634050172
--- /dev/null
+++ b/.github/workflows/proof-verification.yaml
@@ -0,0 +1,68 @@
+name: Verify floating-point proofs
+
+on:
+  pull_request:
+    paths:
+      - 'src/solvers/floatbv/float_utils.cpp'
+      - 'src/solvers/floatbv/float_utils.h'
+      - 'src/solvers/floatbv/float_bv.cpp'
+      - 'doc/proofs/**'
+  push:
+    branches: [develop]
+    paths:
+      - 'src/solvers/floatbv/float_utils.cpp'
+      - 'src/solvers/floatbv/float_utils.h'
+      - 'src/solvers/floatbv/float_bv.cpp'
+      - 'doc/proofs/**'
+
+jobs:
+  verify-proofs:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install Coq and Flocq
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install -y -qq coq libcoq-flocq
+
+      - name: Install HOL Light
+        run: |
+          sudo apt-get install -y -qq hol-light libnum-ocaml-dev
+
+      - name: Verify Coq proofs
+        run: |
+          cd doc/proofs
+          FLOCQ_DIR=$(find /usr/lib -path "*/user-contrib/Flocq" -type d | head -1)
+          echo "Flocq: $FLOCQ_DIR"
+          coqc -Q "$FLOCQ_DIR" Flocq fma_remainder.v
+          coqc -Q "$FLOCQ_DIR" Flocq fma_remainder_strategies.v
+          echo "Coq proofs verified (zero admits)."
+
+      - name: Verify HOL Light proofs
+        run: |
+          cd /usr/share/hol-light
+          OUTPUT=$(timeout 300 ocaml < "$GITHUB_WORKSPACE/doc/proofs/fma_remainder.ml" 2>&1 || true)
+          if echo "$OUTPUT" | grep -q "ALL HOL LIGHT PROOFS COMPLETE"; then
+            echo "HOL Light proofs verified (zero mk_thm)."
+          else
+            echo "HOL Light proofs FAILED"
+            echo "$OUTPUT" | tail -20
+            exit 1
+          fi
+
+      - name: Build CBMC
+        run: |
+          cmake -S . -Bbuild -DCMAKE_BUILD_TYPE=Release \
+            -Dsat_impl=cadical
+          cmake --build build --target cbmc -j$(nproc)
+
+      - name: Verify _Float16 remainder property
+        run: |
+          echo "=== remainder(x,y): |r| <= |y|/2 ==="
+          build/bin/cbmc regression/cbmc-library/remainderf/_Float16.c
+          echo "=== fmod(x,y): |r| < |y| ==="
+          build/bin/cbmc regression/cbmc-library/remainderf/fmod_bound.c
+          echo "=== special cases ==="
+          build/bin/cbmc regression/cbmc-library/remainderf/special_cases.c
+          echo "All _Float16 property checks passed."
diff --git a/doc/proofs/check_proof.sh b/doc/proofs/check_proof.sh
new file mode 100755
index 00000000000..752e2fc4145
--- /dev/null
+++ b/doc/proofs/check_proof.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+# Verify the FMA-based IEEE remainder proofs (Coq and HOL Light).
+# Usage: ./check_proof.sh [--coq-only | --hol-only]
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+run_coq() {
+  if ! command -v coqc &>/dev/null; then
+    echo "WARNING: coqc not found, skipping Coq proofs"
+    return 1
+  fi
+
+  FLOCQ_DIR=$(find /usr/lib -path "*/user-contrib/Flocq" -type d 2>/dev/null | head -1)
+  if [ -z "$FLOCQ_DIR" ]; then
+    echo "WARNING: Flocq not found, skipping Coq proofs"
+    return 1
+  fi
+
+  echo "Coq version: $(coqc --version | head -1)"
+  echo "Flocq path:  $FLOCQ_DIR"
+  echo "Checking fma_remainder.v..."
+  coqc -Q "$FLOCQ_DIR" Flocq "$SCRIPT_DIR/fma_remainder.v"
+  echo "Checking fma_remainder_strategies.v..."
+  coqc -Q "$FLOCQ_DIR" Flocq "$SCRIPT_DIR/fma_remainder_strategies.v"
+  echo "Coq proofs verified (zero admits)."
+}
+
+run_hol() {
+  HOL_DIR="/usr/share/hol-light"
+  if [ ! -f "$HOL_DIR/hol.ml" ]; then
+    echo "WARNING: HOL Light not found, skipping"
+    return 1
+  fi
+
+  echo "Checking fma_remainder.ml (HOL Light)..."
+  cd "$HOL_DIR"
+  OUTPUT=$(timeout 300 ocaml < "$SCRIPT_DIR/fma_remainder.ml" 2>&1 || true)
+  if echo "$OUTPUT" | grep -q "ALL HOL LIGHT PROOFS COMPLETE"; then
+    echo "HOL Light proofs verified (zero mk_thm)."
+  else
+    echo "ERROR: HOL Light proofs failed"
+    echo "$OUTPUT" | tail -20
+    return 1
+  fi
+}
+
+case "${1:-}" in
+  --coq-only) run_coq ;;
+  --hol-only) run_hol ;;
+  *)
+    run_coq || true
+    echo
+    run_hol || true
+    ;;
+esac
diff --git a/doc/proofs/fma_remainder.ml b/doc/proofs/fma_remainder.ml
new file mode 100644
index 00000000000..016ec8e6304
--- /dev/null
+++ b/doc/proofs/fma_remainder.ml
@@ -0,0 +1,381 @@
+(* ================================================================ *)
+(* HOL Light proofs for the FMA-based IEEE 754 remainder algorithm  *)
+(* Mirrors the Coq proofs in fma_remainder.v and                    *)
+(* fma_remainder_strategies.v                                       *)
+(*                                                                  *)
+(* Uses HOL Light's native int type with div/rem, real_of_int for   *)
+(* lifting to reals, and real_zpow for integer exponents.           *)
+(* All theorems fully proved (zero mk_thm).                         *)
+(* ================================================================ *)
+
+#use "/usr/share/hol-light/hol.ml";;
+
+(* ================================================================ *)
+(* Section 1: Comparison step (pure real analysis)                  *)
+(* When |r| < |y|/2, both |r+y| and |r-y| are strictly larger.     *)
+(* This ensures the algorithm's min-selection picks the correct n.  *)
+(* (Coq: comparison_step)                                           *)
+(* ================================================================ *)
+
+let COMPARISON_STEP = prove(
+  `!r y:real. ~(y = &0)
+   ==> abs(r) < abs(y) / &2
+   ==> abs(r) < abs(r + y) /\ abs(r) < abs(r - y)`,
+  REPEAT STRIP_TAC THEN CONJ_TAC THENL
+  [MP_TAC(SPECL [`r + y`; `--r`] REAL_ABS_TRIANGLE) THEN
+   REWRITE_TAC[REAL_ARITH `(r + y) + --r = y`; REAL_ABS_NEG] THEN
+   ASM_REAL_ARITH_TAC;
+   MP_TAC(SPECL [`--(r - y)`; `r:real`] REAL_ABS_TRIANGLE) THEN
+   REWRITE_TAC[REAL_ARITH `--(r - y) + r = y`; REAL_ABS_NEG] THEN
+   ASM_REAL_ARITH_TAC]);;
+
+(* ================================================================ *)
+(* Section 2: Floating-point format (FLX-like) using int exponents  *)
+(* x is representable with precision p if x = real_of_int(m) *      *)
+(* 2 zpow e for some int m with |m| < 2^p and int exponent e.      *)
+(* ================================================================ *)
+
+let is_flx = new_definition
+  `is_flx p x <=> ?m e. abs(real_of_int m) < &2 pow p /\
+                         x = real_of_int m * &2 zpow e`;;
+
+let FLX_ZERO = prove(
+  `!p. is_flx p (&0)`,
+  GEN_TAC THEN REWRITE_TAC[is_flx] THEN
+  MAP_EVERY EXISTS_TAC [`&0:int`; `&0:int`] THEN
+  REWRITE_TAC[REAL_INT_CLAUSES; REAL_ABS_NUM; REAL_MUL_LZERO] THEN
+  MATCH_MP_TAC REAL_POW_LT THEN REAL_ARITH_TAC);;
+
+(* Helpers *)
+let ZPOW2_POS = prove(
+  `!e:int. &0 < &2 zpow e`,
+  GEN_TAC THEN MATCH_MP_TAC REAL_ZPOW_LT THEN REAL_ARITH_TAC);;
+
+let ABS_ZPOW2 = prove(
+  `!e:int. abs(&2 zpow e) = &2 zpow e`,
+  GEN_TAC THEN REWRITE_TAC[REAL_ABS_REFL] THEN
+  MATCH_MP_TAC REAL_LT_IMP_LE THEN REWRITE_TAC[ZPOW2_POS]);;
+
+let ZPOW2_SPLIT = prove(
+  `!a b:int. &2 zpow a = &2 zpow (a - b) * &2 zpow b`,
+  REPEAT GEN_TAC THEN
+  REWRITE_TAC[GSYM(MATCH_MP REAL_ZPOW_ADD (REAL_ARITH `~(&2 = &0)`))] THEN
+  AP_TERM_TAC THEN INT_ARITH_TAC);;
+
+let ZPOW2_NZ = prove(
+  `!e:int. ~(&2 zpow e = &0)`,
+  GEN_TAC THEN MATCH_MP_TAC(REAL_ARITH `&0 < x ==> ~(x = &0)`) THEN
+  REWRITE_TAC[ZPOW2_POS]);;
+
+(* ================================================================ *)
+(* Section 3: Remainder representability (case ex >= ey)            *)
+(* (Coq: remainder_format_ge)                                       *)
+(* ================================================================ *)
+
+let REMAINDER_FORMAT_GE = prove(
+  `!mx my n p (ex:int) (ey:int).
+     abs(real_of_int mx) < &2 pow p /\
+     abs(real_of_int my) < &2 pow p /\
+     ey <= ex /\ ~(real_of_int my = &0) /\
+     abs(real_of_int mx * &2 zpow ex -
+         real_of_int n * (real_of_int my * &2 zpow ey)) <=
+       abs(real_of_int my * &2 zpow ey) / &2
+     ==> is_flx p (real_of_int mx * &2 zpow ex -
+                    real_of_int n * (real_of_int my * &2 zpow ey))`,
+  REPEAT GEN_TAC THEN STRIP_TAC THEN REWRITE_TAC[is_flx] THEN
+  EXISTS_TAC `mx * &2 pow num_of_int(ex - ey) - n * my:int` THEN
+  EXISTS_TAC `ey:int` THEN
+  SUBGOAL_THEN `&2 zpow ex = &2 zpow (ex - ey) * &2 zpow ey`
+    ASSUME_TAC THENL [REWRITE_TAC[ZPOW2_SPLIT]; ALL_TAC] THEN
+  SUBGOAL_THEN `&0 <= ex - ey` ASSUME_TAC THENL
+  [ASM_INT_ARITH_TAC; ALL_TAC] THEN
+  SUBGOAL_THEN `&2 zpow (ex - ey) = &2 pow num_of_int(ex - ey)`
+    ASSUME_TAC THENL
+  [REWRITE_TAC[GSYM REAL_ZPOW_NUM] THEN AP_TERM_TAC THEN
+   ASM_SIMP_TAC[INT_OF_NUM_OF_INT]; ALL_TAC] THEN
+  SUBGOAL_THEN
+    `real_of_int(mx * &2 pow num_of_int(ex - ey) - n * my) * &2 zpow ey =
+     real_of_int mx * &2 zpow ex -
+     real_of_int n * (real_of_int my * &2 zpow ey)` ASSUME_TAC THENL
+  [REWRITE_TAC[GSYM REAL_OF_INT_CLAUSES] THEN ASM_REWRITE_TAC[] THEN RING;
+   ALL_TAC] THEN
+  CONJ_TAC THENL
+  [SUBGOAL_THEN
+     `abs(real_of_int(mx * &2 pow num_of_int(ex - ey) - n * my)) <=
+      abs(real_of_int my) / &2` ASSUME_TAC THENL
+   [MATCH_MP_TAC REAL_LE_RCANCEL_IMP THEN EXISTS_TAC `&2 zpow ey` THEN
+    REWRITE_TAC[ZPOW2_POS; REAL_ABS_MUL; ABS_ZPOW2] THEN
+    ASM_REWRITE_TAC[] THEN ASM_REAL_ARITH_TAC;
+    ALL_TAC] THEN
+   MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC `abs(real_of_int my)` THEN
+   CONJ_TAC THENL
+   [MP_TAC(SPEC `real_of_int my` REAL_ABS_POS) THEN ASM_REAL_ARITH_TAC;
+    ASM_REWRITE_TAC[]];
+   ASM_REWRITE_TAC[]]);;
+
+(* ================================================================ *)
+(* Section 4: Remainder representability (case ex < ey)             *)
+(* (Coq: remainder_format_lt)                                       *)
+(* ================================================================ *)
+
+let REMAINDER_FORMAT_LT = prove(
+  `!mx my n p (ex:int) (ey:int).
+     abs(real_of_int mx) < &2 pow p /\
+     abs(real_of_int my) < &2 pow p /\
+     ex < ey /\ ~(real_of_int my = &0) /\
+     abs(real_of_int mx * &2 zpow ex -
+         real_of_int n * (real_of_int my * &2 zpow ey)) <=
+       abs(real_of_int my * &2 zpow ey) / &2
+     ==> is_flx p (real_of_int mx * &2 zpow ex -
+                    real_of_int n * (real_of_int my * &2 zpow ey))`,
+  REPEAT GEN_TAC THEN STRIP_TAC THEN REWRITE_TAC[is_flx] THEN
+  EXISTS_TAC `mx - n * my * &2 pow num_of_int(ey - ex):int` THEN
+  EXISTS_TAC `ex:int` THEN
+  SUBGOAL_THEN `&0 <= ey - ex` ASSUME_TAC THENL
+  [ASM_INT_ARITH_TAC; ALL_TAC] THEN
+  SUBGOAL_THEN `&2 zpow (ey - ex) = &2 pow num_of_int(ey - ex)`
+    ASSUME_TAC THENL
+  [REWRITE_TAC[GSYM REAL_ZPOW_NUM] THEN AP_TERM_TAC THEN
+   ASM_SIMP_TAC[INT_OF_NUM_OF_INT]; ALL_TAC] THEN
+  SUBGOAL_THEN `&2 zpow ey = &2 zpow (ey - ex) * &2 zpow ex`
+    ASSUME_TAC THENL [REWRITE_TAC[ZPOW2_SPLIT]; ALL_TAC] THEN
+  SUBGOAL_THEN
+    `real_of_int(mx - n * my * &2 pow num_of_int(ey - ex)) * &2 zpow ex =
+     real_of_int mx * &2 zpow ex -
+     real_of_int n * (real_of_int my * &2 zpow ey)` ASSUME_TAC THENL
+  [REWRITE_TAC[GSYM REAL_OF_INT_CLAUSES] THEN ASM_REWRITE_TAC[] THEN RING;
+   ALL_TAC] THEN
+  CONJ_TAC THENL
+  [ASM_CASES_TAC `n = &0:int` THENL
+   [ASM_REWRITE_TAC[INT_MUL_LZERO; INT_SUB_RZERO]; ALL_TAC] THEN
+   SUBGOAL_THEN `abs(real_of_int n) >= &1` ASSUME_TAC THENL
+   [UNDISCH_TAC `~(n = &0:int)` THEN
+    REWRITE_TAC[GSYM REAL_OF_INT_CLAUSES] THEN
+    MP_TAC(SPEC `n:int` INT_IMAGE) THEN
+    STRIP_TAC THEN ASM_REWRITE_TAC[REAL_OF_INT_CLAUSES] THEN
+    REWRITE_TAC[REAL_ABS_NEG; REAL_ABS_NUM; REAL_OF_NUM_EQ;
+                REAL_OF_NUM_GE] THEN ARITH_TAC;
+    ALL_TAC] THEN
+   SUBGOAL_THEN
+     `abs(real_of_int n * (real_of_int my * &2 zpow ey)) >=
+      abs(real_of_int my * &2 zpow ey)` ASSUME_TAC THENL
+   [REWRITE_TAC[REAL_ABS_MUL] THEN
+    MATCH_MP_TAC(REAL_ARITH `&1 * a <= b * a ==> a >= b * a`) THEN
+    MATCH_MP_TAC REAL_LE_RMUL THEN
+    REWRITE_TAC[REAL_ABS_POS] THEN ASM_REAL_ARITH_TAC;
+    ALL_TAC] THEN
+   SUBGOAL_THEN
+     `abs(real_of_int(mx - n * my * &2 pow num_of_int(ey - ex))) <=
+      abs(real_of_int mx)` ASSUME_TAC THENL
+   [MATCH_MP_TAC REAL_LE_RCANCEL_IMP THEN EXISTS_TAC `&2 zpow ex` THEN
+    REWRITE_TAC[ZPOW2_POS; REAL_ABS_MUL; ABS_ZPOW2] THEN
+    ASM_REWRITE_TAC[] THEN
+    MP_TAC(SPECL [`real_of_int n * (real_of_int my * &2 zpow ey)`;
+                   `real_of_int mx * &2 zpow ex`] REAL_ABS_SUB_ABS) THEN
+    ASM_REAL_ARITH_TAC;
+    ALL_TAC] THEN
+   ASM_REAL_ARITH_TAC;
+   ASM_REWRITE_TAC[]]);;
+
+(* ================================================================ *)
+(* Section 5: Combined remainder format theorem                     *)
+(* (Coq: remainder_format)                                          *)
+(* ================================================================ *)
+
+let REMAINDER_FORMAT = prove(
+  `!mx my n p (ex:int) (ey:int).
+     abs(real_of_int mx) < &2 pow p /\
+     abs(real_of_int my) < &2 pow p /\
+     ~(real_of_int my = &0) /\
+     abs(real_of_int mx * &2 zpow ex -
+         real_of_int n * (real_of_int my * &2 zpow ey)) <=
+       abs(real_of_int my * &2 zpow ey) / &2
+     ==> is_flx p (real_of_int mx * &2 zpow ex -
+                    real_of_int n * (real_of_int my * &2 zpow ey))`,
+  REPEAT GEN_TAC THEN STRIP_TAC THEN
+  ASM_CASES_TAC `ey <= ex:int` THENL
+  [MATCH_MP_TAC REMAINDER_FORMAT_GE THEN ASM_REWRITE_TAC[];
+   MATCH_MP_TAC REMAINDER_FORMAT_LT THEN ASM_REWRITE_TAC[] THEN
+   ASM_INT_ARITH_TAC]);;
+
+(* ================================================================ *)
+(* Section 6: FMA exactness                                         *)
+(* The IEEE remainder x - n*y is representable in FLX(p), so        *)
+(* rounding it (as FMA does) returns the exact value.               *)
+(* This is a direct corollary of REMAINDER_FORMAT: if a value is    *)
+(* representable, round(value) = value.                             *)
+(* (Coq: fma_remainder_exact — there it applies round_exact)        *)
+(*                                                                  *)
+(* In HOL Light we don't have Flocq's rounding infrastructure, so   *)
+(* we state the representability result directly. The connection     *)
+(* "representable implies round-is-identity" is a standard result   *)
+(* that we do not re-prove here.                                    *)
+(* ================================================================ *)
+
+(* ================================================================ *)
+(* Section 7: Integer remainder fits in format                      *)
+(* When ex >= ey, the integer remainder (mx * 2^(ex-ey)) rem my    *)
+(* satisfies 0 <= r < |my| < 2^p, so it fits in the format.        *)
+(* Uses HOL Light's native int div/rem with INT_DIVISION.           *)
+(*                                                                  *)
+(* Note: HOL Light's rem satisfies 0 <= a rem b < |b| (non-negative *)
+(* remainder). The implementation applies sign(x) separately to get *)
+(* the signed fmod. This theorem covers the unsigned bound.         *)
+(* (Coq: no direct equivalent; this is new in the HOL Light proofs) *)
+(* ================================================================ *)
+
+let INT_REMAINDER_IN_FORMAT = prove(
+  `!mx my p (ex:int) (ey:int).
+     abs(real_of_int mx) < &2 pow p /\
+     abs(real_of_int my) < &2 pow p /\
+     ey <= ex /\ ~(my = &0:int)
+     ==> ?r q. abs(real_of_int r) < abs(real_of_int my) /\
+               abs(real_of_int r) < &2 pow p /\
+               real_of_int mx * &2 zpow ex -
+               real_of_int q * (real_of_int my * &2 zpow ey) =
+               real_of_int r * &2 zpow ey`,
+  REPEAT GEN_TAC THEN STRIP_TAC THEN
+  SUBGOAL_THEN `&0 <= ex - ey` ASSUME_TAC THENL
+  [ASM_INT_ARITH_TAC; ALL_TAC] THEN
+  SUBGOAL_THEN `&2 zpow (ex - ey) = &2 pow num_of_int(ex - ey)`
+    ASSUME_TAC THENL
+  [REWRITE_TAC[GSYM REAL_ZPOW_NUM] THEN AP_TERM_TAC THEN
+   ASM_SIMP_TAC[INT_OF_NUM_OF_INT]; ALL_TAC] THEN
+  EXISTS_TAC `(mx * &2 pow num_of_int(ex - ey)) rem my:int` THEN
+  EXISTS_TAC `(mx * &2 pow num_of_int(ex - ey)) div my:int` THEN
+  MP_TAC(SPECL [`mx * &2 pow num_of_int(ex - ey):int`; `my:int`]
+    INT_DIVISION) THEN
+  ASM_REWRITE_TAC[] THEN STRIP_TAC THEN
+  REPEAT CONJ_TAC THENL
+  [(* |r| < |my| *)
+   REWRITE_TAC[GSYM REAL_OF_INT_CLAUSES] THEN
+   UNDISCH_TAC `&0 <= (mx * &2 pow num_of_int(ex - ey)) rem my` THEN
+   UNDISCH_TAC `(mx * &2 pow num_of_int(ex - ey)) rem my < abs my` THEN
+   REWRITE_TAC[GSYM REAL_OF_INT_CLAUSES] THEN REAL_ARITH_TAC;
+   (* |r| < 2^p *)
+   MATCH_MP_TAC REAL_LET_TRANS THEN
+   EXISTS_TAC `abs(real_of_int my)` THEN CONJ_TAC THENL
+   [REWRITE_TAC[GSYM REAL_OF_INT_CLAUSES] THEN
+    UNDISCH_TAC `&0 <= (mx * &2 pow num_of_int(ex - ey)) rem my` THEN
+    UNDISCH_TAC `(mx * &2 pow num_of_int(ex - ey)) rem my < abs my` THEN
+    REWRITE_TAC[GSYM REAL_OF_INT_CLAUSES] THEN REAL_ARITH_TAC;
+    ASM_REWRITE_TAC[]];
+   (* Algebraic identity *)
+   SUBGOAL_THEN
+     `mx * &2 pow num_of_int(ex - ey) =
+      (mx * &2 pow num_of_int(ex - ey)) div my * my +
+      (mx * &2 pow num_of_int(ex - ey)) rem my:int` ASSUME_TAC THENL
+   [MESON_TAC[INT_DIVISION_SIMP; INT_ADD_SYM]; ALL_TAC] THEN
+   REWRITE_TAC[GSYM REAL_OF_INT_CLAUSES] THEN
+   SUBGOAL_THEN
+     `real_of_int mx * &2 zpow ex =
+      real_of_int(mx * &2 pow num_of_int(ex - ey)) * &2 zpow ey`
+     SUBST1_TAC THENL
+   [REWRITE_TAC[GSYM REAL_OF_INT_CLAUSES] THEN
+    ASM_REWRITE_TAC[] THEN
+    ONCE_REWRITE_TAC[ZPOW2_SPLIT] THEN RING;
+    ALL_TAC] THEN
+   UNDISCH_TAC
+     `mx * &2 pow num_of_int(ex - ey) =
+      (mx * &2 pow num_of_int(ex - ey)) div my * my +
+      (mx * &2 pow num_of_int(ex - ey)) rem my:int` THEN
+   REWRITE_TAC[GSYM REAL_OF_INT_CLAUSES] THEN REAL_ARITH_TAC]);;
+
+(* ================================================================ *)
+(* Section 8: Remainder via fmod (scaling identity)                 *)
+(* For any real x, y with y <> 0 and integer q:                     *)
+(*   x - n*y = (x - q*y) - (n - q)*y                               *)
+(* So remainder(x, y) = remainder(x - q*y, y) = remainder(fmod, y). *)
+(* This is the algebraic core of Strategy 1.                        *)
+(* (Coq: remainder_via_fmod — there it uses Znearest properties)    *)
+(* ================================================================ *)
+
+let REMAINDER_SCALING = prove(
+  `!x y q n:real. x - n * y = (x - q * y) - (n - q) * y`,
+  REAL_ARITH_TAC);;
+
+(* ================================================================ *)
+(* Section 9: After fmod, n is in {-1, 0, 1} (issue 15)            *)
+(* When |q| < 1, the nearest integer to q has |n| <= 1.            *)
+(* HOL Light doesn't have Znearest, so we state this over reals:    *)
+(* if n is an integer and |q - n| <= 1/2 and |q| < 1, then         *)
+(* n in {-1, 0, 1}.                                                 *)
+(* ================================================================ *)
+
+let NEAREST_INT_SMALL = prove(
+  `!q n:int. abs(real_of_int n - q) <= &1 / &2
+   ==> abs(q) < &1
+   ==> n = -- &1 \/ n = &0 \/ n = &1`,
+  REPEAT STRIP_TAC THEN
+  SUBGOAL_THEN `-- &1 <= n /\ n <= &1:int` MP_TAC THENL
+  [REWRITE_TAC[GSYM REAL_OF_INT_CLAUSES] THEN
+   MP_TAC(SPEC `real_of_int n - q` (GEN_ALL REAL_ABS_BOUNDS)) THEN
+   ASM_REAL_ARITH_TAC;
+   INT_ARITH_TAC]);;
+
+(* ================================================================ *)
+(* Section 10: Composition — fmod then FMA (issue 14)               *)
+(*                                                                  *)
+(* Proved components:                                               *)
+(*   FMOD_RESULT_REPRESENTABLE: the fmod result is in FLX(p)        *)
+(*   FMOD_RATIO_SMALL: |fmod/y| < 1                                *)
+(*   NEAREST_INT_SMALL: n in {-1, 0, 1}                            *)
+(*   REMAINDER_FORMAT: the CORRECT candidate r - n*y is in FLX(p)  *)
+(*   COMPARISON_STEP: |r_correct| < |r_wrong| in exact arithmetic  *)
+(*                                                                  *)
+(* Issue 16 (rounding preserves comparison) is proved in Coq using  *)
+(* round_N_pt with y (same sign) or -r (opposite sign) as witness. *)
+(* The proof does NOT require ulp machinery — just the nearest-     *)
+(* point property of rounding. It cannot be replicated in HOL Light *)
+(* because HOL Light lacks a rounding theory.                       *)
+(* ================================================================ *)
+
+let FMOD_RESULT_REPRESENTABLE = prove(
+  `!mr my p (ey:int).
+     abs(real_of_int mr) < &2 pow p
+     ==> is_flx p (real_of_int mr * &2 zpow ey)`,
+  REPEAT STRIP_TAC THEN REWRITE_TAC[is_flx] THEN
+  MAP_EVERY EXISTS_TAC [`mr:int`; `ey:int`] THEN
+  ASM_REWRITE_TAC[]);;
+
+let FMOD_RATIO_SMALL = prove(
+  `!mr my (ey:int).
+     abs(real_of_int mr) < abs(real_of_int my) /\
+     ~(real_of_int my = &0)
+     ==> abs(real_of_int mr * &2 zpow ey /
+             (real_of_int my * &2 zpow ey)) < &1`,
+  REPEAT GEN_TAC THEN STRIP_TAC THEN
+  SUBGOAL_THEN
+    `real_of_int mr * &2 zpow ey / (real_of_int my * &2 zpow ey) =
+     real_of_int mr / real_of_int my`
+    SUBST1_TAC THENL
+  [MATCH_MP_TAC(REAL_FIELD
+     `~(e = &0) /\ ~(m = &0)
+      ==> a * e / (m * e) = a / m`) THEN
+   ASM_REWRITE_TAC[ZPOW2_NZ];
+   ALL_TAC] THEN
+  REWRITE_TAC[REAL_ABS_DIV] THEN
+  ASM_SIMP_TAC[REAL_LT_LDIV_EQ; REAL_ARITH
+    `~(x = &0) ==> &0 < abs x`] THEN
+  ASM_REAL_ARITH_TAC);;
+
+(* The correct candidate is representable *)
+let CORRECT_CANDIDATE_REPRESENTABLE = prove(
+  `!mr my n p (ey:int).
+     abs(real_of_int mr) < &2 pow p /\
+     abs(real_of_int my) < &2 pow p /\
+     ~(real_of_int my = &0) /\
+     abs(real_of_int mr * &2 zpow ey -
+         real_of_int n * (real_of_int my * &2 zpow ey)) <=
+       abs(real_of_int my * &2 zpow ey) / &2
+     ==> is_flx p (real_of_int mr * &2 zpow ey -
+                    real_of_int n * (real_of_int my * &2 zpow ey))`,
+  REPEAT STRIP_TAC THEN MATCH_MP_TAC REMAINDER_FORMAT THEN
+  ASM_REWRITE_TAC[]);;
+
+print_string "\n=== ALL HOL LIGHT PROOFS COMPLETE (zero mk_thm) ===\n";;
+print_string "Proved: COMPARISON_STEP, REMAINDER_FORMAT_GE/LT,\n";;
+print_string "        REMAINDER_FORMAT, INT_REMAINDER_IN_FORMAT,\n";;
+print_string "        REMAINDER_SCALING, NEAREST_INT_SMALL,\n";;
+print_string "        FMOD_RESULT_REPRESENTABLE, FMOD_RATIO_SMALL,\n";;
+print_string "        CORRECT_CANDIDATE_REPRESENTABLE\n";;
diff --git a/doc/proofs/fma_remainder.v b/doc/proofs/fma_remainder.v
new file mode 100644
index 00000000000..49a85c4251c
--- /dev/null
+++ b/doc/proofs/fma_remainder.v
@@ -0,0 +1,532 @@
+From Coq Require Import ZArith Reals Psatz Lia.
+From Flocq Require Import Core.Zaux Core.Defs Core.Generic_fmt Core.FLX
+  Core.Round_NE Core.Raux Core.Float_prop.
+
+Open Scope R_scope.
+
+(** ============================================================
+    Pure real analysis: comparison step
+    ============================================================
+
+    This does not depend on any floating-point format.
+    When |r| < |y|/2, both |r+y| and |r-y| are strictly larger.
+    This ensures the algorithm's min-selection picks the correct n
+    in the non-tie case. *)
+
+Theorem comparison_step :
+  forall r y : R,
+    y <> 0 ->
+    Rabs r < Rabs y / 2 ->
+    Rabs r < Rabs (r + y) /\ Rabs r < Rabs (r - y).
+Proof.
+  intros r y Hy0 Hr.
+  assert (Hay : Rabs y > 0) by (apply Rabs_pos_lt; exact Hy0).
+  split.
+  - assert (H := Rabs_triang (r + y) (- r)).
+    replace (r + y + - r) with y in H by ring.
+    rewrite Rabs_Ropp in H. lra.
+  - assert (H2 := Rabs_triang (- (r - y)) r).
+    replace (- (r - y) + r) with y in H2 by ring.
+    rewrite Rabs_Ropp in H2. lra.
+Qed.
+
+(** ============================================================
+    Floating-point representability of the remainder
+    ============================================================ *)
+
+Section FMA_Remainder.
+
+Variable p : Z.
+Hypothesis Hp : (1 < p)%Z.
+Let beta := radix2.
+Let fexp := FLX_exp p.
+Let format := generic_format beta fexp.
+Let round_ne := round beta fexp ZnearestE.
+Instance Hp0 : Prec_gt_0 p. unfold Prec_gt_0. lia. Qed.
+
+Lemma Hve : Valid_exp fexp.
+Proof. apply FLX_exp_valid. exact Hp0. Qed.
+
+Lemma round_exact : forall x, format x -> round_ne x = x.
+Proof. intros x Hx. apply round_generic; [apply valid_rnd_N|exact Hx]. Qed.
+
+Lemma format_F2R_bounded : forall m e : Z,
+  (Z.abs m < Zpower beta p)%Z -> format (F2R (Float beta m e)).
+Proof.
+  intros m e Hm. apply generic_format_FLX.
+  econstructor; [reflexivity|simpl; exact Hm].
+Qed.
+
+(** Case 1: ex >= ey. Align x to exponent ey, show mantissa < 2^p. *)
+Theorem remainder_format_ge :
+  forall (mx my n : Z) (ex ey : Z),
+    (Z.abs mx < Zpower beta p)%Z ->
+    (Z.abs my < Zpower beta p)%Z ->
+    (ey <= ex)%Z -> my <> 0%Z ->
+    let x := F2R (Float beta mx ex) in
+    let y := F2R (Float beta my ey) in
+    Rabs (x - IZR n * y) <= Rabs y / 2 ->
+    format (x - IZR n * y).
+Proof.
+  intros mx my n ex ey Hmx Hmy Hle Hmy0 x y Hbound.
+  destruct (Req_dec (x - IZR n * y) 0) as [Hz|Hnz].
+  { rewrite Hz. apply generic_format_0. }
+  unfold x. rewrite (@F2R_change_exp beta ey mx ex Hle).
+  set (M := (mx * Zpower beta (ex - ey) - n * my)%Z).
+  assert (Heq : F2R (Float beta (mx * Zpower beta (ex - ey)) ey) - IZR n * y
+                = F2R (Float beta M ey)).
+  { unfold M, y, F2R. simpl Fnum. simpl Fexp.
+    rewrite minus_IZR, 2!mult_IZR.
+    unfold Rminus. rewrite Rmult_plus_distr_r.
+    rewrite <- Ropp_mult_distr_l, <- Rmult_assoc. reflexivity. }
+  rewrite Heq. apply format_F2R_bounded.
+  assert (Hbp : (0 < bpow beta ey)%R) by apply bpow_gt_0.
+  assert (HMeq : IZR M * bpow beta ey = x - IZR n * y).
+  { unfold x. rewrite (@F2R_change_exp beta ey mx ex Hle). symmetry.
+    exact Heq. }
+  assert (Hyeq : IZR my * bpow beta ey = y).
+  { unfold y, F2R. simpl. reflexivity. }
+  assert (H1 : Rabs (IZR M) * bpow beta ey = Rabs (x - IZR n * y)).
+  { rewrite <- HMeq, Rabs_mult, (Rabs_right (bpow beta ey));
+    [reflexivity | left; exact Hbp]. }
+  assert (H2 : Rabs y = Rabs (IZR my) * bpow beta ey).
+  { rewrite <- Hyeq, Rabs_mult, (Rabs_right (bpow beta ey));
+    [reflexivity | left; exact Hbp]. }
+  assert (H3 : Rabs (IZR M) * bpow beta ey <=
+               Rabs (IZR my) * bpow beta ey / 2).
+  { rewrite H1. rewrite H2 in Hbound. exact Hbound. }
+  assert (Hbound' : Rabs (IZR M) <= Rabs (IZR my) / 2).
+  { apply Rmult_le_reg_r with (bpow beta ey); [exact Hbp|]. lra. }
+  apply lt_IZR. rewrite abs_IZR.
+  apply Rle_lt_trans with (1 := Hbound').
+  apply Rle_lt_trans with (Rabs (IZR my)).
+  { assert (H : 0 <= Rabs (IZR my)) by apply Rabs_pos.
+    apply Rle_trans with (Rabs (IZR my) * 1); [|lra].
+    apply Rmult_le_compat_l; [exact H|]. lra. }
+  rewrite Rabs_Zabs. apply IZR_lt. exact Hmy.
+Qed.
+
+(** Case 2: ex < ey. Align y to exponent ex, show mantissa < 2^p.
+    When n = 0, M = mx and |M| < 2^p trivially.
+    When n <> 0, |n*y| >= |y| and |x - n*y| <= |y|/2 imply
+    |x - n*y| <= |x|, so |M| <= |mx| < 2^p. *)
+Theorem remainder_format_lt :
+  forall (mx my n : Z) (ex ey : Z),
+    (Z.abs mx < Zpower beta p)%Z ->
+    (Z.abs my < Zpower beta p)%Z ->
+    (ex < ey)%Z -> my <> 0%Z ->
+    let x := F2R (Float beta mx ex) in
+    let y := F2R (Float beta my ey) in
+    Rabs (x - IZR n * y) <= Rabs y / 2 ->
+    format (x - IZR n * y).
+Proof.
+  intros mx my n ex ey Hmx Hmy Hlt Hmy0 x y Hbound.
+  destruct (Req_dec (x - IZR n * y) 0) as [Hz|Hnz].
+  { rewrite Hz. apply generic_format_0. }
+  assert (Hle : (ex <= ey)%Z) by lia.
+  unfold y. rewrite (@F2R_change_exp beta ex my ey Hle).
+  set (M := (mx - n * (my * Zpower beta (ey - ex)))%Z).
+  assert (Heq : x - IZR n * F2R (Float beta (my * Zpower beta (ey - ex)) ex)
+                = F2R (Float beta M ex)).
+  { unfold M, x, F2R. simpl Fnum. simpl Fexp.
+    rewrite minus_IZR, 3!mult_IZR.
+    unfold Rminus. rewrite Rmult_plus_distr_r.
+    rewrite <- Ropp_mult_distr_l. ring. }
+  rewrite Heq. apply format_F2R_bounded.
+  assert (Hbp : (0 < bpow beta ex)%R) by apply bpow_gt_0.
+  assert (HMeq : IZR M * bpow beta ex = x - IZR n * y).
+  { unfold x, y. rewrite (@F2R_change_exp beta ex my ey Hle). symmetry.
+    exact Heq. }
+  destruct (Z.eq_dec n 0) as [Hn0|Hn0].
+  { subst n. unfold M. rewrite Z.mul_0_l, Z.sub_0_r. exact Hmx. }
+  assert (Habs_le_x : Rabs (x - IZR n * y) <= Rabs x).
+  { assert (Hny_bound : Rabs (IZR n * y) >= Rabs y).
+    { rewrite Rabs_mult. apply Rle_ge.
+      rewrite <- (Rmult_1_l (Rabs y)) at 1.
+      apply Rmult_le_compat_r; [apply Rabs_pos|].
+      rewrite <- abs_IZR. apply IZR_le.
+      assert (n <> 0%Z) by exact Hn0. lia. }
+    assert (Hny_close : Rabs (IZR n * y - x) <= Rabs y / 2).
+    { replace (IZR n * y - x) with (- (x - IZR n * y)) by ring.
+      rewrite Rabs_Ropp. exact Hbound. }
+    assert (Hx_ge : Rabs x >= Rabs y / 2).
+    { assert (H := Rabs_triang_inv (IZR n * y) x).
+      assert (Hny_minus_x : Rabs (IZR n * y) - Rabs x <= Rabs y / 2).
+      { replace (IZR n * y - x) with (-(x - IZR n * y)) in H by ring.
+        rewrite Rabs_Ropp in H. lra. }
+      lra. }
+    lra. }
+  assert (HM_le_mx : Rabs (IZR M) <= Rabs (IZR mx)).
+  { apply Rmult_le_reg_r with (bpow beta ex); [exact Hbp|].
+    assert (H1 : Rabs (IZR M) * bpow beta ex = Rabs (IZR M * bpow beta ex)).
+    { rewrite Rabs_mult, (Rabs_right (bpow beta ex)); [ring|left; exact Hbp]. }
+    assert (H2 : Rabs (IZR mx) * bpow beta ex = Rabs (IZR mx * bpow beta ex)).
+    { rewrite Rabs_mult, (Rabs_right (bpow beta ex)); [ring|left; exact Hbp]. }
+    rewrite H1, H2.
+    rewrite HMeq.
+    replace (IZR mx * bpow beta ex) with x by (unfold x, F2R; simpl; ring).
+    exact Habs_le_x. }
+  apply lt_IZR. rewrite abs_IZR.
+  apply Rle_lt_trans with (1 := HM_le_mx).
+  rewrite Rabs_Zabs. apply IZR_lt. exact Hmx.
+Qed.
+
+(** Combined theorem: the remainder is representable for any exponents. *)
+Theorem remainder_format :
+  forall (mx my n : Z) (ex ey : Z),
+    (Z.abs mx < Zpower beta p)%Z ->
+    (Z.abs my < Zpower beta p)%Z ->
+    my <> 0%Z ->
+    let x := F2R (Float beta mx ex) in
+    let y := F2R (Float beta my ey) in
+    Rabs (x - IZR n * y) <= Rabs y / 2 ->
+    format (x - IZR n * y).
+Proof.
+  intros mx my n ex ey Hmx Hmy Hmy0 x y Hbound.
+  destruct (Z_le_dec ey ex) as [Hle|Hgt].
+  - exact (remainder_format_ge mx my n ex ey Hmx Hmy Hle Hmy0 Hbound).
+  - apply remainder_format_lt; [exact Hmx|exact Hmy| lia |exact Hmy0|exact Hbound].
+Qed.
+
+(** FMA(-n, y, x) computes round(x - n*y). Since x - n*y is
+    representable (by remainder_format), rounding is the identity. *)
+Theorem fma_remainder_exact :
+  forall (mx my n : Z) (ex ey : Z),
+    (Z.abs mx < Zpower beta p)%Z ->
+    (Z.abs my < Zpower beta p)%Z ->
+    my <> 0%Z ->
+    let x := F2R (Float beta mx ex) in
+    let y := F2R (Float beta my ey) in
+    Rabs (x - IZR n * y) <= Rabs y / 2 ->
+    round_ne (x - IZR n * y) = x - IZR n * y.
+Proof.
+  intros. apply round_exact. now apply remainder_format.
+Qed.
+
+(** ================================================================ *)
+(** When |q| < 1, the nearest integer to q is in {-1, 0, 1}.       *)
+(** This proves that after fmod (which gives |fmod/y| < 1), the     *)
+(** quotient n is within 1 of the correct value.                    *)
+(** ================================================================ *)
+
+Lemma nearest_int_small :
+  forall (choice : Z -> bool) (q : R),
+    Rabs q < 1 ->
+    let n := Znearest choice q in
+    (n = -1 \/ n = 0 \/ n = 1)%Z.
+Proof.
+  intros choice q Hq n.
+  assert (Hzn := Znearest_half choice q). fold n in Hzn.
+  apply Rabs_def2 in Hq.
+  assert (Hbounds : q - IZR n <= / 2 /\ - (/ 2) <= q - IZR n).
+  { unfold Rabs in Hzn. destruct (Rcase_abs (q - IZR n)); lra. }
+  assert (Hlo : (-1 <= n)%Z).
+  { destruct (Z_le_dec (-1) n); [lia|exfalso].
+    assert ((n <= -2)%Z) by lia.
+    assert (IZR n <= IZR (-2)) by (apply IZR_le; lia).
+    simpl in *. lra. }
+  assert (Hhi : (n <= 1)%Z).
+  { destruct (Z_le_dec n 1); [lia|exfalso].
+    assert ((2 <= n)%Z) by lia.
+    assert (IZR 2 <= IZR n) by (apply IZR_le; lia).
+    simpl in *. lra. }
+  lia.
+Qed.
+
+(** ================================================================ *)
+(** Composition: integer fmod then FMA gives the correct remainder. *)
+(** ================================================================ *)
+
+Lemma y_nonzero :
+  forall (my : Z) (ey : Z),
+    my <> 0%Z -> F2R (Float beta my ey) <> 0.
+Proof.
+  intros my ey Hmy. unfold F2R. simpl.
+  assert (IZR my <> 0) by (apply not_0_IZR; exact Hmy).
+  assert (bpow beta ey > 0) by apply bpow_gt_0.
+  intro Heq. apply H. nra.
+Qed.
+
+Theorem fmod_then_remainder :
+  forall (mx my : Z) (ex ey : Z),
+    (Z.abs mx < Zpower beta p)%Z ->
+    (Z.abs my < Zpower beta p)%Z ->
+    my <> 0%Z -> (ey <= ex)%Z ->
+    let y := F2R (Float beta my ey) in
+    exists (mr n_fmod : Z),
+      (Z.abs mr < Z.abs my)%Z /\
+      let r := F2R (Float beta mr ey) in
+      let x := F2R (Float beta mx ex) in
+      r = x - IZR n_fmod * y /\
+      format r /\
+      (forall choice, let n := Znearest choice (r / y) in
+        (n = -1 \/ n = 0 \/ n = 1)%Z) /\
+      (forall choice, let n := Znearest choice (r / y) in
+        round_ne (r - IZR n * y) = r - IZR n * y).
+Proof.
+  intros mx my ex ey Hmx Hmy Hmy0 Hle y.
+  set (shifted := (mx * Zpower beta (ex - ey))%Z).
+  exists (Z.rem shifted my), (Z.quot shifted my).
+  assert (Hdiv : shifted = (Z.quot shifted my * my + Z.rem shifted my)%Z).
+  { rewrite Z.mul_comm. apply Z.quot_rem'. }
+  assert (Hrem_bound : (Z.abs (Z.rem shifted my) < Z.abs my)%Z)
+    by (apply Z.rem_bound_abs; lia).
+  split; [exact Hrem_bound|].
+  set (r := F2R (Float beta (Z.rem shifted my) ey)).
+  set (x := F2R (Float beta mx ex)).
+  assert (Hreq : r = x - IZR (Z.quot shifted my) * y).
+  { unfold r, x, y, F2R. simpl.
+    set (q := Z.quot shifted my). set (rm := Z.rem shifted my).
+    assert (Hd : (shifted = q * my + rm)%Z) by (unfold q, rm; lia).
+    assert (IZR shifted = IZR q * IZR my + IZR rm).
+    { rewrite Hd. rewrite plus_IZR, mult_IZR. ring. }
+    unfold shifted in H.
+    rewrite mult_IZR, IZR_Zpower in H; [|lia].
+    assert (bpow beta ey > 0) by apply bpow_gt_0.
+    assert (IZR mx * bpow beta ex =
+            (IZR q * IZR my + IZR rm) * bpow beta ey).
+    { rewrite <- H. rewrite Rmult_assoc, <- bpow_plus.
+      replace (ex - ey + ey)%Z with ex by lia. ring. }
+    lra. }
+  split; [exact Hreq|].
+  split; [apply format_F2R_bounded; lia|].
+  (* |r/y| < 1 since |mr| < |my| *)
+  assert (Hry : Rabs (r / y) < 1).
+  { unfold r, y, F2R. simpl.
+    assert (Hmy_ne : IZR my <> 0) by (apply not_0_IZR; exact Hmy0).
+    assert (Hbp : bpow beta ey > 0) by apply bpow_gt_0.
+    unfold Rdiv. rewrite Rinv_mult.
+    rewrite Rmult_assoc.
+    replace (bpow beta ey * (/ IZR my * / bpow beta ey))
+      with (/ IZR my) by (field; split; lra).
+    rewrite Rabs_mult, Rabs_inv.
+    apply Rmult_lt_reg_r with (Rabs (IZR my)).
+    { apply Rabs_pos_lt. exact Hmy_ne. }
+    rewrite Rmult_assoc, Rinv_l, Rmult_1_r, Rmult_1_l;
+      [|apply Rabs_no_R0; exact Hmy_ne].
+    rewrite <- 2!abs_IZR. apply IZR_lt. exact Hrem_bound. }
+  assert (Hny : y <> 0) by (apply y_nonzero; exact Hmy0).
+  split.
+  { intros choice. apply nearest_int_small. exact Hry. }
+  { intros choice. apply round_exact.
+    apply remainder_format;
+      [apply Z.lt_trans with (Z.abs my); [lia|exact Hmy]|exact Hmy|exact Hmy0|].
+    set (n := Znearest choice (r / y)).
+    assert (Hzn := Znearest_half choice (r / y)). fold n in Hzn.
+    (* |r - n*y| = |y| * |r/y - n| <= |y| * 1/2 = |y|/2 *)
+    assert (Habs_ry : Rabs (r / y - IZR n) <= / 2) by exact Hzn.
+    assert (Hay : Rabs y > 0) by (apply Rabs_pos_lt; exact Hny).
+    assert (Heq : F2R (Float beta (Z.rem shifted my) ey) -
+                  IZR n * F2R (Float beta my ey) =
+                  y * (r / y - IZR n)).
+    { unfold r, y. field. exact Hny. }
+    rewrite Heq, Rabs_mult.
+    apply Rmult_le_compat_l; [apply Rabs_pos|exact Habs_ry]. }
+Qed.
+
+(** ================================================================ *)
+(** Rounding preserves the comparison (issue 16).                   *)
+(**                                                                  *)
+(** When |r| < |y|/2 and both r, y are representable,               *)
+(** |round(r ± y)| >= |r|.                                          *)
+(**                                                                  *)
+(** Proof strategy:                                                  *)
+(** - Same sign (r*y >= 0): |r+y| >= |y|. Use y as the witness in  *)
+(**   round_N_pt: |round(r+y) - (r+y)| <= |y - (r+y)| = |r|.      *)
+(**   So |round(r+y)| >= |r+y| - |r| >= |y| - |r| > |r|. Strict.  *)
+(** - Opposite sign (r*y < 0): |r+y| = |y| - |r|. Use -r as the   *)
+(**   witness: |round(r+y) - (r+y)| <= |-r - (r+y)| = |2r+y|      *)
+(**   = |y| - 2|r|. So |round(r+y)| >= |r+y| - (|y| - 2|r|)      *)
+(**   = (|y| - |r|) - (|y| - 2|r|) = |r|. Non-strict (>=).        *)
+(**                                                                  *)
+(** The >= (not strict >) in the opposite-sign case corresponds to  *)
+(** ties, where round-to-even resolves correctly.                   *)
+(** ================================================================ *)
+
+Lemma abs_2r_plus_y : forall r y : R,
+  r * y < 0 -> Rabs r < Rabs y / 2 ->
+  Rabs (2 * r + y) = Rabs y - 2 * Rabs r.
+Proof.
+  intros r y Hsign Hbound.
+  destruct (Rlt_dec 0 r).
+  - assert (y < 0) by nra.
+    rewrite (Rabs_right r) by lra. rewrite (Rabs_left y) by lra.
+    assert (2 * r + y < 0) by (rewrite (Rabs_right r) in Hbound by lra;
+      rewrite (Rabs_left y) in Hbound by lra; lra).
+    rewrite (Rabs_left) by lra. lra.
+  - assert (r <= 0) by lra.
+    assert (y > 0) by (destruct (Req_dec r 0); [subst; nra|nra]).
+    rewrite (Rabs_left1 r) by lra. rewrite (Rabs_right y) by lra.
+    assert (2 * r + y > 0) by (rewrite (Rabs_left1 r) in Hbound by lra;
+      rewrite (Rabs_right y) in Hbound by lra; lra).
+    rewrite (Rabs_right) by lra. lra.
+Qed.
+
+Lemma abs_r_plus_y_opp : forall r y : R,
+  r * y < 0 -> Rabs r < Rabs y / 2 ->
+  Rabs (r + y) = Rabs y - Rabs r.
+Proof.
+  intros r y Hsign Hbound.
+  destruct (Rlt_dec 0 r).
+  - assert (y < 0) by nra.
+    rewrite (Rabs_right r) by lra. rewrite (Rabs_left y) by lra.
+    assert (r + y < 0) by (rewrite (Rabs_right r) in Hbound by lra;
+      rewrite (Rabs_left y) in Hbound by lra; lra).
+    rewrite (Rabs_left) by lra. lra.
+  - assert (r <= 0) by lra.
+    assert (y > 0) by (destruct (Req_dec r 0); [subst; nra|nra]).
+    rewrite (Rabs_left1 r) by lra. rewrite (Rabs_right y) by lra.
+    assert (r + y > 0) by (rewrite (Rabs_left1 r) in Hbound by lra;
+      rewrite (Rabs_right y) in Hbound by lra; lra).
+    rewrite (Rabs_right) by lra. lra.
+Qed.
+
+Lemma round_same_sign :
+  forall r y : R, format y -> y <> 0 ->
+    Rabs r < Rabs y / 2 -> r * y >= 0 ->
+    Rabs r < Rabs (round beta fexp (Znearest Z.even) (r + y)).
+Proof.
+  intros r y Hfy Hy Hbound Hsign.
+  assert (Hay : Rabs y > 0) by (apply Rabs_pos_lt; exact Hy).
+  pose proof (@round_N_pt beta fexp Hve Z.even (r + y)) as [_ HN].
+  specialize (HN y Hfy).
+  replace (y - (r + y)) with (- r) in HN by ring.
+  rewrite Rabs_Ropp in HN.
+  assert (Hrpy : Rabs (r + y) >= Rabs y).
+  { unfold Rabs; destruct (Rcase_abs (r+y)), (Rcase_abs y); nra. }
+  assert (Hlow : Rabs (round beta fexp (Znearest Z.even) (r + y)) >=
+                 Rabs (r + y) - Rabs r).
+  { pose proof (Rabs_triang_inv (r + y)
+      (r + y - round beta fexp (Znearest Z.even) (r + y))) as HT.
+    replace (r + y - (r + y - round beta fexp (Znearest Z.even) (r + y)))
+      with (round beta fexp (Znearest Z.even) (r + y)) in HT by ring.
+    assert (Rabs (r + y - round beta fexp (Znearest Z.even) (r + y)) <= Rabs r).
+    { rewrite Rabs_minus_sym. exact HN. }
+    lra. }
+  lra.
+Qed.
+
+Lemma round_opposite_sign :
+  forall r y : R, format r -> format y -> y <> 0 ->
+    Rabs r < Rabs y / 2 -> r * y < 0 ->
+    Rabs r <= Rabs (round beta fexp (Znearest Z.even) (r + y)).
+Proof.
+  intros r y Hfr Hfy Hy Hbound Hsign.
+  assert (Hay : Rabs y > 0) by (apply Rabs_pos_lt; exact Hy).
+  pose proof (@round_N_pt beta fexp Hve Z.even (r + y)) as [_ HN].
+  assert (Hfnr : format (- r)) by (apply generic_format_opp; exact Hfr).
+  specialize (HN (- r) Hfnr).
+  replace (- r - (r + y)) with (- (2 * r + y)) in HN by ring.
+  rewrite Rabs_Ropp in HN.
+  rewrite (abs_2r_plus_y r y Hsign Hbound) in HN.
+  assert (Hrpy := abs_r_plus_y_opp r y Hsign Hbound).
+  assert (Hlow : Rabs (round beta fexp (Znearest Z.even) (r + y)) >=
+                 Rabs (r + y) - (Rabs y - 2 * Rabs r)).
+  { pose proof (Rabs_triang_inv (r + y)
+      (r + y - round beta fexp (Znearest Z.even) (r + y))) as HT.
+    replace (r + y - (r + y - round beta fexp (Znearest Z.even) (r + y)))
+      with (round beta fexp (Znearest Z.even) (r + y)) in HT by ring.
+    assert (Rabs (r + y - round beta fexp (Znearest Z.even) (r + y))
+            <= Rabs y - 2 * Rabs r).
+    { rewrite Rabs_minus_sym. exact HN. }
+    lra. }
+  lra.
+Qed.
+
+Theorem rounding_preserves_remainder_comparison :
+  forall r y : R, format r -> format y -> y <> 0 ->
+    Rabs r < Rabs y / 2 ->
+    Rabs r <= Rabs (round beta fexp (Znearest Z.even) (r + y)) /\
+    Rabs r <= Rabs (round beta fexp (Znearest Z.even) (r - y)).
+Proof.
+  intros r y Hfr Hfy Hy Hbound. split.
+  - destruct (Rlt_dec (r * y) 0).
+    + apply round_opposite_sign; auto.
+    + apply Rlt_le. apply round_same_sign; auto. lra.
+  - replace (r - y) with (r + (- y)) by ring.
+    assert (Hfny : format (- y)) by (apply generic_format_opp; exact Hfy).
+    rewrite <- (Rabs_Ropp y) in Hbound.
+    destruct (Rlt_dec (r * (- y)) 0).
+    + apply round_opposite_sign; auto. lra.
+    + apply Rlt_le. apply round_same_sign; auto. lra. lra.
+Qed.
+
+(** ================================================================ *)
+(** Implementation correspondence lemmas                             *)
+(** ================================================================ *)
+
+(** ================================================================ *)
+(** Implementation correspondence notes                              *)
+(** ================================================================ *)
+
+(** Mismatch #1: fmod_then_remainder only covers ey <= ex.
+    When ex < ey, the implementation shifts my left and computes
+    mx mod (my * 2^(ey-ex)). The remainder r satisfies |r| < |my_shifted|
+    and also |r| <= |mx| < 2^p, so r is representable. The proof of
+    |r/y| < 1 and the FMA exactness follow by the same argument as
+    fmod_then_remainder. The ey <= ex case is the "interesting" one
+    where the quotient can be large; for ex < ey, the quotient is
+    small (often 0) and the proof is simpler.
+    
+    Rather than duplicating the full proof, we note that
+    remainder_format handles both exponent orderings, and
+    nearest_int_small + rounding_preserves_remainder_comparison
+    complete the argument for both cases. *)
+
+(** Mismatch #3: The implementation computes fmod on unsigned
+    significands and applies sign(x) separately. This is correct
+    because |fmod(x, y)| = |fmod(|x|, |y|)| — the integer remainder
+    of unsigned significands gives the absolute value of fmod. *)
+
+(** Mismatch #4: The implementation computes n = round_to_integral(
+    fp_div(fmod, y)). The try-all-three approach (n, n+1, n-1) makes
+    this robust: even if fp_div introduces rounding error, the correct
+    nearest integer is among {n-1, n, n+1}. By fma_remainder_exact,
+    the correct candidate is computed exactly by FMA. By
+    rounding_preserves_remainder_comparison, the wrong candidates have
+    |result| >= |r_correct|. So min-selection picks the correct one. *)
+
+End FMA_Remainder.
+
+(** ============================================================
+    WHAT THIS PROOF COVERS
+    ============================================================
+
+    PROVED (machine-checked, zero admits):
+
+    1. remainder_format: For FLX(p) floats x = mx * 2^ex and
+       y = my * 2^ey, if |x - n*y| <= |y|/2 then x - n*y is
+       exactly representable in FLX(p).
+
+    2. fma_remainder_exact: FMA(-n, y, x) = x - n*y exactly
+       (rounding a representable value is the identity).
+
+    3. comparison_step: When |r| < |y|/2, both |r+y| and |r-y|
+       have strictly larger absolute value.
+
+    4. nearest_int_small: When |q| < 1, Znearest(q) ∈ {-1, 0, 1}.
+       This proves that after fmod, n is within 1 of correct.
+
+    5. fmod_then_remainder: The full composition — integer fmod
+       produces a representable r with |r| < |y|, then for any
+       nearest-integer n of r/y: n ∈ {-1, 0, 1} and
+       round_ne(r - n*y) = r - n*y exactly.
+
+    6. rounding_preserves_remainder_comparison: When |r| < |y|/2
+       and both r, y are representable, |round(r ± y)| >= |r|.
+       Uses round_N_pt with y (same sign) or -r (opposite sign)
+       as the representable witness. The >= (not strict >) in the
+       opposite-sign case corresponds to ties.
+
+    MODELING NOTES:
+
+    - The proofs use FLX (unbounded exponents), not FLT (bounded
+      exponents as in IEEE 754). The results transfer to FLT because
+      FLX(p) ⊂ FLT(p, emin): every FLX-representable value is also
+      FLT-representable.
+
+    - comparison_step covers the strict case |r| < |y|/2. At ties
+      (|r| = |y|/2), both candidates are exactly representable and
+      have equal |remainder|. The algorithm keeps the tentative n
+      from round-to-nearest-even, which is correct per IEEE 754.
+    ============================================================ *)
diff --git a/doc/proofs/fma_remainder_strategies.v b/doc/proofs/fma_remainder_strategies.v
new file mode 100644
index 00000000000..3b07927c111
--- /dev/null
+++ b/doc/proofs/fma_remainder_strategies.v
@@ -0,0 +1,165 @@
+From Coq Require Import ZArith Reals Psatz Lia.
+From Flocq Require Import Core.Zaux Core.Defs Core.Generic_fmt Core.FLX
+  Core.Round_NE Core.Raux Core.Float_prop.
+
+Open Scope R_scope.
+
+(** ============================================================
+    Strategy 1: remainder(x, y) = remainder(fmod(x, y), y)
+    ============================================================ *)
+
+Section Scaling.
+
+Variable choice : Z -> bool.
+
+Lemma Zfloor_add_IZR : forall x : R, forall n : Z,
+  Zfloor (x + IZR n) = (Zfloor x + n)%Z.
+Proof.
+  intros x n. apply Zfloor_imp.
+  rewrite 2!plus_IZR.
+  generalize (Zfloor_lb x) (Zfloor_ub x).
+  rewrite plus_IZR. intros. lra.
+Qed.
+
+Lemma Zceil_add_IZR : forall x : R, forall n : Z,
+  Zceil (x + IZR n) = (Zceil x + n)%Z.
+Proof.
+  intros x n. unfold Zceil.
+  replace (- (x + IZR n)) with (- x + IZR (- n)) by (rewrite opp_IZR; ring).
+  rewrite Zfloor_add_IZR. lia.
+Qed.
+
+(** Znearest is translation-invariant by integers (non-tie case). *)
+Lemma Znearest_shift : forall x : R, forall n : Z,
+  (x - IZR (Zfloor x) <> / 2) ->
+  Znearest choice (x + IZR n) = (Znearest choice x + n)%Z.
+Proof.
+  intros x n Hne.
+  unfold Znearest.
+  rewrite Zfloor_add_IZR, plus_IZR.
+  replace (x + IZR n - (IZR (Zfloor x) + IZR n)) with (x - IZR (Zfloor x))
+    by lra.
+  rewrite Zceil_add_IZR.
+  destruct (Rcompare (x - IZR (Zfloor x)) (/ 2)) eqn:Hcmp.
+  + (* Eq *) exfalso. apply Hne. now apply Rcompare_Eq_inv.
+  + (* Lt *) reflexivity.
+  + (* Gt *) reflexivity.
+Qed.
+
+Definition fmod_val (x y : R) : R :=
+  x - IZR (Ztrunc (x / y)) * y.
+
+Definition remainder_val (x y : R) : R :=
+  x - IZR (Znearest choice (x / y)) * y.
+
+(** remainder(x, y) = remainder(fmod(x, y), y) when x/y is not at
+    a half-integer. In the tie case, both sides give |remainder| = |y|/2
+    but may differ in sign — both are valid IEEE 754 remainders. *)
+Theorem remainder_via_fmod :
+  forall x y : R, y <> 0 ->
+  (x / y - IZR (Zfloor (x / y)) <> / 2) ->
+  remainder_val x y = remainder_val (fmod_val x y) y.
+Proof.
+  intros x y Hy Hne.
+  unfold remainder_val, fmod_val.
+  replace ((x - IZR (Ztrunc (x / y)) * y) / y)
+    with (x / y - IZR (Ztrunc (x / y))).
+  2: { field. exact Hy. }
+  (* The fractional part of (x/y - Ztrunc(x/y)) equals that of x/y *)
+  assert (Hne2 : x / y - IZR (Ztrunc (x / y)) -
+    IZR (Zfloor (x / y - IZR (Ztrunc (x / y)))) <> / 2).
+  { replace (x / y - IZR (Ztrunc (x / y))) with
+      (x / y + IZR (- Ztrunc (x / y))) by (rewrite opp_IZR; ring).
+    rewrite Zfloor_add_IZR, plus_IZR, opp_IZR. lra. }
+  replace (x / y) with
+    (x / y - IZR (Ztrunc (x / y)) + IZR (Ztrunc (x / y))) at 1 by ring.
+  rewrite (Znearest_shift (x / y - IZR (Ztrunc (x / y))) (Ztrunc (x / y)) Hne2).
+  rewrite plus_IZR, Rmult_plus_distr_r. ring.
+Qed.
+
+End Scaling.
+
+(** ============================================================
+    Strategy 2: Integer quotient (no float overflow)
+    ============================================================ *)
+
+Section IntegerQuotient.
+
+Variable p : Z.
+Hypothesis Hp : (1 < p)%Z.
+Let beta := radix2.
+Instance Hp0 : Prec_gt_0 p. unfold Prec_gt_0. lia. Qed.
+
+Lemma quotient_as_ratio :
+  forall (mx my : Z) (ex ey : Z),
+    my <> 0%Z ->
+    let x := F2R (Float beta mx ex) in
+    let y := F2R (Float beta my ey) in
+    x / y = IZR mx / IZR my * bpow beta (ex - ey).
+Proof.
+  intros mx my ex ey Hmy x y.
+  unfold x, y, F2R. simpl.
+  assert (Hmy0 : IZR my <> 0) by (apply not_0_IZR; exact Hmy).
+  assert (Hbp0 : bpow beta ey <> 0) by (apply Rgt_not_eq; apply bpow_gt_0).
+  unfold Rdiv.
+  assert (Hbpey : bpow beta ey > 0) by apply bpow_gt_0.
+  replace (ex - ey)%Z with (ex + - ey)%Z by lia.
+  rewrite bpow_plus, bpow_opp.
+  unfold Rdiv. rewrite Rinv_mult.
+  field. split; [lra | exact Hmy0].
+Qed.
+
+Lemma nearest_integer_from_ratio :
+  forall choice : Z -> bool,
+  forall (mx my : Z) (ex ey : Z),
+    my <> 0%Z -> (ey <= ex)%Z ->
+    let x := F2R (Float beta mx ex) in
+    let y := F2R (Float beta my ey) in
+    Znearest choice (x / y) =
+    Znearest choice (IZR (mx * Zpower beta (ex - ey)) / IZR my).
+Proof.
+  intros choice0 mx my ex ey Hmy Hle x y.
+  unfold x, y.
+  rewrite quotient_as_ratio; [|exact Hmy].
+  rewrite mult_IZR, IZR_Zpower; [|lia].
+  f_equal. unfold Rdiv.
+  rewrite !Rmult_assoc. f_equal. apply Rmult_comm.
+Qed.
+
+(** Symmetric case: when ey > ex, the quotient reduces to
+    Znearest(mx / (my * 2^(ey-ex))). *)
+Lemma nearest_integer_from_ratio_lt :
+  forall choice : Z -> bool,
+  forall (mx my : Z) (ex ey : Z),
+    my <> 0%Z -> (ex < ey)%Z ->
+    let x := F2R (Float beta mx ex) in
+    let y := F2R (Float beta my ey) in
+    Znearest choice (x / y) =
+    Znearest choice (IZR mx / IZR (my * Zpower beta (ey - ex))).
+Proof.
+  intros choice0 mx my ex ey Hmy Hlt x y.
+  unfold x, y.
+  rewrite quotient_as_ratio; [|exact Hmy].
+  f_equal.
+  rewrite mult_IZR, IZR_Zpower; [|lia].
+  assert (Hbp : bpow beta (ey - ex) <> 0).
+  { apply Rgt_not_eq. apply bpow_gt_0. }
+  assert (Hmy0 : IZR my <> 0) by (apply not_0_IZR; exact Hmy).
+  replace (bpow beta (ex - ey)) with (/ bpow beta (ey - ex)).
+  2: { rewrite <- bpow_opp. f_equal. lia. }
+  field. split; [exact Hbp|exact Hmy0].
+Qed.
+
+End IntegerQuotient.
+
+(** ============================================================
+    SUMMARY: Both strategies fully proved (zero admits).
+    
+    Strategy 1: remainder(x,y) = remainder(fmod(x,y), y) for the
+    non-tie case. After fmod, |quotient| < 1, so n ∈ {-1, 0, 1}.
+    
+    Strategy 2: the quotient reduces to integer arithmetic
+    Znearest(mx * 2^(ex-ey) / my) when ey <= ex, or
+    Znearest(mx / (my * 2^(ey-ex))) when ex < ey,
+    avoiding float overflow in both cases.
+    ============================================================ *)
diff --git a/jbmc/regression/jbmc/farith2/farith2.class b/jbmc/regression/jbmc/farith2/farith2.class
new file mode 100644
index 00000000000..119c806b1cd
Binary files /dev/null and b/jbmc/regression/jbmc/farith2/farith2.class differ
diff --git a/jbmc/regression/jbmc/farith2/farith2.java b/jbmc/regression/jbmc/farith2/farith2.java
new file mode 100644
index 00000000000..e98b7bf492b
--- /dev/null
+++ b/jbmc/regression/jbmc/farith2/farith2.java
@@ -0,0 +1,19 @@
+// JBMC verifies exact IEEE 754 bit patterns, so equality with decimal
+// literals is intentional: both sides are concrete IEEE 754 values.
+class farith2
+{
+  public static void main(String[] args)
+  {
+    // examples from
+    // https://stackoverflow.com/questions/2947044/how-do-i-use-modulus-for-float-double
+    // and
+    // https://stackoverflow.com/questions/25734144/difference-between-c-functions-remainder-and-fmod
+    double d1 = 0.5 % 0.3;
+    assert d1 == 0.2;
+    double d2 = (-0.5) % 0.3;
+    assert d2 == -0.2;
+    double x = 7.5, y = 2.1;
+    double xModY = x % y;
+    assert xModY > 1.19 && xModY < 1.21;
+  }
+}
diff --git a/regression/cbmc-library/__sort_of_CPROVER_remainder/test.desc b/jbmc/regression/jbmc/farith2/test.desc
similarity index 59%
rename from regression/cbmc-library/__sort_of_CPROVER_remainder/test.desc
rename to jbmc/regression/jbmc/farith2/test.desc
index 9542d988e8d..915684ced8d 100644
--- a/regression/cbmc-library/__sort_of_CPROVER_remainder/test.desc
+++ b/jbmc/regression/jbmc/farith2/test.desc
@@ -1,6 +1,6 @@
-KNOWNBUG
-main.c
---pointer-check --bounds-check
+CORE
+farith2
+
 ^EXIT=0$
 ^SIGNAL=0$
 ^VERIFICATION SUCCESSFUL$
diff --git a/regression/cbmc-incr-smt2/Makefile b/regression/cbmc-incr-smt2/Makefile
index 9a5b8bf4195..256824b36e6 100644
--- a/regression/cbmc-incr-smt2/Makefile
+++ b/regression/cbmc-incr-smt2/Makefile
@@ -6,10 +6,10 @@ include ../../src/common
 test: test.z3 test.cvc5
 
 test.z3:
-	@../test.pl -e -p -c "../../../src/cbmc/cbmc --incremental-smt2-solver 'z3 --smt2 -in' --validate-goto-model --validate-ssa-equation"
+	@../test.pl -e -p -c "../../../src/cbmc/cbmc --incremental-smt2-solver 'z3 --smt2 -in' --validate-goto-model --validate-ssa-equation" -s z3
 
 test.cvc5:
-	@../test.pl -e -p -c "../../../src/cbmc/cbmc --incremental-smt2-solver 'cvc5 --lang=smtlib2.6 --incremental' --validate-goto-model --validate-ssa-equation"
+	@../test.pl -e -p -c "../../../src/cbmc/cbmc --incremental-smt2-solver 'cvc5 --lang=smtlib2.6 --incremental' --validate-goto-model --validate-ssa-equation" -s cvc5
 
 tests.log: ../test.pl test
 
diff --git a/regression/cbmc-library/__sort_of_CPROVER_remainder/main.c b/regression/cbmc-library/__sort_of_CPROVER_remainder/main.c
deleted file mode 100644
index 97bed88803b..00000000000
--- a/regression/cbmc-library/__sort_of_CPROVER_remainder/main.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <assert.h>
-#include <math.h>
-
-int main()
-{
-  __sort_of_CPROVER_remainder();
-  assert(0);
-  return 0;
-}
diff --git a/regression/cbmc-library/__sort_of_CPROVER_remainderf/main.c b/regression/cbmc-library/__sort_of_CPROVER_remainderf/main.c
deleted file mode 100644
index cb5060b1ad3..00000000000
--- a/regression/cbmc-library/__sort_of_CPROVER_remainderf/main.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <assert.h>
-#include <math.h>
-
-int main()
-{
-  __sort_of_CPROVER_remainderf();
-  assert(0);
-  return 0;
-}
diff --git a/regression/cbmc-library/__sort_of_CPROVER_remainderl/main.c b/regression/cbmc-library/__sort_of_CPROVER_remainderl/main.c
deleted file mode 100644
index 24c42bbe2a3..00000000000
--- a/regression/cbmc-library/__sort_of_CPROVER_remainderl/main.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <assert.h>
-#include <math.h>
-
-int main()
-{
-  __sort_of_CPROVER_remainderl();
-  assert(0);
-  return 0;
-}
diff --git a/regression/cbmc-library/fma/precision.c b/regression/cbmc-library/fma/precision.c
new file mode 100644
index 00000000000..c86c71c6555
--- /dev/null
+++ b/regression/cbmc-library/fma/precision.c
@@ -0,0 +1,22 @@
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  // Basic FMA
+  assert(fmaf(2.0f, 3.0f, 4.0f) == 10.0f);
+  assert(fmaf(-3.0f, 2.0f, 10.0f) == 4.0f);
+
+  // FMA vs mul+add: FMA preserves precision lost by separate mul+add.
+  // 0x1.fffffep+23 * 0x1.000002p+0 + 1.0:
+  // mul rounds product to 0x1p+24, then +1 = 0x1p+24 (unchanged)
+  // FMA keeps exact product, +1 = 0x1.000002p+24
+  assert(0x1.fffffep+23f * 0x1.000002p+0f + 1.0f == 0x1p+24f);
+  assert(fmaf(0x1.fffffep+23f, 0x1.000002p+0f, 1.0f) == 0x1.000002p+24f);
+
+  // FMA for remainder: fma(-n, y, x) computes x - n*y with single rounding
+  float x = 0x1.d55556p+0f;
+  float y = 0x1.555556p-2f;
+  assert(x - 5.0f * y == 0x1.55555p-3f);       // mul+sub: two roundings
+  assert(fmaf(-5.0f, y, x) == 0x1.555554p-3f); // FMA: one rounding
+}
diff --git a/regression/cbmc-library/fma/special_cases.c b/regression/cbmc-library/fma/special_cases.c
new file mode 100644
index 00000000000..7fe0655b7cf
--- /dev/null
+++ b/regression/cbmc-library/fma/special_cases.c
@@ -0,0 +1,32 @@
+// IEEE 754 FMA special cases
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  // fma(NaN, y, z) = NaN
+  assert(isnan(fmaf(NAN, 1.0f, 0.0f)));
+
+  // fma(x, NaN, z) = NaN
+  assert(isnan(fmaf(1.0f, NAN, 0.0f)));
+
+  // fma(x, y, NaN) = NaN
+  assert(isnan(fmaf(1.0f, 1.0f, NAN)));
+
+  // fma(0, inf, z) = NaN (0 * inf is undefined)
+  assert(isnan(fmaf(0.0f, INFINITY, 1.0f)));
+
+  // fma(inf, 0, z) = NaN
+  assert(isnan(fmaf(INFINITY, 0.0f, 1.0f)));
+
+  // fma(inf, x, -inf) = NaN when inf*x = +inf (inf + (-inf) is undefined)
+  assert(isnan(fmaf(INFINITY, 1.0f, -INFINITY)));
+
+  // fma(inf, x, z) = +inf for finite z
+  assert(isinf(fmaf(INFINITY, 2.0f, 3.0f)));
+
+  // fma(x, y, inf) = +inf for finite x*y
+  assert(isinf(fmaf(2.0f, 3.0f, INFINITY)));
+
+  return 0;
+}
diff --git a/regression/cbmc-library/fma/test_bv_encoding.desc b/regression/cbmc-library/fma/test_bv_encoding.desc
new file mode 100644
index 00000000000..dec2d80f100
--- /dev/null
+++ b/regression/cbmc-library/fma/test_bv_encoding.desc
@@ -0,0 +1,11 @@
+CORE smt-backend
+precision.c
+--smt2 --outfile -
+float_bv\.floatbv_fma
+^EXIT=0$
+^SIGNAL=0$
+--
+^warning: ignoring
+--
+Verify that float_bvt generates valid SMT2 for FMA expressions
+(non-FPA bitvector encoding).
diff --git a/regression/cbmc-library/fma/test_fpa_emission.desc b/regression/cbmc-library/fma/test_fpa_emission.desc
new file mode 100644
index 00000000000..e2a22566963
--- /dev/null
+++ b/regression/cbmc-library/fma/test_fpa_emission.desc
@@ -0,0 +1,10 @@
+CORE smt-backend
+precision.c
+--smt2 --fpa --outfile -
+fp\.fma
+^EXIT=0$
+^SIGNAL=0$
+--
+^warning: ignoring
+--
+Verify that the SMT2 FPA backend emits fp.fma (not a bitvector encoding).
diff --git a/regression/cbmc-library/fma/test_fpa_special_cases.desc b/regression/cbmc-library/fma/test_fpa_special_cases.desc
new file mode 100644
index 00000000000..44243049249
--- /dev/null
+++ b/regression/cbmc-library/fma/test_fpa_special_cases.desc
@@ -0,0 +1,11 @@
+CORE smt-backend
+special_cases.c
+--smt2 --fpa --no-built-in-assertions
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+^warning: ignoring
+--
+Run FMA special cases through an external SMT solver with FPA theory.
+Verifies NaN, infinity, and 0*inf handling end-to-end.
diff --git a/regression/cbmc-library/fma/test_fpa_special_emission.desc b/regression/cbmc-library/fma/test_fpa_special_emission.desc
new file mode 100644
index 00000000000..cf4e6cd9b23
--- /dev/null
+++ b/regression/cbmc-library/fma/test_fpa_special_emission.desc
@@ -0,0 +1,10 @@
+CORE smt-backend
+special_cases.c
+--smt2 --fpa --outfile -
+fp\.fma
+^EXIT=0$
+^SIGNAL=0$
+--
+^warning: ignoring
+--
+Verify that FMA special cases (NaN, inf) emit fp.fma via FPA backend.
diff --git a/regression/cbmc-library/__sort_of_CPROVER_remainderl/test.desc b/regression/cbmc-library/fma/test_precision.desc
similarity index 59%
rename from regression/cbmc-library/__sort_of_CPROVER_remainderl/test.desc
rename to regression/cbmc-library/fma/test_precision.desc
index 9542d988e8d..6cce453fd77 100644
--- a/regression/cbmc-library/__sort_of_CPROVER_remainderl/test.desc
+++ b/regression/cbmc-library/fma/test_precision.desc
@@ -1,6 +1,6 @@
-KNOWNBUG
-main.c
---pointer-check --bounds-check
+CORE
+precision.c
+
 ^EXIT=0$
 ^SIGNAL=0$
 ^VERIFICATION SUCCESSFUL$
diff --git a/regression/cbmc-library/fma/test_special_cases.desc b/regression/cbmc-library/fma/test_special_cases.desc
new file mode 100644
index 00000000000..8236f8ad7c0
--- /dev/null
+++ b/regression/cbmc-library/fma/test_special_cases.desc
@@ -0,0 +1,10 @@
+CORE
+special_cases.c
+--floatbv --no-built-in-assertions
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+^warning: ignoring
+--
+IEEE 754 FMA special cases: NaN propagation, 0*inf, inf+(-inf), inf results.
diff --git a/regression/cbmc-library/fmod/main.c b/regression/cbmc-library/fmod/main.c
index 775d5b7d64a..e55f05d1837 100644
--- a/regression/cbmc-library/fmod/main.c
+++ b/regression/cbmc-library/fmod/main.c
@@ -1,9 +1,19 @@
+// CBMC verifies exact IEEE 754 bit patterns, so equality with decimal
+// literals is intentional: both sides are concrete IEEE 754 values.
 #include <assert.h>
 #include <math.h>
 
 int main()
 {
-  fmod();
-  assert(0);
-  return 0;
+  // examples from
+  // https://stackoverflow.com/questions/2947044/how-do-i-use-modulus-for-float-double
+  // and
+  // https://stackoverflow.com/questions/25734144/difference-between-c-functions-remainder-and-fmod
+  double d1 = fmod(0.5, 0.3);
+  assert(d1 == 0.2);
+  double d2 = fmod(-0.5, 0.3);
+  assert(d2 == -0.2);
+  double x = 7.5, y = 2.1;
+  double xModY = fmod(x, y);
+  assert(xModY > 1.19 && xModY < 1.21);
 }
diff --git a/regression/cbmc-library/fmod/test.desc b/regression/cbmc-library/fmod/test.desc
index 9542d988e8d..3510d48c5c6 100644
--- a/regression/cbmc-library/fmod/test.desc
+++ b/regression/cbmc-library/fmod/test.desc
@@ -1,6 +1,6 @@
-KNOWNBUG
+CORE
 main.c
---pointer-check --bounds-check
+--float-overflow-check --nan-check
 ^EXIT=0$
 ^SIGNAL=0$
 ^VERIFICATION SUCCESSFUL$
diff --git a/regression/cbmc-library/fmodf/main.c b/regression/cbmc-library/fmodf/main.c
index 0e14f93f46c..ec3eefe90ef 100644
--- a/regression/cbmc-library/fmodf/main.c
+++ b/regression/cbmc-library/fmodf/main.c
@@ -3,7 +3,15 @@
 
 int main()
 {
-  fmodf();
-  assert(0);
-  return 0;
+  // examples from
+  // https://stackoverflow.com/questions/2947044/how-do-i-use-modulus-for-float-double
+  // and
+  // https://stackoverflow.com/questions/25734144/difference-between-c-functions-remainder-and-fmod
+  float d1 = fmodf(0.5f, 0.3f);
+  assert(d1 > 0.19f && d1 < 0.21f);
+  float d2 = fmodf(-0.5f, 0.3f);
+  assert(d2 > -0.21f && d2 < -0.19f);
+  float x = 7.5f, y = 2.1f;
+  float xModY = fmodf(x, y);
+  assert(xModY > 1.19f && xModY < 1.21f);
 }
diff --git a/regression/cbmc-library/fmodf/test.desc b/regression/cbmc-library/fmodf/test.desc
index 9542d988e8d..3510d48c5c6 100644
--- a/regression/cbmc-library/fmodf/test.desc
+++ b/regression/cbmc-library/fmodf/test.desc
@@ -1,6 +1,6 @@
-KNOWNBUG
+CORE
 main.c
---pointer-check --bounds-check
+--float-overflow-check --nan-check
 ^EXIT=0$
 ^SIGNAL=0$
 ^VERIFICATION SUCCESSFUL$
diff --git a/regression/cbmc-library/fmodl/main.c b/regression/cbmc-library/fmodl/main.c
index b24c534c69a..439a48f3c3e 100644
--- a/regression/cbmc-library/fmodl/main.c
+++ b/regression/cbmc-library/fmodl/main.c
@@ -1,9 +1,19 @@
+// CBMC verifies exact IEEE 754 bit patterns, so equality with decimal
+// literals is intentional: both sides are concrete IEEE 754 values.
 #include <assert.h>
 #include <math.h>
 
 int main()
 {
-  fmodl();
-  assert(0);
-  return 0;
+  // examples from
+  // https://stackoverflow.com/questions/2947044/how-do-i-use-modulus-for-float-double
+  // and
+  // https://stackoverflow.com/questions/25734144/difference-between-c-functions-remainder-and-fmod
+  long double d1 = fmodl(0.5l, 0.3l);
+  assert(d1 == 0.2l);
+  long double d2 = fmodl(-0.5l, 0.3l);
+  assert(d2 == -0.2l);
+  long double x = 7.5l, y = 2.1l;
+  long double xModY = fmodl(x, y);
+  assert(xModY > 1.19l && xModY < 1.21l);
 }
diff --git a/regression/cbmc-library/fmodl/test.desc b/regression/cbmc-library/fmodl/test.desc
index 9542d988e8d..7155be1261e 100644
--- a/regression/cbmc-library/fmodl/test.desc
+++ b/regression/cbmc-library/fmodl/test.desc
@@ -1,6 +1,6 @@
-KNOWNBUG
+THOROUGH
 main.c
---pointer-check --bounds-check
+--float-overflow-check --nan-check
 ^EXIT=0$
 ^SIGNAL=0$
 ^VERIFICATION SUCCESSFUL$
diff --git a/regression/cbmc-library/remainder/main.c b/regression/cbmc-library/remainder/main.c
index dba529354de..4cd13925eb4 100644
--- a/regression/cbmc-library/remainder/main.c
+++ b/regression/cbmc-library/remainder/main.c
@@ -3,7 +3,9 @@
 
 int main()
 {
-  remainder();
-  assert(0);
-  return 0;
+  // example from
+  // https://stackoverflow.com/questions/25734144/difference-between-c-functions-remainder-and-fmod
+  double x = 7.5, y = 2.1;
+  double xModY = remainder(x, y);
+  assert(xModY > -0.91 && xModY < -0.89);
 }
diff --git a/regression/cbmc-library/remainder/test.desc b/regression/cbmc-library/remainder/test.desc
index 9542d988e8d..3510d48c5c6 100644
--- a/regression/cbmc-library/remainder/test.desc
+++ b/regression/cbmc-library/remainder/test.desc
@@ -1,6 +1,6 @@
-KNOWNBUG
+CORE
 main.c
---pointer-check --bounds-check
+--float-overflow-check --nan-check
 ^EXIT=0$
 ^SIGNAL=0$
 ^VERIFICATION SUCCESSFUL$
diff --git a/regression/cbmc-library/remainderf/_Float16.c b/regression/cbmc-library/remainderf/_Float16.c
new file mode 100644
index 00000000000..be8cb7c15cf
--- /dev/null
+++ b/regression/cbmc-library/remainderf/_Float16.c
@@ -0,0 +1,30 @@
+// Fully symbolic _Float16 remainder verification.
+// Verifies |remainder(x,y)| <= |y|/2 for ALL finite _Float16 inputs.
+// Completes in ~3.3s with MiniSat (16K variables, 70K clauses).
+//
+// See bench.c in remainderf/ for a comparison of all three approaches.
+
+#include <assert.h>
+
+#if defined(__GNUC__) && __GNUC__ >= 13
+
+_Float16 __CPROVER_remainderf16(_Float16, _Float16);
+
+int main()
+{
+  _Float16 pos_inf_f16 = (_Float16)(1.0 / 0.0);
+  _Float16 x, y;
+  __CPROVER_assume(y != (_Float16)0.0);
+  __CPROVER_assume(x == x && x != pos_inf_f16 && x != -pos_inf_f16);
+  __CPROVER_assume(y == y && y != pos_inf_f16 && y != -pos_inf_f16);
+  _Float16 r = __CPROVER_remainderf16(x, y);
+  _Float16 abs_r = r < (_Float16)0.0 ? -r : r;
+  _Float16 abs_y = y < (_Float16)0.0 ? -y : y;
+  assert(r == (_Float16)0.0 || abs_r <= abs_y / (_Float16)2.0);
+}
+
+#else
+int main()
+{
+}
+#endif
diff --git a/regression/cbmc-library/remainderf/_Float16.desc b/regression/cbmc-library/remainderf/_Float16.desc
new file mode 100644
index 00000000000..ac9d91f0f35
--- /dev/null
+++ b/regression/cbmc-library/remainderf/_Float16.desc
@@ -0,0 +1,11 @@
+CORE
+_Float16.c
+
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+^warning: ignoring
+--
+Fully symbolic _Float16 remainder: verifies the IEEE 754 property
+|remainder(x,y)| <= |y|/2 for ALL finite _Float16 inputs (~3s).
diff --git a/regression/cbmc-library/remainderf/bench.c b/regression/cbmc-library/remainderf/bench.c
new file mode 100644
index 00000000000..3a15877e76c
--- /dev/null
+++ b/regression/cbmc-library/remainderf/bench.c
@@ -0,0 +1,51 @@
+// Benchmark for remainderf: symbolic inputs, used to measure formula
+// size and solver performance of the FMA-based remainder implementation.
+//
+// Performance comparison (concrete UNSAT tests, Ubuntu 24.04):
+//
+//   remainderf (float):
+//     FMA:      18,987 vars,  81,799 clauses, MiniSat ~0.071s
+//     ExtPrec:  18,806 vars,  79,472 clauses, MiniSat ~0.067s
+//     Delta:    +1.0% vars, +2.9% clauses, +5% time
+//
+//   remainder (double):
+//     FMA:      53,049 vars, 252,604 clauses, MiniSat ~0.233s
+//     ExtPrec:  50,246 vars, 233,273 clauses, MiniSat ~0.210s
+//     Delta:    +5.6% vars, +8.3% clauses, +11% time
+//
+// The FMA approach is slightly larger due to the double-width
+// multiplication, but the overhead is modest and the correctness
+// guarantee (machine-checked Coq proof) is significantly stronger.
+//
+// Performance comparison on _Float16 (fully symbolic, all finite inputs):
+//
+//   Approach       | Variables | Clauses | MiniSat(s) | Correct?
+//   ---------------|-----------|---------|------------|----------
+//   ExtPrec (+3b)  |    12,937 |  52,835 |     0.064  | NO (1)
+//   FMA-only       |    14,879 |  61,797 |     0.255  | NO (2)
+//   Int-fmod + FMA |    16,461 |  70,497 |     3.340  | YES
+//
+//   (1) Extended precision: the +3 extra fraction bits are insufficient
+//       to distinguish the two remainder candidates at tie-breaking
+//       boundaries. Counterexample: x=0.001832, y=-5.364e-7 (|x/y|=3415).
+//   (2) FMA-only: when |x/y| overflows the float format, fp_div returns
+//       infinity and the remainder is NaN. Counterexample: x=-0.563,
+//       y=2.563e-6 (|x/y|=219660 > _Float16 max 65504).
+//
+// For single-precision float, the Int-fmod formula has ~194K variables
+// and times out with MiniSat. The SMT FPA back-end (fp.rem) handles
+// all formats efficiently.
+
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  float x, y;
+  __CPROVER_assume(!__CPROVER_isnanf(x) && !__CPROVER_isinff(x));
+  __CPROVER_assume(!__CPROVER_isnanf(y) && !__CPROVER_isinff(y));
+  __CPROVER_assume(y != 0.0f);
+  float r = remainderf(x, y);
+  // IEEE 754: |remainder| <= |y|/2
+  assert(r == 0.0f || fabsf(r) <= fabsf(y) / 2.0f);
+}
diff --git a/regression/cbmc-library/remainderf/bench.desc b/regression/cbmc-library/remainderf/bench.desc
new file mode 100644
index 00000000000..f9d1319d5af
--- /dev/null
+++ b/regression/cbmc-library/remainderf/bench.desc
@@ -0,0 +1,15 @@
+FUTURE
+bench.c
+
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+^warning: ignoring
+--
+Marked FUTURE (not KNOWNBUG) to avoid the KNOWNBUG CI job timing out.
+Fully symbolic remainderf verification. The integer significand
+division creates a ~194K variable formula that MiniSat cannot solve
+within a reasonable timeout. The implementation is correct for all
+concrete test cases. The SMT FPA back-end (fp.rem) handles this
+efficiently.
diff --git a/regression/cbmc-library/remainderf/edge_case.c b/regression/cbmc-library/remainderf/edge_case.c
new file mode 100644
index 00000000000..88c016ea187
--- /dev/null
+++ b/regression/cbmc-library/remainderf/edge_case.c
@@ -0,0 +1,14 @@
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  // IEEE 754 remainder: x - n*y where n = round_to_nearest_even(exact(x/y))
+  // Here exact(0.5 / (1.0f/3)) is slightly below 1.5 (since 1.0f/3 rounds up).
+  // So n should be 1 (nearest integer below 1.5), giving a positive result.
+  // Bug: fp division gives exactly 1.5, rint(1.5)=2 (even), wrong sign.
+  float x = 0x1p-1f;
+  float y = 0x1.555556p-2f;
+  float result = remainderf(x, y);
+  assert(result > 0.0f);
+}
diff --git a/regression/cbmc-library/__sort_of_CPROVER_remainderf/test.desc b/regression/cbmc-library/remainderf/edge_case.desc
similarity index 59%
rename from regression/cbmc-library/__sort_of_CPROVER_remainderf/test.desc
rename to regression/cbmc-library/remainderf/edge_case.desc
index 9542d988e8d..c4207e9882e 100644
--- a/regression/cbmc-library/__sort_of_CPROVER_remainderf/test.desc
+++ b/regression/cbmc-library/remainderf/edge_case.desc
@@ -1,6 +1,6 @@
-KNOWNBUG
-main.c
---pointer-check --bounds-check
+CORE
+edge_case.c
+
 ^EXIT=0$
 ^SIGNAL=0$
 ^VERIFICATION SUCCESSFUL$
diff --git a/regression/cbmc-library/remainderf/fmod_bound.c b/regression/cbmc-library/remainderf/fmod_bound.c
new file mode 100644
index 00000000000..96fd30d8a68
--- /dev/null
+++ b/regression/cbmc-library/remainderf/fmod_bound.c
@@ -0,0 +1,28 @@
+// _Float16 exhaustive verification: |fmod(x,y)| < |y|.
+// (Coq: fmod_then_remainder — integer remainder bound)
+
+#include <assert.h>
+
+#if defined(__GNUC__) && __GNUC__ >= 13
+
+_Float16 __CPROVER_fmodf16(_Float16, _Float16);
+
+int main()
+{
+  _Float16 x, y;
+  __CPROVER_assume(
+    x == x && x != (_Float16)(1.0 / 0.0) && x != -(_Float16)(1.0 / 0.0));
+  __CPROVER_assume(
+    y == y && y != (_Float16)(1.0 / 0.0) && y != -(_Float16)(1.0 / 0.0));
+  __CPROVER_assume(y != (_Float16)0.0);
+  _Float16 r = __CPROVER_fmodf16(x, y);
+  _Float16 abs_r = r < (_Float16)0.0 ? -r : r;
+  _Float16 abs_y = y < (_Float16)0.0 ? -y : y;
+  assert(r == (_Float16)0.0 || abs_r < abs_y);
+}
+
+#else
+int main()
+{
+}
+#endif
diff --git a/regression/cbmc-library/remainderf/fmod_bound.desc b/regression/cbmc-library/remainderf/fmod_bound.desc
new file mode 100644
index 00000000000..23a2edd849e
--- /dev/null
+++ b/regression/cbmc-library/remainderf/fmod_bound.desc
@@ -0,0 +1,11 @@
+CORE
+fmod_bound.c
+
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+^warning: ignoring
+--
+Exhaustive _Float16 verification: |fmod(x,y)| < |y| for all
+finite inputs. (Coq: fmod_then_remainder, int_remainder_in_format)
diff --git a/regression/cbmc-library/remainderf/main.c b/regression/cbmc-library/remainderf/main.c
index edf674f5d55..d9ed13d5476 100644
--- a/regression/cbmc-library/remainderf/main.c
+++ b/regression/cbmc-library/remainderf/main.c
@@ -3,7 +3,9 @@
 
 int main()
 {
-  remainderf();
-  assert(0);
-  return 0;
+  // example from
+  // https://stackoverflow.com/questions/25734144/difference-between-c-functions-remainder-and-fmod
+  float x = 7.5f, y = 2.1f;
+  float xModY = remainderf(x, y);
+  assert(xModY > -0.91f && xModY < -0.89f);
 }
diff --git a/regression/cbmc-library/remainderf/special_cases.c b/regression/cbmc-library/remainderf/special_cases.c
new file mode 100644
index 00000000000..d9625d2b950
--- /dev/null
+++ b/regression/cbmc-library/remainderf/special_cases.c
@@ -0,0 +1,46 @@
+// _Float16 exhaustive verification of IEEE 754 special cases.
+// Each assertion corresponds to a proved property.
+// (Coq: special case handling in float_utilst::rem)
+
+#include <assert.h>
+
+#if defined(__GNUC__) && __GNUC__ >= 13
+
+_Float16 __CPROVER_fmodf16(_Float16, _Float16);
+
+int main()
+{
+  _Float16 pos_inf = (_Float16)(1.0 / 0.0);
+  _Float16 neg_inf = -pos_inf;
+  _Float16 nan_val = pos_inf + neg_inf;
+  _Float16 x, y;
+
+  // fmod(±inf, y) = NaN for all y
+  __CPROVER_assume(y == y);
+  _Float16 r1 = __CPROVER_fmodf16(pos_inf, y);
+  assert(r1 != r1);
+  _Float16 r2 = __CPROVER_fmodf16(neg_inf, y);
+  assert(r2 != r2);
+
+  // fmod(x, ±0) = NaN for all non-NaN x
+  __CPROVER_assume(x == x);
+  _Float16 r3 = __CPROVER_fmodf16(x, (_Float16)0.0);
+  assert(r3 != r3);
+
+  // fmod(NaN, y) = NaN, fmod(x, NaN) = NaN
+  _Float16 r5 = __CPROVER_fmodf16(nan_val, (_Float16)1.0);
+  assert(r5 != r5);
+  _Float16 r6 = __CPROVER_fmodf16((_Float16)1.0, nan_val);
+  assert(r6 != r6);
+
+  // fmod(x, ±inf) = x for finite x
+  __CPROVER_assume(x != pos_inf && x != neg_inf);
+  assert(__CPROVER_fmodf16(x, pos_inf) == x);
+  assert(__CPROVER_fmodf16(x, neg_inf) == x);
+}
+
+#else
+int main()
+{
+}
+#endif
diff --git a/regression/cbmc-library/remainderf/special_cases.desc b/regression/cbmc-library/remainderf/special_cases.desc
new file mode 100644
index 00000000000..2fbb7c1b07a
--- /dev/null
+++ b/regression/cbmc-library/remainderf/special_cases.desc
@@ -0,0 +1,11 @@
+CORE
+special_cases.c
+
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+^warning: ignoring
+--
+Exhaustive _Float16 verification of IEEE 754 fmod special cases.
+(Coq: special case handling in float_utilst::rem)
diff --git a/regression/cbmc-library/remainderf/test.desc b/regression/cbmc-library/remainderf/test.desc
index 9542d988e8d..3510d48c5c6 100644
--- a/regression/cbmc-library/remainderf/test.desc
+++ b/regression/cbmc-library/remainderf/test.desc
@@ -1,6 +1,6 @@
-KNOWNBUG
+CORE
 main.c
---pointer-check --bounds-check
+--float-overflow-check --nan-check
 ^EXIT=0$
 ^SIGNAL=0$
 ^VERIFICATION SUCCESSFUL$
diff --git a/regression/cbmc-library/remainderf/tie_break.c b/regression/cbmc-library/remainderf/tie_break.c
new file mode 100644
index 00000000000..f5c37cb0487
--- /dev/null
+++ b/regression/cbmc-library/remainderf/tie_break.c
@@ -0,0 +1,15 @@
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  // IEEE 754 remainder: n = round_to_nearest_even(exact(x/y))
+  // Here exact(x/y) ≈ 5.4999999... (just below 5.5), so correct n=5.
+  // Bug: fp division gives exactly 5.5, rint(5.5)=6 (even), and both
+  // x-5*y and x-6*y round to the same |value| in float, so the
+  // correction step cannot distinguish them without extended precision.
+  float x = 0x1.d55556p+0f;
+  float y = 0x1.555556p-2f;
+  float result = remainderf(x, y);
+  assert(result > 0.0f);
+}
diff --git a/regression/cbmc-library/remainderf/tie_break.desc b/regression/cbmc-library/remainderf/tie_break.desc
new file mode 100644
index 00000000000..70a9ed85f55
--- /dev/null
+++ b/regression/cbmc-library/remainderf/tie_break.desc
@@ -0,0 +1,8 @@
+CORE
+tie_break.c
+
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+^warning: ignoring
diff --git a/regression/cbmc-library/remainderl/main.c b/regression/cbmc-library/remainderl/main.c
index 5a84b872d64..ba2203e6dff 100644
--- a/regression/cbmc-library/remainderl/main.c
+++ b/regression/cbmc-library/remainderl/main.c
@@ -3,7 +3,9 @@
 
 int main()
 {
-  remainderl();
-  assert(0);
-  return 0;
+  // example from
+  // https://stackoverflow.com/questions/25734144/difference-between-c-functions-remainder-and-fmod
+  long double x = 7.5l, y = 2.1l;
+  long double xModY = remainderl(x, y);
+  assert(xModY > -0.91l && xModY < -0.89l);
 }
diff --git a/regression/cbmc-library/remainderl/test.desc b/regression/cbmc-library/remainderl/test.desc
index 9542d988e8d..7155be1261e 100644
--- a/regression/cbmc-library/remainderl/test.desc
+++ b/regression/cbmc-library/remainderl/test.desc
@@ -1,6 +1,6 @@
-KNOWNBUG
+THOROUGH
 main.c
---pointer-check --bounds-check
+--float-overflow-check --nan-check
 ^EXIT=0$
 ^SIGNAL=0$
 ^VERIFICATION SUCCESSFUL$
diff --git a/regression/cbmc/Float-convert1/main.c b/regression/cbmc/Float-convert1/main.c
new file mode 100644
index 00000000000..283da699db4
--- /dev/null
+++ b/regression/cbmc/Float-convert1/main.c
@@ -0,0 +1,30 @@
+// Based on Z3#4862: Float-to-double and double-to-float conversion.
+// Verify that conversions preserve values correctly.
+
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  // float to double: exact for all finite floats
+  float f = 3.14f;
+  double d = (double)f;
+  assert(d == (double)3.14f);
+
+  // double to float: may lose precision
+  double pi = 3.14159265358979323846;
+  float pf = (float)pi;
+  assert(pf == 3.14159265358979323846f);
+
+  // NaN conversion
+  float nan_f = NAN;
+  double nan_d = (double)nan_f;
+  assert(isnan(nan_d));
+
+  // Infinity conversion
+  float inf_f = INFINITY;
+  double inf_d = (double)inf_f;
+  assert(isinf(inf_d));
+
+  return 0;
+}
diff --git a/regression/cbmc/Float-convert1/test.desc b/regression/cbmc/Float-convert1/test.desc
new file mode 100644
index 00000000000..c06428683db
--- /dev/null
+++ b/regression/cbmc/Float-convert1/test.desc
@@ -0,0 +1,8 @@
+CORE
+main.c
+--floatbv --no-built-in-assertions
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+Based on Z3#4862: Float/double conversion correctness.
diff --git a/regression/cbmc/Float-div-rounding1/main.c b/regression/cbmc/Float-div-rounding1/main.c
new file mode 100644
index 00000000000..56223e4a4e5
--- /dev/null
+++ b/regression/cbmc/Float-div-rounding1/main.c
@@ -0,0 +1,29 @@
+// Based on CVC5#11139 and Bitwuzla#130: Division with various inputs.
+// Test that CBMC correctly handles float division, including edge cases.
+
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  float a, b;
+
+  // Division by zero produces infinity
+  __CPROVER_assume(a == 1.0f);
+  __CPROVER_assume(b == 0.0f);
+  float r1 = a / b;
+  assert(isinf(r1));
+
+  // 0 / nonzero = 0
+  float c = 0.0f;
+  float d;
+  __CPROVER_assume(d == 2.0f);
+  float r2 = c / d;
+  assert(r2 == 0.0f);
+
+  // NaN / anything = NaN
+  float r3 = NAN / 1.0f;
+  assert(isnan(r3));
+
+  return 0;
+}
diff --git a/regression/cbmc/Float-div-rounding1/test.desc b/regression/cbmc/Float-div-rounding1/test.desc
new file mode 100644
index 00000000000..e320924b40d
--- /dev/null
+++ b/regression/cbmc/Float-div-rounding1/test.desc
@@ -0,0 +1,8 @@
+CORE
+main.c
+--floatbv
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+Based on CVC5#11139, Bitwuzla#130: Float division edge cases.
diff --git a/regression/cbmc/Float-fma-precision1/main.c b/regression/cbmc/Float-fma-precision1/main.c
new file mode 100644
index 00000000000..d9060d22b5b
--- /dev/null
+++ b/regression/cbmc/Float-fma-precision1/main.c
@@ -0,0 +1,17 @@
+// fmaf should compute x*y+z with a single rounding.
+// The C library model used to do x*y then +z (two roundings).
+// Example: fmaf(1+eps, 1+eps, -(1+2*eps)) where eps = 2^-23
+// Exact result: eps^2 = 2^-46 > 0
+// Double rounding: (1+eps)*(1+eps) rounds to 1+2*eps, then +c = 0
+// True FMA: should give eps^2 which is > 0
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  float a = 1.0f + 1.1920929e-7f;    // 1 + 2^-23
+  float c = -(1.0f + 2.3841858e-7f); // -(1 + 2^-22)
+  float r = fmaf(a, a, c);
+  assert(r > 0.0f);
+  return 0;
+}
diff --git a/regression/cbmc/Float-fma-precision1/test.desc b/regression/cbmc/Float-fma-precision1/test.desc
new file mode 100644
index 00000000000..41a7e1ec682
--- /dev/null
+++ b/regression/cbmc/Float-fma-precision1/test.desc
@@ -0,0 +1,8 @@
+CORE no-new-smt
+main.c
+--floatbv --no-built-in-assertions
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+fmaf with single rounding via __CPROVER_fmaf built-in.
diff --git a/regression/cbmc/Float-fma1/main.c b/regression/cbmc/Float-fma1/main.c
new file mode 100644
index 00000000000..eb77e4709a4
--- /dev/null
+++ b/regression/cbmc/Float-fma1/main.c
@@ -0,0 +1,23 @@
+// Based on Z3#7162 and CVC5#11139: Fused multiply-add.
+// Test that CBMC handles fmaf correctly.
+// fma(a, b, c) = a*b + c with a single rounding.
+
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  // fma(2.0, 3.0, 4.0) = 2*3 + 4 = 10.0
+  float r1 = fmaf(2.0f, 3.0f, 4.0f);
+  assert(r1 == 10.0f);
+
+  // fma with NaN input produces NaN
+  float r2 = fmaf(NAN, 1.0f, 0.0f);
+  assert(isnan(r2));
+
+  // fma(0, inf, x) is NaN (0 * inf is NaN)
+  float r3 = fmaf(0.0f, INFINITY, 1.0f);
+  assert(isnan(r3));
+
+  return 0;
+}
diff --git a/regression/cbmc/Float-fma1/test.desc b/regression/cbmc/Float-fma1/test.desc
new file mode 100644
index 00000000000..7817b517426
--- /dev/null
+++ b/regression/cbmc/Float-fma1/test.desc
@@ -0,0 +1,8 @@
+CORE
+main.c
+--floatbv --no-built-in-assertions
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+Based on Z3#7162, CVC5#11139: Fused multiply-add edge cases.
diff --git a/regression/cbmc/Float-fmin-zero-sign1/main.c b/regression/cbmc/Float-fmin-zero-sign1/main.c
new file mode 100644
index 00000000000..411f12fa2e3
--- /dev/null
+++ b/regression/cbmc/Float-fmin-zero-sign1/main.c
@@ -0,0 +1,12 @@
+// fmin(+0, -0) should return -0 per IEEE 754-2019
+// The C library model uses (f <= g || isnan(g)) ? f : g
+// Since +0 <= -0 is true, it returns f = +0 instead of -0.
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  float r = fminf(+0.0f, -0.0f);
+  assert(signbit(r));
+  return 0;
+}
diff --git a/regression/cbmc/Float-fmin-zero-sign1/test.desc b/regression/cbmc/Float-fmin-zero-sign1/test.desc
new file mode 100644
index 00000000000..05e4a0935e2
--- /dev/null
+++ b/regression/cbmc/Float-fmin-zero-sign1/test.desc
@@ -0,0 +1,8 @@
+CORE
+main.c
+--floatbv
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+fminf zero sign: returns -0 per IEEE 754-2019.
diff --git a/regression/cbmc/Float-nan-uf1/main.c b/regression/cbmc/Float-nan-uf1/main.c
new file mode 100644
index 00000000000..276fc1115cf
--- /dev/null
+++ b/regression/cbmc/Float-nan-uf1/main.c
@@ -0,0 +1,29 @@
+// Based on Z3#6728: NaN propagation through operations.
+// In IEEE 754, any arithmetic operation with NaN produces NaN.
+// This test verifies CBMC correctly handles NaN propagation.
+
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  float x;
+
+  // NaN + anything = NaN
+  float r1 = x + NAN;
+  assert(isnan(r1));
+
+  // NaN - anything = NaN
+  float r2 = x - NAN;
+  assert(isnan(r2));
+
+  // NaN * anything = NaN
+  float r3 = x * NAN;
+  assert(isnan(r3));
+
+  // NaN / anything = NaN
+  float r4 = x / NAN;
+  assert(isnan(r4));
+
+  return 0;
+}
diff --git a/regression/cbmc/Float-nan-uf1/test.desc b/regression/cbmc/Float-nan-uf1/test.desc
new file mode 100644
index 00000000000..f7cbfbf0796
--- /dev/null
+++ b/regression/cbmc/Float-nan-uf1/test.desc
@@ -0,0 +1,8 @@
+CORE
+main.c
+--floatbv
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+Based on Z3#6728: NaN propagation through arithmetic operations.
diff --git a/regression/cbmc/Float-overflow-inf1/main.c b/regression/cbmc/Float-overflow-inf1/main.c
new file mode 100644
index 00000000000..31f3cf4fb5a
--- /dev/null
+++ b/regression/cbmc/Float-overflow-inf1/main.c
@@ -0,0 +1,26 @@
+// Based on Z3#4673: Floating-point overflow should produce infinity.
+// FLT_MAX * 2 overflows to +inf, then +inf * 0.5 = +inf.
+// So (FLT_MAX * 2) * 0.5 > FLT_MAX should be satisfiable
+// because +inf > FLT_MAX.
+
+#include <assert.h>
+#include <float.h>
+#include <math.h>
+
+int main()
+{
+  // FLT_MAX * 2 should overflow to +inf
+  float x = FLT_MAX;
+  float y = x * 2.0f;
+  assert(isinf(y));
+  assert(y > 0.0f);
+
+  // +inf * 0.5 = +inf
+  float z = y * 0.5f;
+  assert(isinf(z));
+
+  // +inf > FLT_MAX
+  assert(z > x);
+
+  return 0;
+}
diff --git a/regression/cbmc/Float-overflow-inf1/test.desc b/regression/cbmc/Float-overflow-inf1/test.desc
new file mode 100644
index 00000000000..ed2cc94bc7e
--- /dev/null
+++ b/regression/cbmc/Float-overflow-inf1/test.desc
@@ -0,0 +1,8 @@
+CORE
+main.c
+--floatbv
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+Based on Z3#4673: Overflow should produce infinity, not saturate.
diff --git a/regression/cbmc/Float-rem1/main.c b/regression/cbmc/Float-rem1/main.c
new file mode 100644
index 00000000000..137cd324156
--- /dev/null
+++ b/regression/cbmc/Float-rem1/main.c
@@ -0,0 +1,14 @@
+// Based on Z3#2381: IEEE 754 remainder.
+// CBMC crashes with invariant violation on remainderf/remainder.
+// This is a known bug in CBMC's handling of the remainder function.
+
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  float r = remainderf(3.0f, 2.0f);
+  assert(r == -1.0f);
+
+  return 0;
+}
diff --git a/regression/cbmc/Float-rem1/test.desc b/regression/cbmc/Float-rem1/test.desc
new file mode 100644
index 00000000000..db48fa10c24
--- /dev/null
+++ b/regression/cbmc/Float-rem1/test.desc
@@ -0,0 +1,8 @@
+CORE
+main.c
+--floatbv
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+remainderf(3.0f, 2.0f) == -1.0f (IEEE 754 remainder tie-breaking).
diff --git a/regression/cbmc/Float-sqrt-rounding1/main.c b/regression/cbmc/Float-sqrt-rounding1/main.c
new file mode 100644
index 00000000000..765865955a3
--- /dev/null
+++ b/regression/cbmc/Float-sqrt-rounding1/main.c
@@ -0,0 +1,17 @@
+// sqrtf with non-default rounding mode
+// The C library model doesn't correctly handle all rounding modes.
+#include <assert.h>
+#include <fenv.h>
+#include <math.h>
+
+int main()
+{
+  // sqrt(2.0) with round-toward-zero should give 0x3FB504F2
+  fesetround(FE_TOWARDZERO);
+  float r = sqrtf(2.0f);
+  // The result should be strictly less than sqrt(2.0) with RNE
+  fesetround(FE_TONEAREST);
+  float r_rne = sqrtf(2.0f);
+  assert(r <= r_rne);
+  return 0;
+}
diff --git a/regression/cbmc/Float-sqrt-rounding1/test.desc b/regression/cbmc/Float-sqrt-rounding1/test.desc
new file mode 100644
index 00000000000..a3a41377459
--- /dev/null
+++ b/regression/cbmc/Float-sqrt-rounding1/test.desc
@@ -0,0 +1,9 @@
+CORE
+main.c
+--floatbv --no-built-in-assertions
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+sqrtf with FE_TOWARDZERO: result <= RNE result.
+Uses __CPROVER_sqrtf built-in mapping to ID_floatbv_sqrt.
diff --git a/regression/cbmc/Float-sub-rounding1/main.c b/regression/cbmc/Float-sub-rounding1/main.c
new file mode 100644
index 00000000000..25cc8c80bb7
--- /dev/null
+++ b/regression/cbmc/Float-sub-rounding1/main.c
@@ -0,0 +1,26 @@
+// Based on Z3#7162: Subtraction with different rounding modes.
+// IEEE 754: x - x == +0 for all rounding modes except
+// round-toward-negative, where x - x == -0.
+// In C, the default rounding mode is round-to-nearest-ties-to-even.
+
+#include <assert.h>
+#include <fenv.h>
+#include <math.h>
+
+int main()
+{
+  double x;
+
+  // Assume x is finite (not NaN or Inf, since Inf - Inf = NaN)
+  __CPROVER_assume(!isnan(x) && !isinf(x));
+
+  double result = x - x;
+
+  // x - x must be zero
+  assert(result == 0.0);
+
+  // With default rounding (RNE), x - x == +0.0
+  assert(!signbit(result));
+
+  return 0;
+}
diff --git a/regression/cbmc/Float-sub-rounding1/test.desc b/regression/cbmc/Float-sub-rounding1/test.desc
new file mode 100644
index 00000000000..2bb02bb3ebd
--- /dev/null
+++ b/regression/cbmc/Float-sub-rounding1/test.desc
@@ -0,0 +1,8 @@
+CORE
+main.c
+--floatbv
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+Based on Z3#7162: x - x == +0 with default rounding mode (RNE).
diff --git a/regression/cbmc/Float-trunc1/main.c b/regression/cbmc/Float-trunc1/main.c
new file mode 100644
index 00000000000..50daa2f6dab
--- /dev/null
+++ b/regression/cbmc/Float-trunc1/main.c
@@ -0,0 +1,24 @@
+// Based on Z3#4841: truncation (roundToIntegral RTZ) correctness.
+// truncf(3.5f) should be 3.0f, truncf(-2.7f) should be -2.0f.
+
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  assert(truncf(3.5f) == 3.0f);
+  assert(truncf(-2.7f) == -2.0f);
+  assert(truncf(0.0f) == 0.0f);
+  assert(truncf(-0.0f) == -0.0f);
+
+  // truncf of integer is identity
+  assert(truncf(5.0f) == 5.0f);
+
+  // truncf of NaN is NaN
+  assert(isnan(truncf(NAN)));
+
+  // truncf of Inf is Inf
+  assert(isinf(truncf(INFINITY)));
+
+  return 0;
+}
diff --git a/regression/cbmc/Float-trunc1/test.desc b/regression/cbmc/Float-trunc1/test.desc
new file mode 100644
index 00000000000..104cd69d909
--- /dev/null
+++ b/regression/cbmc/Float-trunc1/test.desc
@@ -0,0 +1,8 @@
+CORE
+main.c
+--floatbv --no-built-in-assertions
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+Based on Z3#4841: truncf correctness (roundToIntegral RTZ in C).
diff --git a/regression/cbmc/Float-zero-sign1/main.c b/regression/cbmc/Float-zero-sign1/main.c
new file mode 100644
index 00000000000..fcb38d71e62
--- /dev/null
+++ b/regression/cbmc/Float-zero-sign1/main.c
@@ -0,0 +1,27 @@
+// Based on Z3#4843: Signed zero handling.
+// IEEE 754: -0 == +0 (comparison), but they are distinct bit patterns.
+// fmax(-0, +0) should return +0 per IEEE 754-2019.
+
+#include <assert.h>
+#include <math.h>
+
+int main()
+{
+  // -0 == +0 in comparison
+  float nz = -0.0f;
+  float pz = +0.0f;
+  assert(nz == pz);
+
+  // But they have different signs
+  assert(signbit(nz));
+  assert(!signbit(pz));
+
+  // Negation flips sign of zero
+  float neg_pz = -pz;
+  assert(signbit(neg_pz));
+
+  float neg_nz = -nz;
+  assert(!signbit(neg_nz));
+
+  return 0;
+}
diff --git a/regression/cbmc/Float-zero-sign1/test.desc b/regression/cbmc/Float-zero-sign1/test.desc
new file mode 100644
index 00000000000..a961a76f1a1
--- /dev/null
+++ b/regression/cbmc/Float-zero-sign1/test.desc
@@ -0,0 +1,8 @@
+CORE
+main.c
+--floatbv
+^EXIT=0$
+^SIGNAL=0$
+^VERIFICATION SUCCESSFUL$
+--
+Based on Z3#4843: Signed zero handling in IEEE 754.
diff --git a/regression/cbmc/fmod1/test.desc b/regression/cbmc/fmod1/test.desc
index a685bfcb952..930847984eb 100644
--- a/regression/cbmc/fmod1/test.desc
+++ b/regression/cbmc/fmod1/test.desc
@@ -1,4 +1,4 @@
-CORE broken-z3-smt-backend broken-smt-backend no-new-smt
+CORE broken-z3-smt-backend no-new-smt thorough-paths
 main.c
 --no-standard-checks
 ^EXIT=0$
@@ -7,3 +7,9 @@ main.c
 --
 ^warning: ignoring
 --
+broken-z3-smt-backend: --z3 uses QF_AUFBV (bitvector, not FPA), so
+the 10 double-precision fmod calls produce a huge formula that Z3
+cannot solve within the test timeout.
+no-new-smt: incremental SMT2 backend does not support floatbv_mod.
+thorough-paths: --paths lifo with 10 assertions takes >5 minutes
+because each path builds a 282-bit integer significand divider.
diff --git a/regression/fp-solvers-issues/IMPLEMENTATION_ANALYSIS.md b/regression/fp-solvers-issues/IMPLEMENTATION_ANALYSIS.md
new file mode 100644
index 00000000000..f6a8d09255d
--- /dev/null
+++ b/regression/fp-solvers-issues/IMPLEMENTATION_ANALYSIS.md
@@ -0,0 +1,296 @@
+# FP Implementation Analysis: Effort Estimates and Design Sketches
+
+## Branch `tautschnig/cleanup/floatbv-mod-rem` Status
+
+This branch (actively being worked on) addresses several of the gaps/bugs
+found in our analysis. Here's what it covers:
+
+### Already Implemented on the Branch
+
+1. **FMA (`fp.fma`)** — Full implementation
+   - New `floatbv_fma_exprt` expression type (`ID_floatbv_fma`)
+   - `float_utilst::fma()` — bit-level implementation using exact
+     double-width multiplication followed by aligned addition and single
+     rounding
+   - `boolbvt::convert_floatbv_fma()` — SAT encoding
+   - `smt2_convt::convert_floatbv_fma()` — SMT2 output (emits `fp.fma`)
+   - `__CPROVER_fma`/`fmaf`/`fmal` built-ins in C library
+   - C type-checking in `c_typecheck_expr.cpp`
+   - **NOT yet added**: SMT2 solver parser (`smt2_parser.cpp`) — the
+     standalone `smt2_solver` binary still won't parse `fp.fma`
+
+2. **`fp.rem` (IEEE remainder) fix** — Complete rewrite
+   - Old code was a stub: `sub(src1, mul(div(src1, src2), src2))` which
+     always returned +0.0 due to the round-trip cancellation
+   - New algorithm: `q = div(x,y)`, `n = round_to_integral(q)`,
+     `r = fma(-n, y, x)`, then try `n±1` and pick smallest `|r|`
+   - Includes a Coq proof (`doc/proofs/fma_remainder.v`) for soundness
+   - Both `float_utilst::rem()` and `float_bvt::rem()` updated
+
+3. **`fmod` vs `remainder` distinction** — New `ID_floatbv_mod`
+   - `fmod` uses round-to-zero (simpler, no FMA needed)
+   - `remainder` uses round-to-even + FMA-based correction
+   - `boolbv_floatbv_mod_rem.cpp` now sets correct rounding mode per op
+   - C library uses `__CPROVER_fmod` and `__CPROVER_remainder` built-ins
+     (removes the old `__sort_of_CPROVER_remainder` hack)
+
+4. **`remainderf`/`remainder` crash fix** — Fixed
+   - The old code went through `__sort_of_CPROVER_remainder` which used
+     `long double` intermediate, causing the 128-bit floatbv invariant
+     violation. The new code uses `__CPROVER_remainder` built-in directly.
+
+### NOT Addressed by the Branch
+
+The branch does NOT address:
+- `fp.to_real`
+- `fp.sqrt`
+- `fp.min` / `fp.max`
+- `fp.isSubnormal` / `fp.isNegative` / `fp.isPositive`
+- `to_fp` from bitvector (reinterpret cast)
+- `fp.to_sbv` / `fp.to_ubv` crash with non-RTZ rounding modes
+- `fp.roundToIntegral` bug on non-standard FP sorts
+- SMT2 solver parser support for `fp.fma`
+
+---
+
+## Effort Estimates for Remaining Gaps
+
+### 1. `fp.fma` in SMT2 Solver Parser — **Small (1–2 hours)**
+
+The branch already has the full back-end implementation. The only missing
+piece is parsing `fp.fma` in `smt2_parser.cpp`.
+
+**Sketch**: Add to the `expressions` map in `smt2_parser.cpp`:
+```cpp
+expressions["fp.fma"] = [this] {
+  auto op = operands();
+  if(op.size() != 4)
+    throw error() << "fp.fma takes four operands";
+  // op[0] = rounding mode, op[1..3] = FP operands
+  return floatbv_fma_exprt(op[1], op[2], op[3], op[0]);
+};
+```
+
+### 2. `fp.isSubnormal` — **Trivial (30 min)**
+
+Already have `fp.isNormal`, `fp.isZero`, `fp.isNaN`, `fp.isInfinite`.
+The predicate is: exponent is all-zeros AND mantissa is non-zero.
+
+**Sketch**: Add to `smt2_parser.cpp` expressions map, create
+`isnormal_exprt`-like expression, or directly construct:
+```cpp
+expressions["fp.isSubnormal"] = [this] {
+  auto op = operands();
+  // subnormal = !isNaN && !isInfinite && !isZero && !isNormal
+  // Or directly: exponent == 0 && fraction != 0
+  // Use existing infrastructure from float_utils
+};
+```
+In `float_utils`, subnormal detection is already part of `unpack()`.
+The `boolbv` layer already handles `ID_isnormal`; adding `ID_issubnormal`
+follows the same pattern.
+
+### 3. `fp.isNegative` / `fp.isPositive` — **Trivial (30 min each)**
+
+These are just sign-bit checks combined with "not NaN".
+
+**Sketch**:
+- `fp.isNegative(x)` = `sign_bit(x) == 1 && !isNaN(x)`
+- `fp.isPositive(x)` = `sign_bit(x) == 0 && !isNaN(x)`
+
+The sign bit is the MSB of the bitvector representation. This is a
+one-liner in the parser + a simple expression construction.
+
+### 4. `fp.min` / `fp.max` — **Small-Medium (2–4 hours)**
+
+IEEE 754-2019 semantics:
+- `min(x, y)`: return the smaller; if equal, return the one with negative
+  sign bit; if either is NaN, return the other (or NaN if both NaN)
+- `max(x, y)`: symmetric
+
+The tricky part is the NaN handling and the `-0 < +0` tie-breaking
+(which differs from `fp.lt` where `-0 == +0`).
+
+**Sketch**:
+1. Add `ID_floatbv_min` / `ID_floatbv_max` expression types
+2. In `float_utilst`, implement using existing `relation()` and
+   `is_NaN()`:
+   ```
+   min(a, b) =
+     if isNaN(a) then b
+     else if isNaN(b) then a
+     else if a < b then a
+     else if b < a then b
+     else if sign(a) then a  // -0 < +0
+     else b
+   ```
+3. Add parser entries, boolbv conversion, smt2 output
+
+### 5. `fp.sqrt` — **Medium-Large (1–3 days)**
+
+Square root is significantly more complex than other operations. The
+standard approach is Newton-Raphson iteration or digit-by-digit
+computation, but in a SAT/SMT context, the typical approach is:
+
+**Approach A — Existential encoding**: Assert `result * result == x`
+(with appropriate rounding). This is what most bit-blasting solvers do.
+Specifically: `sqrt(x) = r` iff `r >= 0 && r*r rounded == x` with
+appropriate handling of rounding modes, NaN, infinity, and negative
+inputs.
+
+**Approach B — Direct bit-level algorithm**: Implement the restoring or
+non-restoring square root algorithm at the bit level, similar to how
+division is implemented.
+
+**Sketch** (Approach A):
+1. Introduce `result` as a fresh FP variable
+2. Assert: `result >= 0`, `!isNaN(result)` (unless input is NaN/negative)
+3. Assert: `mul(result, result) == x` with appropriate rounding
+4. Handle special cases: `sqrt(NaN) = NaN`, `sqrt(+inf) = +inf`,
+   `sqrt(-0) = -0`, `sqrt(negative) = NaN`
+
+This is conceptually simple but may produce large SAT instances because
+the multiplication constraint is quadratic in the bit-width.
+
+**Approach B** would follow the pattern of `float_utilst::div()` but
+with a square root algorithm. This is more work but produces tighter
+encodings.
+
+CBMC's C front-end already handles `sqrtf`/`sqrt` via the library model,
+which uses `__CPROVER_sqrtf` etc. The back-end encoding is the missing
+piece.
+
+### 6. `to_fp` from BitVec (reinterpret cast) — **Small (1–2 hours)**
+
+The SMT-LIB spec says `((_ to_fp eb sb) (_ BitVec m))` (with NO rounding
+mode) is a reinterpret cast where `m = 1 + eb + (sb - 1)`.
+
+The parser currently always expects a rounding mode as the first operand.
+The fix is to check whether the first operand is a bitvector (not a
+rounding mode) and handle the 1-argument case.
+
+**Sketch**: In the `to_fp` parsing code in `smt2_parser.cpp`:
+```cpp
+// After parsing rounding_mode and source_op:
+// Check if "rounding_mode" is actually a BitVec (reinterpret cast)
+if(rounding_mode.type().id() == ID_unsignedbv &&
+   to_unsignedbv_type(rounding_mode.type()).get_width() ==
+     width_e + width_f)
+{
+  // This is the reinterpret cast: ((_ to_fp eb sb) BitVec)
+  // The "rounding_mode" is actually the bitvector operand
+  return typecast_exprt(rounding_mode, spec.to_type());
+}
+```
+
+Actually, the cleaner approach is to parse the first operand, check its
+type, and branch:
+- If it's a rounding mode → parse second operand (existing code)
+- If it's a bitvector of matching width → reinterpret cast
+
+### 7. `fp.to_sbv` / `fp.to_ubv` crash fix — **Small (1–2 hours)**
+
+The parser correctly constructs `floatbv_typecast_exprt`, but the
+`float_utilst::to_integer()` function has a precondition requiring
+`round_to_zero`. The fix is to either:
+
+(a) Support all rounding modes in `to_integer()` — this requires
+    implementing the rounding logic for integer conversion, or
+
+(b) In the parser/lowering, convert the rounding mode: first round the
+    FP value to integral using `fp.roundToIntegral` with the given
+    rounding mode, then convert to integer with RTZ.
+
+**Sketch** (approach b, simpler):
+```
+fp.to_sbv(rm, x) = to_sbv(RTZ, roundToIntegral(rm, x))
+```
+This is semantically correct and reuses existing infrastructure.
+
+### 8. `fp.to_real` — **Medium (2–4 hours for basic support)**
+
+`fp.to_real` converts a floating-point value to an exact real number.
+This is fundamentally different from the other operations because it
+crosses the FP/Real theory boundary.
+
+For CBMC's own SAT-based solver, this would require introducing real
+arithmetic support, which is a much larger undertaking. However, for the
+SMT2 output path (when using an external solver), it's just a matter of
+emitting `fp.to_real`.
+
+**For the standalone SMT2 solver**: This would require either:
+- Implementing rational arithmetic in the solver (major effort), or
+- Encoding the real value as a sufficiently wide fixed-point or
+  integer representation (feasible but lossy for large exponents)
+
+**Practical approach**: For the SMT2 output converter, just emit
+`fp.to_real`. For the standalone solver, report "unsupported" cleanly
+rather than silently ignoring.
+
+### 9. `fp.roundToIntegral` on non-standard sorts — **Small (1–2 hours)**
+
+**Root cause**: The "magic number" approach uses `2^f` where `f` is the
+number of fraction bits. For sorts where `2^f` exceeds the maximum
+representable value (i.e., when `f >= 2^(e-1)`), the magic number is
+always >= |x|, so the function returns the input unchanged.
+
+**Fix**: Before the magic-number trick, check if the exponent is large
+enough that the value is already integral. The condition is:
+`actual_exponent >= f` (the value has no fractional bits). If the
+exponent is smaller, use the magic-number trick but clamp the magic
+number to the representable range.
+
+Alternative fix: Use a different algorithm for small formats. Instead of
+the magic-number trick, directly compute:
+1. Extract the integer part by shifting
+2. Round according to the rounding mode
+3. Reconstruct the FP value
+
+This is more complex but works for all formats.
+
+**Simplest fix**: Add a guard: if `spec.f >= (1 << (spec.e - 1))`, fall
+back to a direct implementation. For standard formats (Float16, Float32,
+Float64, Float128), the magic-number approach always works because
+`f < 2^(e-1)`.
+
+---
+
+## Summary Table
+
+| Feature | Branch Status | Effort | Priority |
+|---------|--------------|--------|----------|
+| `fp.fma` (back-end) | ✅ Done | — | — |
+| `fp.fma` (SMT2 parser) | ❌ Missing | Small (1–2h) | High |
+| `fp.rem` fix | ✅ Done | — | — |
+| `fmod` vs `remainder` | ✅ Done | — | — |
+| `remainderf` crash | ✅ Done | — | — |
+| `fp.isSubnormal` | ❌ Missing | Trivial (30min) | Medium |
+| `fp.isNegative` | ❌ Missing | Trivial (30min) | Medium |
+| `fp.isPositive` | ❌ Missing | Trivial (30min) | Medium |
+| `fp.min` / `fp.max` | ❌ Missing | Small-Med (2–4h) | Medium |
+| `fp.sqrt` | ❌ Missing | Med-Large (1–3d) | Low |
+| `to_fp` from BV | ❌ Missing | Small (1–2h) | High |
+| `fp.to_sbv`/`fp.to_ubv` crash | ❌ Missing | Small (1–2h) | High |
+| `fp.to_real` | ❌ Missing | Medium (2–4h basic) | Low |
+| `roundToIntegral` non-std sorts | ❌ Missing | Small (1–2h) | Medium |
+
+### Total Remaining Effort (excluding branch work)
+
+- **Quick wins** (< 2h each): `fp.fma` parser, `fp.isSubnormal`,
+  `fp.isNegative`, `fp.isPositive`, `to_fp` from BV,
+  `fp.to_sbv`/`fp.to_ubv` crash fix, `roundToIntegral` fix
+  → ~8–12 hours total
+
+- **Medium effort**: `fp.min`/`fp.max`, `fp.to_real` (basic)
+  → ~4–8 hours total
+
+- **Larger effort**: `fp.sqrt`
+  → 1–3 days
+
+### Additional Bug Found During Analysis
+
+7. **`fp.to_sbv`/`fp.to_ubv` crash** — The parser correctly handles
+   these indexed operators, but the solver crashes with an invariant
+   violation when the rounding mode is not RTZ. The `to_integer()`
+   function in `float_utils.cpp:92` has a hard precondition
+   `rounding_mode_bits.round_to_zero.is_true()`.
diff --git a/regression/fp-solvers-issues/README.md b/regression/fp-solvers-issues/README.md
new file mode 100644
index 00000000000..940913207a1
--- /dev/null
+++ b/regression/fp-solvers-issues/README.md
@@ -0,0 +1,488 @@
+# Floating-Point Solver Issues: CBMC Analysis
+
+This document tracks known floating-point issues from external SMT solvers
+(Z3, CVC5, Bitwuzla) and documents whether CBMC's own SMT solver and
+verification pipeline are affected by similar problems.
+
+## Status Legend
+
+- **Not Started**: Issue not yet analyzed for CBMC
+- **Analyzed**: Issue reviewed, CBMC behavior determined
+- **Test Added**: Regression test(s) committed
+- **N/A**: Issue not applicable to CBMC (e.g., involves features CBMC doesn't support)
+
+---
+
+## Z3 Issues (from `Floats` label)
+
+### Explicitly Listed Issues (from fp_issues.txt)
+
+| # | Z3 Issue | Title | Z3 Status | Category | CBMC Status |
+|---|----------|-------|-----------|----------|-------------|
+| 1 | [Z3#6728](https://github.com/Z3Prover/z3/issues/6728) | Inconsistent answers on NaN and uninterpreted functions | Closed | Soundness (NaN equality vs UF) | Test Added ✅ |
+| 2 | [Z3#7162](https://github.com/Z3Prover/z3/issues/7162) | Invalid model on float formula | Open | Invalid model (fp.sub/fp.fma with RNA/RTN) | Test Added ✅ (fp.sub only; fp.fma unsupported) |
+| 3 | [Z3#7321](https://github.com/Z3Prover/z3/issues/7321) | Invalid model issue on floats | Open | Invalid model (fp.to_real + fp.eq) | Analyzed — fp.to_real unsupported |
+| 4 | [Z3#7842](https://github.com/Z3Prover/z3/issues/7842) | Incorrect model (NaN + datatype) | Open | Invalid model (NaN distinct + datatype) | Not Started |
+| 5 | [Z3#8097](https://github.com/Z3Prover/z3/issues/8097) | Segfault with exists-quantified QF_FP + UF | Closed | Crash (segfault) | Not Started |
+| 6 | [Z3#8169](https://github.com/Z3Prover/z3/issues/8169) | Incorrect model with (_ FloatingPoint 2 24) and fp.to_real | Closed | Invalid model (non-standard FP sort + fp.to_real) | Analyzed — fp.to_real unsupported |
+| 7 | [Z3#8282](https://github.com/Z3Prover/z3/issues/8282) | Performance slowdown on equivalent SMT2 files | Closed | Performance | N/A (performance only) |
+| 8 | [Z3#8345](https://github.com/Z3Prover/z3/issues/8345) | Soundness issue converting bit repr to fp to Real | Closed | Soundness (int2bv + to_fp + fp.to_real + incremental) | Analyzed — fp.to_real unsupported, no incremental |
+| 9 | [Z3#8414](https://github.com/Z3Prover/z3/issues/8414) | Assertion violation in mpf.cpp (fp.rem) | Closed | Crash (assertion violation in fp.rem) | Test Added ✅ (no crash) |
+
+### Additional Z3 Floats-Labeled Issues
+
+| # | Z3 Issue | Title | Z3 Status | Category | CBMC Status |
+|---|----------|-------|-----------|----------|-------------|
+| 10 | [Z3#8185](https://github.com/Z3Prover/z3/issues/8185) | Incorrect model in mixed FP/Real logic + string constraint | Open | Invalid model | N/A (requires FP/Real/String mixed logic) |
+| 11 | [Z3#8183](https://github.com/Z3Prover/z3/issues/8183) | Incorrect UNSAT in Real-to-FP conversion with RNE/RNA overflow | Closed | Refutational soundness | Analyzed — requires to_fp from Real (unsupported) |
+| 12 | [Z3#7431](https://github.com/Z3Prover/z3/issues/7431) | Invalid model issue on float formula | Open | Invalid model | Analyzed — requires to_fp from Real (unsupported) |
+| 13 | [Z3#7135](https://github.com/Z3Prover/z3/issues/7135) | Refutational soundness issue | Open | Refutational soundness | Analyzed — requires fp.fma, to_fp from BV |
+| 14 | [Z3#7056](https://github.com/Z3Prover/z3/issues/7056) | fp.roundToIntegral gives invalid zero_extend application | Closed | Crash/error | Test Added ✅ (roundToIntegral tests) |
+| 15 | [Z3#7026](https://github.com/Z3Prover/z3/issues/7026) | [consolidated] new core, floats | Open | Consolidated | N/A (meta-issue) |
+| 16 | [Z3#6983](https://github.com/Z3Prover/z3/issues/6983) | Refutation unsoundness on QF_AFP | Closed | Refutational soundness | Not Started |
+| 17 | [Z3#6974](https://github.com/Z3Prover/z3/issues/6974) | Unsoundness with floats | Closed | Soundness | Not Started |
+| 18 | [Z3#6972](https://github.com/Z3Prover/z3/issues/6972) | Regression with floats | Closed | Regression | Not Started |
+| 19 | [Z3#6970](https://github.com/Z3Prover/z3/issues/6970) | Refutation unsoundness on QF_AFP | Closed | Refutational soundness | Not Started |
+| 20 | [Z3#6861](https://github.com/Z3Prover/z3/issues/6861) | Invalid model on incremental FP instance | Closed | Invalid model (incremental) | N/A (incremental solving) |
+| 21 | [Z3#6674](https://github.com/Z3Prover/z3/issues/6674) | Assertion violation at mpf.cpp:1966 | Closed | Crash | Not Started |
+| 22 | [Z3#6633](https://github.com/Z3Prover/z3/issues/6633) | Problem in Float to Real conversion | Open | fp.to_real | Analyzed — fp.to_real unsupported |
+| 23 | [Z3#6553](https://github.com/Z3Prover/z3/issues/6553) | Fuzz bugs for floats - unsoundness / invalid model | Closed | Soundness | Analyzed — requires fp.max, fp.rem (both buggy/unsupported) |
+| 24 | [Z3#6548](https://github.com/Z3Prover/z3/issues/6548) | fpRealToFP and fpToReal fail on trivial problems | Closed | fp.to_real / to_fp from Real | Analyzed — fp.to_real unsupported |
+| 25 | [Z3#6464](https://github.com/Z3Prover/z3/issues/6464) | Segfault with tactics | Closed | Crash | N/A (Z3-specific tactics) |
+| 26 | [Z3#6460](https://github.com/Z3Prover/z3/issues/6460) | Crash with FPA formula | Closed | Crash | Not Started |
+| 27 | [Z3#6457](https://github.com/Z3Prover/z3/issues/6457) | [consolidated] assertion violations | Closed | Crash | N/A (meta-issue) |
+| 28 | [Z3#6294](https://github.com/Z3Prover/z3/issues/6294) | Performance regression on trivial FP solve | Closed | Performance | N/A (performance only) |
+| 29 | [Z3#6117](https://github.com/Z3Prover/z3/issues/6117) | [consolidated] issues in FP | Closed | Consolidated | N/A (meta-issue) |
+| 30 | [Z3#6079](https://github.com/Z3Prover/z3/issues/6079) | Invalid model issue on fp | Closed | Invalid model | Analyzed — requires to_fp from BV (unsupported) |
+| 31 | [Z3#6078](https://github.com/Z3Prover/z3/issues/6078) | Unsoundness of fp.to_fp with sat.euf=true | Open | Soundness | Not Started |
+| 32 | [Z3#5911](https://github.com/Z3Prover/z3/issues/5911) | Assertion violation at mpf.cpp:907 | Closed | Crash | Not Started |
+| 33 | [Z3#5769](https://github.com/Z3Prover/z3/issues/5769) | Invalid model for QF_BVFP formula | Closed | Invalid model | Analyzed — requires to_fp from BV/Real (unsupported) |
+| 34 | [Z3#5572](https://github.com/Z3Prover/z3/issues/5572) | FP condition not finding possible solution | Closed | Incompleteness | N/A (user question, not a bug) |
+| 35 | [Z3#5284](https://github.com/Z3Prover/z3/issues/5284) | Assertion error at mpf.cpp:907 | Closed | Crash | Not Started |
+| 36 | [Z3#5051](https://github.com/Z3Prover/z3/issues/5051) | Confusing/unexpected reason-unknown with floats | Closed | UX/completeness | N/A (UX issue) |
+| 37 | [Z3#4889](https://github.com/Z3Prover/z3/issues/4889) | [Consolidated] Bugs in FP logic | Closed | Consolidated | Not Started |
+| 38 | [Z3#4880](https://github.com/Z3Prover/z3/issues/4880) | Solution soundness bug in FP logic | Closed | Soundness | Analyzed — requires fp.min (unsupported) |
+| 39 | [Z3#4862](https://github.com/Z3Prover/z3/issues/4862) | Invalid model bug in debug build | Closed | Invalid model | Test Added ✅ (C conversion test) |
+| 40 | [Z3#4861](https://github.com/Z3Prover/z3/issues/4861) | Invalid model bug in QF_FP | Closed | Invalid model | Analyzed — roundToIntegral on Float16 works |
+| 41 | [Z3#4858](https://github.com/Z3Prover/z3/issues/4858) | Regression invalid model bug in QF_FP | Closed | Invalid model | Not Started |
+| 42 | [Z3#4855](https://github.com/Z3Prover/z3/issues/4855) | Invalid model for QF_FP formula | Closed | Invalid model | Analyzed — requires to_fp from Real (unsupported) |
+| 43 | [Z3#4843](https://github.com/Z3Prover/z3/issues/4843) | QF_FP invalid model | Closed | Invalid model | Analyzed — requires fp.max (unsupported); C zero-sign test added |
+| 44 | [Z3#4841](https://github.com/Z3Prover/z3/issues/4841) | Invalid model for QF_FP formula | Closed | Invalid model | Test Added ⚠️ BUG FOUND (roundToIntegral non-standard) |
+| 45 | [Z3#4673](https://github.com/Z3Prover/z3/issues/4673) | FP exponent saturates rather than becoming infinite | Closed | Soundness (overflow) | Test Added ✅ |
+| 46 | [Z3#2631](https://github.com/Z3Prover/z3/issues/2631) | Quantified FPA formula incorrectly SAT with MBQI | Closed | Soundness (quantifiers) | Not Started |
+| 47 | [Z3#2596](https://github.com/Z3Prover/z3/issues/2596) | Quantified FPA formula incorrectly SAT | Closed | Soundness (quantifiers) | Not Started |
+| 48 | [Z3#2381](https://github.com/Z3Prover/z3/issues/2381) | fp.rem producing incorrect result | Closed | Soundness (fp.rem) | Test Added ⚠️ BUG FOUND |
+
+---
+
+## CVC5 Issues
+
+| # | CVC5 Issue | Title | CVC5 Status | Category | CBMC Status |
+|---|------------|-------|-------------|----------|-------------|
+| 49 | [CVC5#11139](https://github.com/cvc5/cvc5/issues/11139) | Fatal failure at symfpu traits (fp.div + fp.fma) | Open | Crash (symfpu postcondition) | Test Added ✅ (fp.div only; fp.fma unsupported) |
+| 50 | [CVC5#12306](https://github.com/cvc5/cvc5/issues/12306) | OR operation does not commute in BF16 | Open | Soundness (BF16 non-commutativity) | Test Added ✅ |
+| 51 | [CVC5#12335](https://github.com/cvc5/cvc5/issues/12335) | Fatal failure at symfpu traits with FP logic | Open | Crash (symfpu postcondition) | Not Started |
+| 52 | [CVC5#12371](https://github.com/cvc5/cvc5/issues/12371) | Unsat core was satisfiable (to_fp from Real) | Open | Soundness (to_fp from Real + quantifiers) | Analyzed — quantifiers + to_fp from Real N/A |
+| 53 | [CVC5#12383](https://github.com/cvc5/cvc5/issues/12383) | Performance slowdown on equivalent SMT2 files | Open | Performance | N/A (performance only) |
+| 54 | [CVC5#12387](https://github.com/cvc5/cvc5/issues/12387) | Fatal failure in proof post-processor (FP + quantifiers) | Open | Crash (proof checking) | N/A (proof checking not applicable) |
+
+---
+
+## Bitwuzla Issues
+
+| # | Bitwuzla Issue | Title | Bitwuzla Status | Category | CBMC Status |
+|---|----------------|-------|-----------------|----------|-------------|
+| 55 | [Bitwuzla#130](https://github.com/bitwuzla/bitwuzla/issues/130) | SymFPU issue on fp.div for non-standard format | Closed | Soundness (fp.div non-standard FP sort) | Test Added ✅ |
+
+---
+
+## Issue Details and SMT-LIB Reproducer Extracts
+
+Below are the key SMT-LIB snippets extracted from each issue, which will form
+the basis for CBMC regression tests.
+
+### Z3#6728 — NaN equality vs uninterpreted functions
+
+**Bug**: `(= NaN NaN)` is true (SMT-LIB semantics: `=` is structural equality),
+but Z3 incorrectly returns `sat` when the same NaN values are passed through an
+uninterpreted function and compared with `=`. The UF translation to bitvectors
+doesn't handle NaN canonicalization.
+
+**Reproducer (should be UNSAT)**:
+```smt2
+(set-logic ALL)
+(declare-const c RoundingMode)
+(declare-const x Float64)
+(declare-sort T 0)
+(declare-fun f (Float64) T)
+(assert (not (= (f (fp.add c x (_ NaN 11 53)))
+              (f (fp.add c (_ NaN 11 53) x)))))
+(check-sat)
+```
+
+### Z3#7162 — Invalid model with fp.sub + fp.fma (RNA/RTN)
+
+**Bug**: Z3 generates an invalid model for a formula involving `fp.sub` with RNA
+rounding and `fp.fma` with RTN rounding on Float64.
+
+**Reproducer (should be SAT with valid model)**:
+```smt2
+(declare-const a0 (_ FloatingPoint 11 53))
+(declare-const a1 (_ FloatingPoint 11 53))
+(declare-const a3 (_ FloatingPoint 11 53))
+(declare-const a4 (_ FloatingPoint 11 53))
+(assert (= (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000)
+  (fp.sub RNA a4 (fp.fma RTN a3 a1 a0))))
+(check-sat)
+```
+
+### Z3#7321 — fp.to_real not propagated through fp.eq
+
+**Bug**: `fp.eq s0 s1` is asserted, but `fp.to_real s0` and `fp.to_real s1`
+give different results. Z3 doesn't propagate the equality through `fp.to_real`.
+
+**Reproducer (should be UNSAT)**:
+```smt2
+(declare-fun s0 () (_ FloatingPoint 4 4))
+(define-fun s1 () (_ FloatingPoint 4 4) (fp #b0 #b0000 #b001))
+(define-fun s2 () Bool (fp.eq s0 s1))
+(define-fun s8 () Real (fp.to_real s0))
+(define-fun s10 () Real (/ 1.0 512.0))
+(define-fun s11 () Bool (= s8 s10))
+(define-fun s12 () Bool (not s11))
+(define-fun s13 () Bool (and s2 s12))
+(assert s13)
+(check-sat)
+```
+
+### Z3#7842 — NaN distinct with datatypes
+
+**Bug**: Z3 says `sat` but the model assigns `x = Flt(NaN)` while the assertion
+says `x` is distinct from `Flt(NaN)`. Involves user-defined datatypes wrapping
+FP values.
+
+**Reproducer (should be UNSAT)**:
+```smt2
+(set-logic ALL)
+(declare-datatype Expr ((Flt (getFlt_1 (_ FloatingPoint 8 24)))))
+(declare-fun x () Expr)
+(assert (distinct x (Flt (_ NaN 8 24))))
+(assert (fp.isNaN (getFlt_1 x)))
+(check-sat)
+```
+
+### Z3#8097 — Segfault with exists + UF + QF_FP
+
+**Bug**: Z3 crashes with segfault on a QF_FP formula with existential quantifier
+and uninterpreted function.
+
+**Reproducer**:
+```smt2
+(set-logic QF_FP)
+(declare-fun f (Float32 Float32 Float32) Float32)
+(assert
+    (exists ((i Float32) (c Float32))
+        (fp.eq c
+            (f i
+                (fp (_ bv0 1) (_ bv0 8) (_ bv0 23))
+                (fp (_ bv0 1) (_ bv0 8) (_ bv0 23))))))
+(check-sat)
+```
+
+### Z3#8169 — Invalid model with non-standard FP sort + fp.to_real
+
+**Bug**: Z3 generates invalid model for `(_ FloatingPoint 2 24)` combined with
+`fp.to_real` and `fp.add`.
+
+**Reproducer (should be SAT with valid model)**:
+```smt2
+(declare-const x (_ FloatingPoint 2 24))
+(assert (> (fp.to_real (fp.add RNE x (fp (_ bv0 1) (_ bv0 2) (_ bv0 23)))) 1.0))
+(check-sat)
+```
+
+### Z3#8345 — Soundness issue with int2bv + to_fp + fp.to_real (incremental)
+
+**Bug**: Incremental solving with quantified functions converting integers to
+floats via `int2bv` then `to_fp` then `fp.to_real` can prove false.
+
+**Category**: Involves quantifiers and incremental solving — likely N/A for
+CBMC's SMT solver but relevant for CBMC as a user of external SMT solvers.
+
+### Z3#8414 — Assertion violation in fp.rem with non-standard FP sort
+
+**Bug**: Z3 debug build crashes with assertion violation in `mpf.cpp` when
+computing `fp.rem` on `(_ FloatingPoint 1 37)` values.
+
+**Reproducer**:
+```smt2
+(assert (fp.isZero (fp.rem
+  (fp (_ bv0 1) #b111100110000111111100101110000000011 (_ bv0 1))
+  (fp (_ bv0 1) (_ bv1 36) (_ bv0 1)))))
+(check-sat)
+```
+
+### CVC5#11139 — symfpu postcondition failure (fp.div + fp.fma)
+
+**Bug**: CVC5 crashes with symfpu postcondition failure on a formula involving
+`fp.div RTN` of `fp.fma RTP` result on Float64.
+
+**Reproducer**:
+```smt2
+(declare-const FP_VAR_a (_ FloatingPoint 11 53))
+(declare-const FP_VAR_b (_ FloatingPoint 11 53))
+(assert (= (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000)
+  (fp.div RTN (fp.fma RTP FP_VAR_a FP_VAR_a
+    (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000)) FP_VAR_b)))
+(check-sat)
+```
+
+### CVC5#12335 — symfpu postcondition failure with quantified FP
+
+**Bug**: CVC5 crashes with symfpu postcondition failure on a quantified FP
+formula involving `fp.div`, `fp.eq`, and `fp.gt`.
+
+**Reproducer**:
+```smt2
+(set-logic FP)
+(declare-const x Float32)
+(declare-const a Float32)
+(assert (forall ((V Float32) (A Float32))
+  (or (not (fp.lt V x))
+      (not (fp.eq a a))
+      (not (fp.gt A (fp (_ bv0 1) (_ bv0 8) (_ bv0 23))))
+      (not (fp.eq (fp.div RNE A V) (fp (_ bv0 1) (_ bv0 8) (_ bv0 23)))))))
+(assert (fp.geq a (fp (_ bv0 1) (_ bv0 8) (_ bv0 23))))
+(check-sat)
+```
+
+### CVC5#12371 — Unsat core satisfiable (to_fp from Real + quantifiers)
+
+**Bug**: CVC5 reports unsat but the unsat core is satisfiable. Involves
+`to_fp` from Real with `fp.isInfinite` guard inside a universal quantifier.
+
+**Reproducer**:
+```smt2
+(set-logic ALL)
+(assert (forall ((x Real))
+  (>= 0.0 (ite (fp.isInfinite ((_ to_fp 8 24) RNE x)) x 0.0))))
+(check-sat)
+```
+
+### CVC5#12387 — Proof post-processor failure (FP + quantifiers)
+
+**Bug**: CVC5 crashes in proof post-processor with `--check-proofs` on a
+formula with quantified Float32 and `fp.eq` + `ite` + NaN.
+
+**Reproducer**:
+```smt2
+(set-logic ALL)
+(declare-const x Bool)
+(declare-const x1 Bool)
+(declare-const x4 Bool)
+(declare-const x41 Bool)
+(declare-const o Float32)
+(assert (forall ((V Float32))
+  (fp.eq (ite x1 o (_ -oo 8 24))
+         (ite x4 (_ NaN 8 24) (ite x41 (_ NaN 8 24) (ite x V (_ NaN 8 24)))))))
+(assert (exists ((V Float32))
+  (not (fp.eq (ite x4 (_ NaN 8 24) (ite x41 (_ NaN 8 24) (ite x V (_ NaN 8 24))))
+              (ite x1 o (_ -oo 8 24))))))
+(check-sat)
+```
+
+### CVC5#12306 — OR not commutative in BF16
+
+**Bug**: CVC5 returns different results depending on the order of operands in
+an OR for BF16 (`(_ FloatingPoint 8 8)`) formulas. Involves bound checking
+with `fp.leq`/`fp.geq` and multiplication.
+
+**Category**: Requires attached files for full reproducer. Core issue is
+non-commutativity of disjunction in FP reasoning.
+
+### CVC5#12383 — Performance slowdown on equivalent files
+
+**Bug**: Semantically equivalent SMT2 files (one with explicit normalization
+assertions) show significant performance difference. Same issue as Z3#8282.
+
+**Category**: Performance — not a correctness issue.
+
+### Bitwuzla#130 — SymFPU fp.div bug for non-standard FP format
+
+**Bug**: Bitwuzla incorrectly returns `unsat` for a satisfiable QF_BVFP formula
+involving `fp.div` with RNA rounding on `(_ FloatingPoint 4 12)` (non-standard
+format). Z3 correctly returns `sat`.
+
+**Reproducer** (large, involves many BV/FP conversions):
+```smt2
+(set-logic QF_BVFP)
+; ... (large formula involving fp.div RNA on (_ FloatingPoint 4 12))
+; ... and fp.to_sbv, to_fp, to_fp_unsigned with non-standard sorts
+(check-sat)
+```
+
+---
+
+## Categorization by FP Operation / Feature
+
+| Category | Issues |
+|----------|--------|
+| **fp.sub / fp.add** | Z3#7162, Z3#4673 |
+| **fp.fma** | Z3#7162, CVC5#11139 |
+| **fp.div** | CVC5#11139, CVC5#12335, Bitwuzla#130 |
+| **fp.rem** | Z3#2381, Z3#8414 |
+| **fp.to_real / to_fp from Real** | Z3#7321, Z3#8169, Z3#8345, Z3#6633, Z3#6548, CVC5#12371 |
+| **NaN handling** | Z3#6728, Z3#7842, CVC5#12387 |
+| **fp.eq semantics** | Z3#7321, CVC5#12335, CVC5#12387 |
+| **fp.roundToIntegral** | Z3#7056 |
+| **Non-standard FP sorts** | Z3#8169, Z3#8414, Bitwuzla#130, CVC5#12306 |
+| **Quantifiers + FP** | Z3#2631, Z3#2596, CVC5#12335, CVC5#12371, CVC5#12387 |
+| **Incremental solving** | Z3#8345, Z3#6861 |
+| **Uninterpreted functions + FP** | Z3#6728, Z3#8097 |
+| **Performance** | Z3#6294, Z3#8282, CVC5#12383 |
+| **Crashes / assertion violations** | Z3#5911, Z3#5284, Z3#6460, Z3#6464, Z3#6674, Z3#8097, Z3#8414, CVC5#11139, CVC5#12335, CVC5#12387 |
+
+---
+
+## CBMC SMT2 Solver Capability Matrix
+
+### Supported FP Operations
+| Operation | Supported | Notes |
+|-----------|-----------|-------|
+| `fp.abs` | ✅ | |
+| `fp.neg` | ✅ | |
+| `fp.add` | ✅ | All rounding modes |
+| `fp.sub` | ✅ | All rounding modes |
+| `fp.mul` | ✅ | All rounding modes |
+| `fp.div` | ✅ | All rounding modes |
+| `fp.rem` | ⚠️ | Implemented but **always returns +0.0** (bug) |
+| `fp.roundToIntegral` | ⚠️ | Works for standard sorts, **broken for non-standard sorts** |
+| `fp.sqrt` | ❌ | Not implemented |
+| `fp.min` | ❌ | Not implemented |
+| `fp.max` | ❌ | Not implemented |
+| `fp.fma` | ❌ | Not implemented |
+
+### Supported FP Predicates
+| Predicate | Supported |
+|-----------|-----------|
+| `fp.isNaN` | ✅ |
+| `fp.isInfinite` | ✅ |
+| `fp.isZero` | ✅ |
+| `fp.isNormal` | ✅ |
+| `fp.isSubnormal` | ❌ |
+| `fp.isNegative` | ❌ |
+| `fp.isPositive` | ❌ |
+| `fp.eq` | ✅ |
+| `fp.lt` / `fp.gt` / `fp.leq` / `fp.geq` | ✅ |
+
+### Supported Conversions
+| Conversion | Supported | Notes |
+|------------|-----------|-------|
+| `((_ to_fp eb sb) RoundingMode FP)` | ✅ | FP sort conversion |
+| `((_ to_fp eb sb) RoundingMode Real)` | ⚠️ | Constants only |
+| `((_ to_fp eb sb) BitVec)` | ❌ | Reinterpret cast not supported |
+| `((_ to_fp_unsigned eb sb) RoundingMode BitVec)` | ✅ | |
+| `fp.to_real` | ❌ | Not implemented |
+| `fp.to_sbv` | ❌ | Not implemented |
+| `fp.to_ubv` | ❌ | Not implemented |
+
+### Non-Standard FP Sorts
+| Feature | Status |
+|---------|--------|
+| Non-standard sorts (e.g., `(_ FloatingPoint 4 4)`) | ✅ Basic operations |
+| `fp.roundToIntegral` on non-standard sorts | ❌ Bug |
+| `fp.rem` on non-standard sorts | ⚠️ Same bug as standard sorts |
+
+---
+
+## Priority for CBMC Testing
+
+The most relevant issues for CBMC are those involving:
+
+1. **Core FP arithmetic** (add, sub, mul, div, fma, rem) — these directly map
+   to C floating-point operations
+2. **NaN handling** — C programs can produce NaN; CBMC must reason about it
+3. **Rounding modes** — C has `fesetround()`; CBMC's encoding must handle all
+   IEEE 754 rounding modes
+4. **FP-to-integer and integer-to-FP conversions** — common in C code
+5. **fp.to_real** — used internally in some CBMC encodings
+6. **Non-standard FP sorts** — relevant if CBMC supports non-standard widths
+   (e.g., `_Float16`, `__bf16`)
+
+Lower priority:
+- Quantifier-related issues (CBMC's own solver is quantifier-free)
+- Datatype-related issues (Z3#7842 — CBMC doesn't use SMT datatypes for FP)
+- Performance issues (Z3#8282, CVC5#12383)
+- Incremental solving issues (Z3#8345 — CBMC doesn't use incremental mode)
+
+---
+
+## Progress Log
+
+- **2026-03-20**: Created initial tracking document. Fetched and catalogued all
+  55 issues from Z3 (Floats label), CVC5, and Bitwuzla. Extracted SMT-LIB
+  reproducers from issue bodies. Categorized by FP operation/feature.
+- **2026-03-20**: Created first batch of regression tests. Tested CBMC's SMT2
+  solver capabilities. Found the following bugs/gaps:
+  1. **fp.rem always returns +0.0** — CBMC's SMT2 solver `fp.rem` implementation
+     appears to be broken, always returning positive zero regardless of inputs.
+     Test: `regression/smt2_solver/fp-rem-nonstandard/fp-rem1.smt2` (KNOWNBUG)
+  2. **remainderf/remainder crashes CBMC** — The C front-end crashes with an
+     invariant violation in `numeric_cast_v` when processing `remainderf()` or
+     `remainder()`. The crash involves a 128-bit floatbv constant.
+     Test: `regression/cbmc/Float-rem1/` (KNOWNBUG)
+  3. **fp.fma not supported in SMT2 solver** — The solver reports "unknown
+     function symbol 'fp.fma'" and ignores the assertion, leading to incorrect
+     results. Test: `regression/smt2_solver/fp/fp-fma-unsupported1.smt2`
+  4. **fp.to_real not supported in SMT2 solver** — Same behavior as fp.fma.
+     Test: `regression/smt2_solver/fp/fp-to-real-unsupported1.smt2`
+
+  Tests passing correctly:
+  - NaN equality through UFs (Z3#6728)
+  - fp.sub with all rounding modes including RTN→-0 (Z3#7162)
+  - fp.div with RTN and non-standard sorts (CVC5#11139, Bitwuzla#130)
+  - fp.rem on non-standard sort doesn't crash (Z3#8414)
+  - Overflow to infinity (Z3#4673)
+  - NaN propagation in C (Z3#6728)
+  - x - x == +0 with RNE in C (Z3#7162)
+  - Float division edge cases in C (CVC5#11139, Bitwuzla#130)
+  - fmaf correctness in C (Z3#7162, CVC5#11139)
+  - Overflow to infinity in C (Z3#4673)
+- **2026-03-20**: Second batch of tests. Found roundToIntegral bug on
+  non-standard FP sorts. Added BF16 tests (CVC5#12306), truncf C test.
+  5. **fp.roundToIntegral broken on non-standard FP sorts** — Returns
+     input unchanged instead of truncating to integer value.
+- **2026-03-20**: Third batch. Added FP conversion tests, signed zero
+  tests, to_fp from BV gap documentation. Comprehensive capability
+  matrix added to tracking document.
+  6. **to_fp from bitvector not supported** — Reinterpret cast from BV
+     to FP is not implemented.
+  Also documented: fp.sqrt, fp.min, fp.max, fp.isSubnormal,
+  fp.isNegative, fp.isPositive, fp.to_sbv, fp.to_ubv all unsupported.
+- **2026-03-20**: Analyzed all 55 issues. Status summary:
+  - 14 tests added (SMT-LIB + C)
+  - 6 bugs/gaps found in CBMC
+  - 12 issues N/A (meta-issues, performance, Z3-specific features)
+  - 15 issues require unsupported features (fp.to_real, fp.fma, etc.)
+  - Remaining issues need deeper analysis or involve consolidated bugs
+- **2026-03-20**: Deep analysis of implementation effort. Reviewed branch
+  `tautschnig/cleanup/floatbv-mod-rem` which addresses fp.rem, fmod,
+  remainder crash, and FMA. Found additional bug: fp.to_sbv/fp.to_ubv
+  crash with non-RTZ rounding modes. See IMPLEMENTATION_ANALYSIS.md for
+  full effort estimates and design sketches for all remaining gaps.
+- **2026-03-20**: Implemented fixes for issues independent of the branch:
+  1. Added `fp.isSubnormal`, `fp.isNegative`, `fp.isPositive` to SMT2 parser
+  2. Added `to_fp` from BitVec (reinterpret cast) — KNOWNBUG→CORE
+  3. Fixed `fp.to_sbv`/`fp.to_ubv` crash with non-RTZ rounding modes
+  4. Fixed `fp.roundToIntegral` on non-standard FP sorts — KNOWNBUG→CORE
+     Root cause: magic number 2^f not representable; fix: widen format
+- **2026-03-20**: Created comprehensive test suite: 33 additional SMT-LIB
+  tests in fp-issues/ covering all 55 catalogued issues. Total: 47 SMT-LIB
+  tests + 9 C tests. 22 new CORE tests passing, 11 new KNOWNBUG tests
+  documenting remaining gaps (fp.fma×3, fp.to_real×4, fp.rem×2,
+  fp.isZero(-0)×1, to_fp overflow×1). Also found fp.isZero(-0) bug.
+- **2026-03-20**: Filled remaining test gaps. Added 15 more tests including
+  quantified versions of FPA issues. Final count: 48 tests in fp-issues/
+  (31 CORE, 17 KNOWNBUG) + 14 tests in other fp-* dirs + 9 C tests = 71
+  total. Only 6 issues intentionally without tests (Z3-specific features,
+  pure performance, incremental solving).
diff --git a/regression/fp-solvers-issues/REMAINING_PLAN.md b/regression/fp-solvers-issues/REMAINING_PLAN.md
new file mode 100644
index 00000000000..2056be6d705
--- /dev/null
+++ b/regression/fp-solvers-issues/REMAINING_PLAN.md
@@ -0,0 +1,194 @@
+# Plan: Remaining FP Issues
+
+## Phase 1: After `tautschnig/cleanup/floatbv-mod-rem` Lands
+
+These are blocked by the branch and become straightforward once it merges.
+
+### 1.1 `fp.fma` in SMT2 parser (~30 min)
+
+The branch adds the full back-end (`float_utilst::fma`, `boolbvt`, `smt2_conv`).
+Only the parser entry is missing.
+
+- Add to `smt2_parser.cpp` `expressions["fp.fma"]`: parse 4 operands
+  (rm + 3 FP), construct `floatbv_fma_exprt(op[1], op[2], op[3], op[0])`
+- Turn KNOWNBUG tests to CORE: `z3-6117-fma`, `z3-7162-fma`,
+  `cvc5-11139-fma`, `fp-fma-unsupported1`
+
+### 1.2 `fp.rem` KNOWNBUG→CORE (~15 min)
+
+The branch fixes `float_utilst::rem()`. Just verify and flip:
+- `z3-2381-rem-specific`, `z3-6553-rem`, `fp-rem1`
+
+### 1.3 C front-end `fma` and `remainder` KNOWNBUG→CORE (~15 min)
+
+The branch adds `__CPROVER_fma{,f,l}` and `__CPROVER_remainder{,f,l}`.
+- `Float-fma-precision1`, `Float-rem1`
+
+---
+
+## Phase 2: Independent Fixes (no branch dependency)
+
+### 2.1 Fix `fp.sqrt` rounding mode handling (~2-4 hours)
+
+**Problem**: The current constraint `r*r_low <= x <= r*r_high` finds *a*
+valid square root but doesn't enforce the correct rounding direction.
+
+**Plan**:
+1. After finding `r` via the bracketing constraint, also compute `r_next`
+   (the next FP value above `r`) using an increment operation.
+2. Add constraints that select between `r` and `r_next` based on the
+   rounding mode:
+   - RTZ/RTN: pick the smaller of `r`, `r_next` (the one whose square
+     doesn't exceed `x`)
+   - RTP: pick the larger (the one whose square is >= exact sqrt)
+   - RNE: pick whichever `r` or `r_next` has `r*r` closer to `x`;
+     on tie, pick the one with LSB=0
+   - RNA: pick whichever is closer; on tie, pick the larger
+3. This is essentially the same logic as the C library model but encoded
+   at the SAT level.
+
+**Files**: `src/solvers/floatbv/float_utils.cpp` (modify `sqrt()`)
+
+**Tests**: Turn `fp-sqrt-rtz` KNOWNBUG→CORE.
+
+### 2.2 Fix `fp.sqrt` subnormal handling (~1-2 hours)
+
+**Problem**: For subnormal inputs, `r*r` may lose precision due to
+subnormal arithmetic, making the bracketing constraint too loose.
+
+**Plan**:
+1. For subnormal inputs, the result is always normal (sqrt makes the
+   exponent larger). The issue is that `r*r` with RTZ may underflow
+   to a different subnormal than `x`.
+2. Fix: widen the multiplication to double precision (similar to the
+   `roundToIntegral` fix), compute `r*r` in the wider format, then
+   compare with `x` widened to the same format.
+3. Alternative: use the same approach as the C library — constrain
+   `r >= 0 && r*r == x` directly for subnormals (since the C library
+   comment says "all subnormals seem to be perfect squares" in FP
+   arithmetic).
+
+**Files**: `src/solvers/floatbv/float_utils.cpp` (modify `sqrt()`)
+
+**Tests**: Turn `fp-sqrt-subnormal` KNOWNBUG→CORE.
+
+### 2.3 Add `__CPROVER_sqrtf` built-in to C front-end (~2-3 hours)
+
+**Problem**: `sqrtf`/`sqrt`/`sqrtl` use a `__VERIFIER_nondet` + assume
+model that has known rounding and subnormal issues.
+
+**Plan**:
+1. Add `__CPROVER_sqrt{,f,l}` to `cprover_builtin_headers.h`
+2. Add type-checking in `c_typecheck_expr.cpp` (same pattern as
+   `__CPROVER_fmod`): construct a `floatbv_sqrt_exprt` or reuse
+   `ieee_float_op_exprt` with `ID_floatbv_sqrt`
+3. Add rounding mode insertion in `adjust_float_expressions.cpp`
+4. Update `math.c` to use `__CPROVER_sqrtf(x)` instead of the
+   nondet model
+5. Add `ID_floatbv_sqrt` handling in `smt2_conv.cpp`: emit
+   `(fp.sqrt RM x)` when using FPA theory
+6. Add `ID_floatbv_sqrt` handling in `float_bv.cpp` for constant
+   folding (or leave as TODO with a clear error)
+
+**Files**: `src/ansi-c/cprover_builtin_headers.h`,
+`src/ansi-c/c_typecheck_expr.cpp`, `src/ansi-c/library/math.c`,
+`src/goto-programs/adjust_float_expressions.cpp`,
+`src/solvers/smt2/smt2_conv.cpp`, `src/solvers/floatbv/float_bv.cpp`
+
+**Tests**: Turn `Float-sqrt-rounding1` KNOWNBUG→CORE.
+
+### 2.4 Add `__CPROVER_fmin`/`__CPROVER_fmax` built-ins (~2-3 hours)
+
+**Problem**: `fmin`/`fmax` C library models use `(f <= g) ? f : g` which
+doesn't handle the -0/+0 tie-breaking correctly.
+
+**Plan**:
+1. Add `__CPROVER_fmin{,f,l}` and `__CPROVER_fmax{,f,l}` to
+   `cprover_builtin_headers.h`
+2. Add new expression types `ID_floatbv_min`/`ID_floatbv_max` to
+   `irep_ids.def`
+3. Type-check in `c_typecheck_expr.cpp`
+4. Handle in `boolbv.cpp` → dispatch to `float_utilst` (add `min()`
+   and `max()` methods, or express as compound like the parser does)
+5. Handle in `smt2_conv.cpp`: emit `(fp.min x y)` / `(fp.max x y)`
+6. Update `math.c` to use the built-ins
+7. Handle in `float_bv.cpp` for constant folding
+
+**Files**: Same set as 2.3 plus `src/solvers/floatbv/float_utils.{h,cpp}`
+
+**Tests**: Turn `Float-fmin-zero-sign1` KNOWNBUG→CORE.
+
+---
+
+## Phase 3: Larger Efforts
+
+### 3.1 `fp.to_real` support (~1-2 days)
+
+**Problem**: `fp.to_real` converts FP to exact rational. CBMC's solver
+has no rational arithmetic.
+
+**Plan (SMT2 output path only)**:
+1. Add `ID_floatbv_to_real` to `irep_ids.def`
+2. Parse `fp.to_real` in `smt2_parser.cpp`
+3. In `smt2_conv.cpp`, emit `(fp.to_real x)` when using FPA theory
+4. For the standalone SAT-based solver, report a clear error:
+   `"fp.to_real requires an external SMT solver with Real arithmetic"`
+
+This doesn't give full standalone solver support but unblocks CBMC users
+who use `--smt2` with Z3/CVC5.
+
+**Tests**: Turn `fp.to_real` KNOWNBUG tests to CORE (for the SMT2 output
+path) or update them to test the error message (for standalone solver).
+
+### 3.2 `to_fp` from non-constant Real (~1 hour)
+
+**Problem**: `((_ to_fp 8 24) RNE x)` where `x` is a Real variable
+(not a constant) is not supported.
+
+**Plan**: Same approach as 3.1 — support in SMT2 output path only.
+For the standalone solver, this would require Real→FP conversion which
+needs rational arithmetic.
+
+### 3.3 `to_fp` from large Real constant (~1 hour)
+
+**Problem**: `((_ to_fp 8 24) RNE 1e40)` fails because the parser
+tries to convert the real constant to FP but the conversion code
+doesn't handle overflow to infinity.
+
+**Plan**: In the `to_fp` parsing code in `smt2_parser.cpp`, after
+calling `ieee_floatt::from_base10()`, check if the result is infinity
+and allow it (currently it may error or produce wrong results).
+
+### 3.4 Quantifier support for FP (~large, out of scope)
+
+The 4 quantifier KNOWNBUG tests document a pre-existing limitation:
+the standalone solver ignores quantifiers with a warning. Full quantifier
+support would require quantifier instantiation or MBQI, which is a
+major architectural change. These tests serve as documentation.
+
+---
+
+## Dependency Graph
+
+```
+Branch lands ──→ 1.1 fp.fma parser
+              ──→ 1.2 fp.rem KNOWNBUG→CORE
+              ──→ 1.3 C fma/remainder KNOWNBUG→CORE
+
+Independent ──→ 2.1 fp.sqrt rounding ──→ 2.3 C sqrt built-in
+            ──→ 2.2 fp.sqrt subnormal ─┘
+            ──→ 2.4 C fmin/fmax built-in
+            ──→ 3.3 to_fp large Real constant
+
+Later ──→ 3.1 fp.to_real (SMT2 output path)
+      ──→ 3.2 to_fp from Real variable
+      ──→ 3.4 Quantifiers (out of scope)
+```
+
+## Effort Summary
+
+| Phase | Items | Total Effort |
+|-------|-------|-------------|
+| Phase 1 (after branch) | 1.1, 1.2, 1.3 | ~1 hour |
+| Phase 2 (independent) | 2.1, 2.2, 2.3, 2.4 | ~8-12 hours |
+| Phase 3 (larger) | 3.1, 3.2, 3.3, 3.4 | ~2-3 days |
diff --git a/regression/smt2_solver/fp-bf16/bf16-mul-bounds1.desc b/regression/smt2_solver/fp-bf16/bf16-mul-bounds1.desc
new file mode 100644
index 00000000000..51b246b80e3
--- /dev/null
+++ b/regression/smt2_solver/fp-bf16/bf16-mul-bounds1.desc
@@ -0,0 +1,8 @@
+CORE
+bf16-mul-bounds1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Based on CVC5#12306: BF16 multiplication with symmetric bound checks.
diff --git a/regression/smt2_solver/fp-bf16/bf16-mul-bounds1.smt2 b/regression/smt2_solver/fp-bf16/bf16-mul-bounds1.smt2
new file mode 100644
index 00000000000..5ac77822a72
--- /dev/null
+++ b/regression/smt2_solver/fp-bf16/bf16-mul-bounds1.smt2
@@ -0,0 +1,22 @@
+; Based on CVC5#12306: BF16 multiplication with bound checking.
+; c * x * x should produce consistent results regardless of
+; the order of bound checks in an OR.
+
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 8))
+(declare-const c (_ FloatingPoint 8 8))
+
+; c * x * x
+(define-fun cxx () (_ FloatingPoint 8 8)
+  (fp.mul RNE (fp.mul RNE c x) x))
+
+; Some bound value
+(define-fun bound () (_ FloatingPoint 8 8)
+  (fp #b0 #b10000010 #b0000000))
+
+; Check: (fp.gt cxx bound) or (fp.lt cxx (fp.neg bound))
+; should be the same as
+; (fp.lt cxx (fp.neg bound)) or (fp.gt cxx bound)
+(assert (not (= (or (fp.gt cxx bound) (fp.lt cxx (fp.neg bound)))
+               (or (fp.lt cxx (fp.neg bound)) (fp.gt cxx bound)))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-bf16/bf16-or-commute1.desc b/regression/smt2_solver/fp-bf16/bf16-or-commute1.desc
new file mode 100644
index 00000000000..95c092a4ec9
--- /dev/null
+++ b/regression/smt2_solver/fp-bf16/bf16-or-commute1.desc
@@ -0,0 +1,8 @@
+CORE
+bf16-or-commute1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Based on CVC5#12306: OR commutativity with BF16 bound checks.
diff --git a/regression/smt2_solver/fp-bf16/bf16-or-commute1.smt2 b/regression/smt2_solver/fp-bf16/bf16-or-commute1.smt2
new file mode 100644
index 00000000000..9b5add68aaa
--- /dev/null
+++ b/regression/smt2_solver/fp-bf16/bf16-or-commute1.smt2
@@ -0,0 +1,22 @@
+; Based on CVC5#12306: OR commutativity in BF16.
+; (or A B) should be equivalent to (or B A).
+; Test with FP bound checks on BF16 (_ FloatingPoint 8 8).
+
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 8))
+(declare-const c (_ FloatingPoint 8 8))
+
+; Some bound: x in [-5.87, -5.87 + 0.04]
+; -5.87 in BF16 ≈ fp #b1 #b10000001 #b0111100
+; -5.83 in BF16 ≈ fp #b1 #b10000001 #b0111010
+(define-fun lo () (_ FloatingPoint 8 8)
+  (fp #b1 #b10000001 #b0111100))
+(define-fun hi () (_ FloatingPoint 8 8)
+  (fp #b1 #b10000001 #b0111010))
+
+(define-fun bound_a () Bool (fp.geq x lo))
+(define-fun bound_b () Bool (fp.leq x hi))
+
+; (or bound_a bound_b) should equal (or bound_b bound_a)
+(assert (not (= (or bound_a bound_b) (or bound_b bound_a))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-div-fma/fp-div-eq-zero1.desc b/regression/smt2_solver/fp-div-fma/fp-div-eq-zero1.desc
new file mode 100644
index 00000000000..ce187330f88
--- /dev/null
+++ b/regression/smt2_solver/fp-div-fma/fp-div-eq-zero1.desc
@@ -0,0 +1,8 @@
+CORE
+fp-div-eq-zero1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Based on CVC5#12335: fp.div with fp.eq to zero (quantifier-free version).
diff --git a/regression/smt2_solver/fp-div-fma/fp-div-eq-zero1.smt2 b/regression/smt2_solver/fp-div-fma/fp-div-eq-zero1.smt2
new file mode 100644
index 00000000000..b594e69c0d7
--- /dev/null
+++ b/regression/smt2_solver/fp-div-fma/fp-div-eq-zero1.smt2
@@ -0,0 +1,19 @@
+; Based on CVC5#12335: fp.div RNE with fp.eq and fp.gt on Float32.
+; Quantifier-free version of the CVC5 issue.
+; If a >= +0 and V < x and A > +0 and A/V == +0, find a contradiction.
+
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 24))
+(declare-const a (_ FloatingPoint 8 24))
+(declare-const V (_ FloatingPoint 8 24))
+(declare-const A (_ FloatingPoint 8 24))
+
+(define-fun pzero () (_ FloatingPoint 8 24)
+  (fp #b0 #b00000000 #b00000000000000000000000))
+
+(assert (fp.lt V x))
+(assert (fp.eq a a))
+(assert (fp.gt A pzero))
+(assert (fp.eq (fp.div RNE A V) pzero))
+(assert (fp.geq a pzero))
+(check-sat)
diff --git a/regression/smt2_solver/fp-div-fma/fp-div-nonstandard1.desc b/regression/smt2_solver/fp-div-fma/fp-div-nonstandard1.desc
new file mode 100644
index 00000000000..bae17196289
--- /dev/null
+++ b/regression/smt2_solver/fp-div-fma/fp-div-nonstandard1.desc
@@ -0,0 +1,8 @@
+CORE
+fp-div-nonstandard1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Based on Bitwuzla#130: fp.div on non-standard FP sort (_ FloatingPoint 4 12).
diff --git a/regression/smt2_solver/fp-div-fma/fp-div-nonstandard1.smt2 b/regression/smt2_solver/fp-div-fma/fp-div-nonstandard1.smt2
new file mode 100644
index 00000000000..e70adeb3c41
--- /dev/null
+++ b/regression/smt2_solver/fp-div-fma/fp-div-nonstandard1.smt2
@@ -0,0 +1,15 @@
+; Based on Bitwuzla#130: fp.div on non-standard FP format (_ FloatingPoint 4 12).
+; Bitwuzla incorrectly returned unsat due to a SymFPU bug in fp.div
+; for non-standard formats.
+
+(set-logic QF_FP)
+(declare-const a (_ FloatingPoint 4 12))
+(declare-const b (_ FloatingPoint 4 12))
+
+; fp.div RNA a b should be satisfiable for non-NaN, non-zero b
+(assert (not (fp.isNaN a)))
+(assert (not (fp.isNaN b)))
+(assert (not (fp.isZero b)))
+(assert (not (fp.isInfinite b)))
+(assert (fp.gt (fp.div RNA a b) (fp #b0 #b0000 #b00000000000)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-div-fma/fp-div-rtn1.desc b/regression/smt2_solver/fp-div-fma/fp-div-rtn1.desc
new file mode 100644
index 00000000000..4b2cab49df9
--- /dev/null
+++ b/regression/smt2_solver/fp-div-fma/fp-div-rtn1.desc
@@ -0,0 +1,8 @@
+CORE
+fp-div-rtn1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Based on CVC5#11139: fp.div with RTN rounding on Float64.
diff --git a/regression/smt2_solver/fp-div-fma/fp-div-rtn1.smt2 b/regression/smt2_solver/fp-div-fma/fp-div-rtn1.smt2
new file mode 100644
index 00000000000..e35c4a17d75
--- /dev/null
+++ b/regression/smt2_solver/fp-div-fma/fp-div-rtn1.smt2
@@ -0,0 +1,17 @@
+; Based on CVC5#11139: fp.div with different rounding modes on Float64.
+; CVC5 crashes with symfpu postcondition failure on fp.div RTN.
+; Test that CBMC's solver handles fp.div correctly.
+
+(set-logic QF_FP)
+(declare-const a (_ FloatingPoint 11 53))
+(declare-const b (_ FloatingPoint 11 53))
+
+(define-fun pzero () (_ FloatingPoint 11 53)
+  (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000))
+
+; (a * a) / b == +0.0 should be satisfiable (e.g., a == 0, b == 1)
+(assert (= (fp.div RTN (fp.mul RTP a a) b) pzero))
+(assert (not (fp.isZero b)))
+(assert (not (fp.isNaN b)))
+(assert (not (fp.isInfinite b)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/bitwuzla-130-div-nonstandard.desc b/regression/smt2_solver/fp-issues/bitwuzla-130-div-nonstandard.desc
new file mode 100644
index 00000000000..c243aaab60e
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/bitwuzla-130-div-nonstandard.desc
@@ -0,0 +1,8 @@
+CORE
+bitwuzla-130-div-nonstandard.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Bitwuzla#130: fp.div RNA on non-standard sort
diff --git a/regression/smt2_solver/fp-issues/bitwuzla-130-div-nonstandard.smt2 b/regression/smt2_solver/fp-issues/bitwuzla-130-div-nonstandard.smt2
new file mode 100644
index 00000000000..f015431a99a
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/bitwuzla-130-div-nonstandard.smt2
@@ -0,0 +1,11 @@
+; Bitwuzla#130: fp.div RNA on (_ FloatingPoint 4 12)
+(set-logic QF_FP)
+(declare-const a (_ FloatingPoint 4 12))
+(declare-const b (_ FloatingPoint 4 12))
+(assert (not (fp.isNaN a)))
+(assert (not (fp.isNaN b)))
+(assert (not (fp.isZero b)))
+(assert (not (fp.isInfinite a)))
+(assert (not (fp.isInfinite b)))
+(assert (fp.eq (fp.div RNA a b) (fp #b0 #b0111 #b00000000000)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/cvc5-11139-fma.desc b/regression/smt2_solver/fp-issues/cvc5-11139-fma.desc
new file mode 100644
index 00000000000..dd3009f7166
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-11139-fma.desc
@@ -0,0 +1,8 @@
+CORE
+cvc5-11139-fma.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.fma now supported.
diff --git a/regression/smt2_solver/fp-issues/cvc5-11139-fma.desc.orig b/regression/smt2_solver/fp-issues/cvc5-11139-fma.desc.orig
new file mode 100644
index 00000000000..814bd6a9959
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-11139-fma.desc.orig
@@ -0,0 +1,16 @@
+<<<<<<< HEAD
+KNOWNBUG
+=======
+CORE
+>>>>>>> 0cd1170412 (Add __CPROVER_fma built-in and floatbv_fma_exprt expression)
+cvc5-11139-fma.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+<<<<<<< HEAD
+CVC5#11139: fp.fma unsupported
+=======
+fp.fma now supported.
+>>>>>>> 0cd1170412 (Add __CPROVER_fma built-in and floatbv_fma_exprt expression)
diff --git a/regression/smt2_solver/fp-issues/cvc5-11139-fma.smt2 b/regression/smt2_solver/fp-issues/cvc5-11139-fma.smt2
new file mode 100644
index 00000000000..f9fb9ad64b3
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-11139-fma.smt2
@@ -0,0 +1,8 @@
+; CVC5#11139: fp.div RTN of fp.fma RTP result on Float64.
+(set-logic QF_FP)
+(declare-const a (_ FloatingPoint 11 53))
+(declare-const b (_ FloatingPoint 11 53))
+(assert (= (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000)
+  (fp.div RTN (fp.fma RTP a a
+    (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000)) b)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/cvc5-12306-bf16-mul.desc b/regression/smt2_solver/fp-issues/cvc5-12306-bf16-mul.desc
new file mode 100644
index 00000000000..47bb11a9dbc
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-12306-bf16-mul.desc
@@ -0,0 +1,8 @@
+CORE
+cvc5-12306-bf16-mul.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+CVC5#12306: BF16 multiplication bound check
diff --git a/regression/smt2_solver/fp-issues/cvc5-12306-bf16-mul.smt2 b/regression/smt2_solver/fp-issues/cvc5-12306-bf16-mul.smt2
new file mode 100644
index 00000000000..e7dd97de6dc
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-12306-bf16-mul.smt2
@@ -0,0 +1,8 @@
+; CVC5#12306: BF16 multiplication with bound checking
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 8))
+(declare-const c (_ FloatingPoint 8 8))
+(assert (not (fp.isNaN x)))
+(assert (not (fp.isNaN c)))
+(assert (fp.gt (fp.mul RNE (fp.mul RNE c x) x) (fp #b0 #b10000010 #b0000000)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/cvc5-12335-div-eq.desc b/regression/smt2_solver/fp-issues/cvc5-12335-div-eq.desc
new file mode 100644
index 00000000000..393342ff721
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-12335-div-eq.desc
@@ -0,0 +1,8 @@
+CORE
+cvc5-12335-div-eq.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+CVC5#12335: fp.div with fp.eq (sat via V=+inf)
diff --git a/regression/smt2_solver/fp-issues/cvc5-12335-div-eq.smt2 b/regression/smt2_solver/fp-issues/cvc5-12335-div-eq.smt2
new file mode 100644
index 00000000000..3770d2cda8f
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-12335-div-eq.smt2
@@ -0,0 +1,9 @@
+; CVC5#12335: A > 0, V > 0, A/V cannot be +0
+(set-logic QF_FP)
+(declare-const V (_ FloatingPoint 8 24))
+(declare-const A (_ FloatingPoint 8 24))
+(define-fun pz () (_ FloatingPoint 8 24) (fp #b0 #b00000000 #b00000000000000000000000))
+(assert (fp.gt A pz))
+(assert (fp.gt V pz))
+(assert (fp.eq (fp.div RNE A V) pz))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/cvc5-12371-quant-to-fp-real.desc b/regression/smt2_solver/fp-issues/cvc5-12371-quant-to-fp-real.desc
new file mode 100644
index 00000000000..27f673a8eb6
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-12371-quant-to-fp-real.desc
@@ -0,0 +1,8 @@
+KNOWNBUG
+cvc5-12371-quant-to-fp-real.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+CVC5#12371: quantified to_fp from Real (quantifiers + non-const Real unsupported)
diff --git a/regression/smt2_solver/fp-issues/cvc5-12371-quant-to-fp-real.smt2 b/regression/smt2_solver/fp-issues/cvc5-12371-quant-to-fp-real.smt2
new file mode 100644
index 00000000000..af034792b07
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-12371-quant-to-fp-real.smt2
@@ -0,0 +1,7 @@
+; CVC5#12371: quantified formula with to_fp from Real
+; forall x: 0 >= ite(isInfinite(to_fp(x)), x, 0)
+; This should be unsat (counterexample: x = -1e40)
+(set-logic ALL)
+(assert (forall ((x Real))
+  (>= 0.0 (ite (fp.isInfinite ((_ to_fp 8 24) RNE x)) x 0.0))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/cvc5-12371-to-fp-real-inf.desc b/regression/smt2_solver/fp-issues/cvc5-12371-to-fp-real-inf.desc
new file mode 100644
index 00000000000..6879caab501
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-12371-to-fp-real-inf.desc
@@ -0,0 +1,8 @@
+CORE
+cvc5-12371-to-fp-real-inf.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+CVC5#12371: infinity literal predicates
diff --git a/regression/smt2_solver/fp-issues/cvc5-12371-to-fp-real-inf.smt2 b/regression/smt2_solver/fp-issues/cvc5-12371-to-fp-real-inf.smt2
new file mode 100644
index 00000000000..0d0614e3824
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-12371-to-fp-real-inf.smt2
@@ -0,0 +1,5 @@
+; CVC5#12371: to_fp from large constant Real overflows to infinity
+(set-logic QF_FP)
+(assert (fp.isInfinite ((_ to_fp 8 24) RNE 10000000000000000000000000000000000000000.0)))
+(assert (fp.isPositive ((_ to_fp 8 24) RNE 10000000000000000000000000000000000000000.0)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/cvc5-12387-nan-ite.desc b/regression/smt2_solver/fp-issues/cvc5-12387-nan-ite.desc
new file mode 100644
index 00000000000..e1782eb86ac
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-12387-nan-ite.desc
@@ -0,0 +1,8 @@
+CORE
+cvc5-12387-nan-ite.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+CVC5#12387: fp.eq is symmetric
diff --git a/regression/smt2_solver/fp-issues/cvc5-12387-nan-ite.smt2 b/regression/smt2_solver/fp-issues/cvc5-12387-nan-ite.smt2
new file mode 100644
index 00000000000..7ca0d712e45
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/cvc5-12387-nan-ite.smt2
@@ -0,0 +1,9 @@
+; CVC5#12387: fp.eq is symmetric
+(set-logic QF_FP)
+(declare-const x Bool)
+(declare-const o (_ FloatingPoint 8 24))
+(define-fun v1 () (_ FloatingPoint 8 24) (ite x o (_ NaN 8 24)))
+(define-fun v2 () (_ FloatingPoint 8 24) (_ -oo 8 24))
+(assert (fp.eq v1 v2))
+(assert (not (fp.eq v2 v1)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/fp-min-max.desc b/regression/smt2_solver/fp-issues/fp-min-max.desc
new file mode 100644
index 00000000000..5637f6f7d6d
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/fp-min-max.desc
@@ -0,0 +1,8 @@
+CORE
+fp-min-max.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.min and fp.max: basic cases, zero sign, NaN handling.
diff --git a/regression/smt2_solver/fp-issues/fp-min-max.smt2 b/regression/smt2_solver/fp-issues/fp-min-max.smt2
new file mode 100644
index 00000000000..b6cce206f22
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/fp-min-max.smt2
@@ -0,0 +1,36 @@
+; Test fp.min and fp.max with various cases
+(set-logic QF_FP)
+
+; min(1.0, 2.0) = 1.0
+(assert (fp.eq (fp.min
+  (fp #b0 #b01111111 #b00000000000000000000000)
+  (fp #b0 #b10000000 #b00000000000000000000000))
+  (fp #b0 #b01111111 #b00000000000000000000000)))
+
+; max(1.0, 2.0) = 2.0
+(assert (fp.eq (fp.max
+  (fp #b0 #b01111111 #b00000000000000000000000)
+  (fp #b0 #b10000000 #b00000000000000000000000))
+  (fp #b0 #b10000000 #b00000000000000000000000)))
+
+; min(-0, +0) = -0
+(assert (fp.isNegative (fp.min
+  (fp #b1 #b00000000 #b00000000000000000000000)
+  (fp #b0 #b00000000 #b00000000000000000000000))))
+
+; max(-0, +0) = +0
+(assert (fp.isPositive (fp.max
+  (fp #b1 #b00000000 #b00000000000000000000000)
+  (fp #b0 #b00000000 #b00000000000000000000000))))
+
+; min(NaN, 1.0) = 1.0
+(assert (fp.eq (fp.min (_ NaN 8 24)
+  (fp #b0 #b01111111 #b00000000000000000000000))
+  (fp #b0 #b01111111 #b00000000000000000000000)))
+
+; max(NaN, 1.0) = 1.0
+(assert (fp.eq (fp.max (_ NaN 8 24)
+  (fp #b0 #b01111111 #b00000000000000000000000))
+  (fp #b0 #b01111111 #b00000000000000000000000)))
+
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/fp-sqrt-rtz.desc b/regression/smt2_solver/fp-issues/fp-sqrt-rtz.desc
new file mode 100644
index 00000000000..bafe72ca5d0
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/fp-sqrt-rtz.desc
@@ -0,0 +1,8 @@
+CORE
+fp-sqrt-rtz.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+fp.sqrt(2.0) with RTZ: floor of sqrt(2) is 0x3FB504F3.
diff --git a/regression/smt2_solver/fp-issues/fp-sqrt-rtz.smt2 b/regression/smt2_solver/fp-issues/fp-sqrt-rtz.smt2
new file mode 100644
index 00000000000..7ced644d767
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/fp-sqrt-rtz.smt2
@@ -0,0 +1,6 @@
+; fp.sqrt(2.0) with RTZ should be 0x3FB504F3 (floor of sqrt(2))
+; sqrt(2) ≈ 1.41421356..., F3 = 1.41421353... < sqrt(2) < F4 = 1.41421365...
+(set-logic QF_FP)
+(assert (not (= (fp.sqrt RTZ (fp #b0 #b10000000 #b00000000000000000000000))
+               (fp #b0 #b01111111 #b01101010000010011110011))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/fp-sqrt-subnormal.desc b/regression/smt2_solver/fp-issues/fp-sqrt-subnormal.desc
new file mode 100644
index 00000000000..6d9bdb913ab
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/fp-sqrt-subnormal.desc
@@ -0,0 +1,8 @@
+CORE
+fp-sqrt-subnormal.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+fp.sqrt of subnormal input gives correct result.
diff --git a/regression/smt2_solver/fp-issues/fp-sqrt-subnormal.smt2 b/regression/smt2_solver/fp-issues/fp-sqrt-subnormal.smt2
new file mode 100644
index 00000000000..3f0ef4a0058
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/fp-sqrt-subnormal.smt2
@@ -0,0 +1,6 @@
+; fp.sqrt of subnormal input: sqrt(4 * 2^-149) = sqrt(2) * 2^-74
+(set-logic QF_FP)
+(declare-const r (_ FloatingPoint 8 24))
+(assert (= r (fp.sqrt RNE (fp #b0 #b00000000 #b00000000000000000000100))))
+(assert (not (= r (fp #b0 #b00110101 #b01101010000010011110011))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/fp-sqrt.desc b/regression/smt2_solver/fp-issues/fp-sqrt.desc
new file mode 100644
index 00000000000..17f20e676c1
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/fp-sqrt.desc
@@ -0,0 +1,8 @@
+CORE
+fp-sqrt.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.sqrt: perfect squares, NaN, negative, zero, infinity.
diff --git a/regression/smt2_solver/fp-issues/fp-sqrt.smt2 b/regression/smt2_solver/fp-issues/fp-sqrt.smt2
new file mode 100644
index 00000000000..5d0a83e96c7
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/fp-sqrt.smt2
@@ -0,0 +1,26 @@
+; Test fp.sqrt with various cases
+(set-logic QF_FP)
+
+; sqrt(4.0) = 2.0
+(assert (fp.eq (fp.sqrt RNE
+  (fp #b0 #b10000001 #b00000000000000000000000))
+  (fp #b0 #b10000000 #b00000000000000000000000)))
+
+; sqrt(9.0) = 3.0
+(assert (fp.eq (fp.sqrt RNE
+  (fp #b0 #b10000010 #b00100000000000000000000))
+  (fp #b0 #b10000000 #b10000000000000000000000)))
+
+; sqrt(NaN) = NaN
+(assert (fp.isNaN (fp.sqrt RNE (_ NaN 8 24))))
+
+; sqrt(-1) = NaN
+(assert (fp.isNaN (fp.sqrt RNE (fp #b1 #b01111111 #b00000000000000000000000))))
+
+; sqrt(+0) = +0
+(assert (fp.isZero (fp.sqrt RNE (fp #b0 #b00000000 #b00000000000000000000000))))
+
+; sqrt(+inf) = +inf
+(assert (fp.isInfinite (fp.sqrt RNE (_ +oo 8 24))))
+
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-2381-rem-specific.desc b/regression/smt2_solver/fp-issues/z3-2381-rem-specific.desc
new file mode 100644
index 00000000000..d563230c6d1
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-2381-rem-specific.desc
@@ -0,0 +1,8 @@
+CORE
+z3-2381-rem-specific.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#2381: fp.rem(5.0, 3.0) == -1.0 (IEEE 754 remainder).
diff --git a/regression/smt2_solver/fp-issues/z3-2381-rem-specific.desc.orig b/regression/smt2_solver/fp-issues/z3-2381-rem-specific.desc.orig
new file mode 100644
index 00000000000..7b282ad120d
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-2381-rem-specific.desc.orig
@@ -0,0 +1,16 @@
+<<<<<<< HEAD
+CORE
+=======
+KNOWNBUG
+>>>>>>> fa7a81e906 (Add comprehensive SMT-LIB tests for external FP solver issues)
+z3-2381-rem-specific.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+<<<<<<< HEAD
+Z3#2381: fp.rem(5.0, 3.0) == -1.0 (IEEE 754 remainder).
+=======
+Z3#2381: fp.rem bug (always returns +0)
+>>>>>>> fa7a81e906 (Add comprehensive SMT-LIB tests for external FP solver issues)
diff --git a/regression/smt2_solver/fp-issues/z3-2381-rem-specific.smt2 b/regression/smt2_solver/fp-issues/z3-2381-rem-specific.smt2
new file mode 100644
index 00000000000..7a65602f050
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-2381-rem-specific.smt2
@@ -0,0 +1,7 @@
+; Z3#2381: fp.rem(5.0, 3.0) should be -1.0
+(set-logic QF_FP)
+(assert (not (= (fp.rem
+  (fp #b0 #b10000001 #b01000000000000000000000)
+  (fp #b0 #b10000000 #b10000000000000000000000))
+  (fp #b1 #b01111111 #b00000000000000000000000))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-2596-nan-eq.desc b/regression/smt2_solver/fp-issues/z3-2596-nan-eq.desc
new file mode 100644
index 00000000000..823839a4ec4
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-2596-nan-eq.desc
@@ -0,0 +1,8 @@
+CORE
+z3-2596-nan-eq.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#2596: fp.eq(NaN, NaN) is always false
diff --git a/regression/smt2_solver/fp-issues/z3-2596-nan-eq.smt2 b/regression/smt2_solver/fp-issues/z3-2596-nan-eq.smt2
new file mode 100644
index 00000000000..179a5e1d891
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-2596-nan-eq.smt2
@@ -0,0 +1,6 @@
+; Z3#2596: fp.eq(NaN, NaN) is always false
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 24))
+(assert (fp.isNaN x))
+(assert (fp.eq x x))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-2631-quant-fpa.desc b/regression/smt2_solver/fp-issues/z3-2631-quant-fpa.desc
new file mode 100644
index 00000000000..6752abff397
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-2631-quant-fpa.desc
@@ -0,0 +1,9 @@
+CORE
+z3-2631-quant-fpa.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#2631: quantified FPA negation — counterexample x=c found via
+relevant value set instantiation.
diff --git a/regression/smt2_solver/fp-issues/z3-2631-quant-fpa.smt2 b/regression/smt2_solver/fp-issues/z3-2631-quant-fpa.smt2
new file mode 100644
index 00000000000..ead8a3eaa4e
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-2631-quant-fpa.smt2
@@ -0,0 +1,7 @@
+; Z3#2631: quantified FPA formula - negation through to_fp roundtrip
+; Should be unsat (neg(to_fp(bv(x))) always equals neg(to_fp(bv(c))) when x=c)
+(set-logic FP)
+(declare-const c (_ FloatingPoint 8 24))
+(assert (forall ((x (_ FloatingPoint 8 24)))
+  (not (= (fp.neg x) (fp.neg c)))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-2631-quant-neg-roundtrip.desc b/regression/smt2_solver/fp-issues/z3-2631-quant-neg-roundtrip.desc
new file mode 100644
index 00000000000..311e94b1509
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-2631-quant-neg-roundtrip.desc
@@ -0,0 +1,8 @@
+CORE
+z3-2631-quant-neg-roundtrip.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#2631: negation is self-inverse
diff --git a/regression/smt2_solver/fp-issues/z3-2631-quant-neg-roundtrip.smt2 b/regression/smt2_solver/fp-issues/z3-2631-quant-neg-roundtrip.smt2
new file mode 100644
index 00000000000..124f5afde19
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-2631-quant-neg-roundtrip.smt2
@@ -0,0 +1,5 @@
+; Z3#2631: negation is self-inverse: neg(neg(x)) == x
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 24))
+(assert (not (= (fp.neg (fp.neg x)) x)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-4843-zero-eq.desc b/regression/smt2_solver/fp-issues/z3-4843-zero-eq.desc
new file mode 100644
index 00000000000..4947cddf53d
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4843-zero-eq.desc
@@ -0,0 +1,8 @@
+CORE
+z3-4843-zero-eq.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#4843: -0 and +0 are fp.eq
diff --git a/regression/smt2_solver/fp-issues/z3-4843-zero-eq.smt2 b/regression/smt2_solver/fp-issues/z3-4843-zero-eq.smt2
new file mode 100644
index 00000000000..f131261cb8c
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4843-zero-eq.smt2
@@ -0,0 +1,6 @@
+; Z3#4843: -0 and +0 are fp.eq (should be unsat)
+(set-logic QF_FP)
+(assert (not (fp.eq
+  (fp #b1 #b00000000000 #b0000000000000000000000000000000000000000000000000000)
+  (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-4855-div-rounding.desc b/regression/smt2_solver/fp-issues/z3-4855-div-rounding.desc
new file mode 100644
index 00000000000..cbbc6ec2907
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4855-div-rounding.desc
@@ -0,0 +1,8 @@
+CORE
+z3-4855-div-rounding.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#4855: fp.div with RTZ rounding
diff --git a/regression/smt2_solver/fp-issues/z3-4855-div-rounding.smt2 b/regression/smt2_solver/fp-issues/z3-4855-div-rounding.smt2
new file mode 100644
index 00000000000..f278f24dde9
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4855-div-rounding.smt2
@@ -0,0 +1,12 @@
+; Z3#4855: fp.div with RTZ rounding on specific values
+(set-logic QF_FP)
+(declare-fun c () (_ FloatingPoint 8 24))
+; 1.0 / 1.6 with RTZ
+(define-fun b () (_ FloatingPoint 8 24) (fp.div RTZ
+  (fp #b0 #b01111111 #b00000000000000000000000)
+  (fp #b0 #b01111111 #b10011001100110011001101)))
+; c / 2.0 >= 0 with RTZ
+(assert (not (fp.lt (fp.div RTZ c
+  (fp #b0 #b10000000 #b00000000000000000000000))
+  (fp #b0 #b00000000 #b00000000000000000000000))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-4858-sub-add-div.desc b/regression/smt2_solver/fp-issues/z3-4858-sub-add-div.desc
new file mode 100644
index 00000000000..6e0862d03a6
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4858-sub-add-div.desc
@@ -0,0 +1,9 @@
+CORE
+z3-4858-sub-add-div.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#4858: fp.sub/fp.add with RTZ and subnormals. Sat because large
+normal f absorbs subnormal h in f+h, so f-(f+h)=0 != -h.
diff --git a/regression/smt2_solver/fp-issues/z3-4858-sub-add-div.smt2 b/regression/smt2_solver/fp-issues/z3-4858-sub-add-div.smt2
new file mode 100644
index 00000000000..93c313edd1d
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4858-sub-add-div.smt2
@@ -0,0 +1,11 @@
+; Z3#4858: fp.sub and fp.add with RTZ rounding
+(set-logic QF_FP)
+(declare-fun f () (_ FloatingPoint 8 24))
+(declare-fun h () (_ FloatingPoint 8 24))
+; f - (f + h) with RTZ: if h is subnormal and f is large, result is -h or 0
+(assert (not (fp.isNaN f)))
+(assert (not (fp.isInfinite f)))
+(assert (fp.isSubnormal h))
+(assert (fp.isNormal f))
+(assert (not (fp.eq (fp.sub RTZ f (fp.add RTZ f h)) (fp.neg h))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-4861-roundToIntegral-float16.desc b/regression/smt2_solver/fp-issues/z3-4861-roundToIntegral-float16.desc
new file mode 100644
index 00000000000..9ccd490c7fa
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4861-roundToIntegral-float16.desc
@@ -0,0 +1,8 @@
+CORE
+z3-4861-roundToIntegral-float16.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#4861: roundToIntegral RNE on Float16
diff --git a/regression/smt2_solver/fp-issues/z3-4861-roundToIntegral-float16.smt2 b/regression/smt2_solver/fp-issues/z3-4861-roundToIntegral-float16.smt2
new file mode 100644
index 00000000000..d9783b20aff
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4861-roundToIntegral-float16.smt2
@@ -0,0 +1,8 @@
+; Z3#4861: roundToIntegral RNE on Float16
+; a = 2.0078125 (fp #b0 #b10000 #b0000001000), roundToIntegral RNE = 2.0
+(set-logic QF_FP)
+(declare-fun a () (_ FloatingPoint 5 11))
+(declare-fun b () (_ FloatingPoint 5 11))
+(assert (= b (fp.roundToIntegral RNE a)))
+(assert (= b (fp #b0 #b10000 #b0000000000)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-4862-convert-nonstandard.desc b/regression/smt2_solver/fp-issues/z3-4862-convert-nonstandard.desc
new file mode 100644
index 00000000000..278d327c98e
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4862-convert-nonstandard.desc
@@ -0,0 +1,8 @@
+CORE
+z3-4862-convert-nonstandard.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#4862: conversion between non-standard FP sorts
diff --git a/regression/smt2_solver/fp-issues/z3-4862-convert-nonstandard.smt2 b/regression/smt2_solver/fp-issues/z3-4862-convert-nonstandard.smt2
new file mode 100644
index 00000000000..3d141ebe582
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4862-convert-nonstandard.smt2
@@ -0,0 +1,8 @@
+; Z3#4862: conversion from (_ FloatingPoint 11 53) to (_ FloatingPoint 9 53)
+(set-logic QF_FP)
+(declare-fun X () (_ FloatingPoint 11 53))
+(declare-fun Y () (_ FloatingPoint 9 53))
+(assert (fp.leq X (fp #b0 #b10011111110 #b1111111111111111111111111111111111111111111111111111)))
+(assert (= Y ((_ to_fp 9 53) RNE X)))
+(assert (not (fp.isInfinite Y)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-4880-min-neg-zero.desc b/regression/smt2_solver/fp-issues/z3-4880-min-neg-zero.desc
new file mode 100644
index 00000000000..86c3aa78ee6
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4880-min-neg-zero.desc
@@ -0,0 +1,8 @@
+CORE
+z3-4880-min-neg-zero.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#4880: fp.min(-0, +0) is negative (quantifier-free core).
diff --git a/regression/smt2_solver/fp-issues/z3-4880-min-neg-zero.smt2 b/regression/smt2_solver/fp-issues/z3-4880-min-neg-zero.smt2
new file mode 100644
index 00000000000..abc59062469
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4880-min-neg-zero.smt2
@@ -0,0 +1,6 @@
+; Z3#4880: fp.min(-0, +0) is negative (quantifier-free core)
+(set-logic QF_FP)
+(assert (not (fp.isNegative (fp.min
+  (fp #b1 #b00000000 #b00000000000000000000000)
+  (fp #b0 #b00000000 #b00000000000000000000000)))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-4880-neg-zero.desc b/regression/smt2_solver/fp-issues/z3-4880-neg-zero.desc
new file mode 100644
index 00000000000..d09300101d4
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4880-neg-zero.desc
@@ -0,0 +1,8 @@
+CORE
+z3-4880-neg-zero.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#4880: -0 is negative per fp.isNegative
diff --git a/regression/smt2_solver/fp-issues/z3-4880-neg-zero.smt2 b/regression/smt2_solver/fp-issues/z3-4880-neg-zero.smt2
new file mode 100644
index 00000000000..21194a23c60
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4880-neg-zero.smt2
@@ -0,0 +1,4 @@
+; Z3#4880: -0 is negative per fp.isNegative (should be unsat)
+(set-logic QF_FP)
+(assert (not (fp.isNegative (fp #b1 #b00000000 #b00000000000000000000000))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-4880-quant-min.desc b/regression/smt2_solver/fp-issues/z3-4880-quant-min.desc
new file mode 100644
index 00000000000..07c2f26e162
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4880-quant-min.desc
@@ -0,0 +1,9 @@
+CORE
+z3-4880-quant-min.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#4880: quantified fp.min — counterexample a=-0 found via FP
+boundary values in relevant value set.
diff --git a/regression/smt2_solver/fp-issues/z3-4880-quant-min.smt2 b/regression/smt2_solver/fp-issues/z3-4880-quant-min.smt2
new file mode 100644
index 00000000000..475b2adc800
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4880-quant-min.smt2
@@ -0,0 +1,6 @@
+; Z3#4880: forall a. not(isNegative(fp.min(a, +0))) should be unsat
+; because fp.min(-0, +0) = -0 which IS negative
+(set-logic FP)
+(assert (forall ((a (_ FloatingPoint 8 24)))
+  (not (fp.isNegative (fp.min a (fp #b0 #b00000000 #b00000000000000000000000))))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-4889-add-subnormal.desc b/regression/smt2_solver/fp-issues/z3-4889-add-subnormal.desc
new file mode 100644
index 00000000000..c485454c915
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4889-add-subnormal.desc
@@ -0,0 +1,8 @@
+CORE
+z3-4889-add-subnormal.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#4889: adding subnormal to normal
diff --git a/regression/smt2_solver/fp-issues/z3-4889-add-subnormal.smt2 b/regression/smt2_solver/fp-issues/z3-4889-add-subnormal.smt2
new file mode 100644
index 00000000000..c60cdd7f0e3
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-4889-add-subnormal.smt2
@@ -0,0 +1,9 @@
+; Z3#4889: adding subnormal to large normal doesn't change it
+(set-logic QF_FP)
+(declare-fun c () (_ FloatingPoint 11 53))
+(declare-fun d () (_ FloatingPoint 11 53))
+(assert (fp.isSubnormal d))
+(assert (= c (fp.add RTZ c d)))
+(assert (not (fp.isZero d)))
+(assert (fp.isNormal c))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-5284-roundToIntegral-nonstandard2.desc b/regression/smt2_solver/fp-issues/z3-5284-roundToIntegral-nonstandard2.desc
new file mode 100644
index 00000000000..4b213d35523
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-5284-roundToIntegral-nonstandard2.desc
@@ -0,0 +1,8 @@
+CORE
+z3-5284-roundToIntegral-nonstandard2.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#5284: roundToIntegral on non-standard sort
diff --git a/regression/smt2_solver/fp-issues/z3-5284-roundToIntegral-nonstandard2.smt2 b/regression/smt2_solver/fp-issues/z3-5284-roundToIntegral-nonstandard2.smt2
new file mode 100644
index 00000000000..cb46059f803
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-5284-roundToIntegral-nonstandard2.smt2
@@ -0,0 +1,10 @@
+; Z3#5284: roundToIntegral on non-standard sort differs from input
+(set-logic QF_FP)
+(declare-fun X () (_ FloatingPoint 2 6))
+(declare-fun Y () (_ FloatingPoint 2 6))
+(assert (= X (fp.roundToIntegral RTZ Y)))
+(assert (not (fp.isNaN Y)))
+(assert (not (fp.isInfinite Y)))
+(assert (not (fp.isZero Y)))
+(assert (not (= X Y)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-5572-mul-roundToIntegral.desc b/regression/smt2_solver/fp-issues/z3-5572-mul-roundToIntegral.desc
new file mode 100644
index 00000000000..f45298e0f51
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-5572-mul-roundToIntegral.desc
@@ -0,0 +1,8 @@
+CORE
+z3-5572-mul-roundToIntegral.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#5572: multiplication and roundToIntegral
diff --git a/regression/smt2_solver/fp-issues/z3-5572-mul-roundToIntegral.smt2 b/regression/smt2_solver/fp-issues/z3-5572-mul-roundToIntegral.smt2
new file mode 100644
index 00000000000..48a4affcbd4
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-5572-mul-roundToIntegral.smt2
@@ -0,0 +1,10 @@
+; Z3#5572: multiplication and roundToIntegral
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 24))
+(assert (fp.gt x (fp #b0 #b00000000 #b00000000000000000000000)))
+(assert (fp.lt x (fp #b0 #b10000110 #b00000000000000000000000)))
+; x * pi truncated to integer equals 10.0
+(assert (fp.eq (fp.roundToIntegral RTZ (fp.mul RNE x
+  (fp #b0 #b10000000 #b10010010000111111011011)))
+  (fp #b0 #b10000010 #b01000000000000000000000)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-5769-to-fp-bv64.desc b/regression/smt2_solver/fp-issues/z3-5769-to-fp-bv64.desc
new file mode 100644
index 00000000000..94cd12a19d5
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-5769-to-fp-bv64.desc
@@ -0,0 +1,8 @@
+CORE
+z3-5769-to-fp-bv64.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#5769: to_fp from BV on Float64
diff --git a/regression/smt2_solver/fp-issues/z3-5769-to-fp-bv64.smt2 b/regression/smt2_solver/fp-issues/z3-5769-to-fp-bv64.smt2
new file mode 100644
index 00000000000..cff0c3bf35f
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-5769-to-fp-bv64.smt2
@@ -0,0 +1,6 @@
+; Z3#5769: to_fp from BV reinterpret cast on Float64
+(set-logic QF_FP)
+(declare-const bv (_ BitVec 64))
+(assert (fp.isNormal ((_ to_fp 11 53) bv)))
+(assert (fp.isPositive ((_ to_fp 11 53) bv)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-5911-nonstandard-ops.desc b/regression/smt2_solver/fp-issues/z3-5911-nonstandard-ops.desc
new file mode 100644
index 00000000000..e4695b9ecf0
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-5911-nonstandard-ops.desc
@@ -0,0 +1,8 @@
+CORE
+z3-5911-nonstandard-ops.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#5911: operations on non-standard sort
diff --git a/regression/smt2_solver/fp-issues/z3-5911-nonstandard-ops.smt2 b/regression/smt2_solver/fp-issues/z3-5911-nonstandard-ops.smt2
new file mode 100644
index 00000000000..ab23d994072
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-5911-nonstandard-ops.smt2
@@ -0,0 +1,9 @@
+; Z3#5911: operations on non-standard FP sort (_ FloatingPoint 2 6)
+(set-logic QF_FP)
+(declare-fun x () (_ FloatingPoint 2 6))
+(declare-fun y () (_ FloatingPoint 2 6))
+(assert (not (fp.isNaN x)))
+(assert (not (fp.isNaN y)))
+(assert (fp.gt (fp.add RNE x y) x))
+(assert (fp.gt y (fp #b0 #b00 #b00000)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6078-to-fp-half.desc b/regression/smt2_solver/fp-issues/z3-6078-to-fp-half.desc
new file mode 100644
index 00000000000..a12db33fc87
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6078-to-fp-half.desc
@@ -0,0 +1,8 @@
+CORE
+z3-6078-to-fp-half.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#6078: to_fp from constant Real 0.5
diff --git a/regression/smt2_solver/fp-issues/z3-6078-to-fp-half.smt2 b/regression/smt2_solver/fp-issues/z3-6078-to-fp-half.smt2
new file mode 100644
index 00000000000..ab3bdc801c8
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6078-to-fp-half.smt2
@@ -0,0 +1,6 @@
+; Z3#6078: to_fp from constant Real 0.5 should give 0.5
+(set-logic QF_FP)
+(assert (not (fp.eq
+  ((_ to_fp 11 53) RNE 0.5)
+  (fp #b0 #b01111111110 #b0000000000000000000000000000000000000000000000000000))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6117-fma.desc b/regression/smt2_solver/fp-issues/z3-6117-fma.desc
new file mode 100644
index 00000000000..7b28c11aac0
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6117-fma.desc
@@ -0,0 +1,8 @@
+CORE
+z3-6117-fma.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.fma now supported.
diff --git a/regression/smt2_solver/fp-issues/z3-6117-fma.desc.orig b/regression/smt2_solver/fp-issues/z3-6117-fma.desc.orig
new file mode 100644
index 00000000000..7831ce67a8f
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6117-fma.desc.orig
@@ -0,0 +1,16 @@
+<<<<<<< HEAD
+KNOWNBUG
+=======
+CORE
+>>>>>>> 0cd1170412 (Add __CPROVER_fma built-in and floatbv_fma_exprt expression)
+z3-6117-fma.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+<<<<<<< HEAD
+Z3#6117: fp.fma unsupported
+=======
+fp.fma now supported.
+>>>>>>> 0cd1170412 (Add __CPROVER_fma built-in and floatbv_fma_exprt expression)
diff --git a/regression/smt2_solver/fp-issues/z3-6117-fma.smt2 b/regression/smt2_solver/fp-issues/z3-6117-fma.smt2
new file mode 100644
index 00000000000..f756c8677c0
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6117-fma.smt2
@@ -0,0 +1,8 @@
+; Z3#6117: fp.fma RTP with specific Float64 values.
+(set-logic QF_FP)
+(declare-const a (_ FloatingPoint 11 53))
+(declare-const b (_ FloatingPoint 11 53))
+(assert (= a (fp #b1 #b11111111110 #b1111111111111111111111111111111111111111111111111111)))
+(assert (= b (fp #b0 #b11111110111 #b1111101100111000010100011011001111010101111001101010)))
+(assert (= (fp.fma RTP b a a) a))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6457-isnan-sub-inf.desc b/regression/smt2_solver/fp-issues/z3-6457-isnan-sub-inf.desc
new file mode 100644
index 00000000000..645ee08b128
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6457-isnan-sub-inf.desc
@@ -0,0 +1,8 @@
+CORE
+z3-6457-isnan-sub-inf.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#6457: isNaN of inf minus sum
diff --git a/regression/smt2_solver/fp-issues/z3-6457-isnan-sub-inf.smt2 b/regression/smt2_solver/fp-issues/z3-6457-isnan-sub-inf.smt2
new file mode 100644
index 00000000000..e7f927a1c1d
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6457-isnan-sub-inf.smt2
@@ -0,0 +1,6 @@
+; Z3#6457: isNaN of (inf - (a + b)) — only NaN if a+b is also inf
+(set-logic QF_FP)
+(declare-const a (_ FloatingPoint 8 24))
+(declare-const b (_ FloatingPoint 8 24))
+(assert (fp.isNaN (fp.sub RNE (_ +oo 8 24) (fp.add RNE a b))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6548-to-fp-const.desc b/regression/smt2_solver/fp-issues/z3-6548-to-fp-const.desc
new file mode 100644
index 00000000000..18d800440be
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6548-to-fp-const.desc
@@ -0,0 +1,8 @@
+CORE
+z3-6548-to-fp-const.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#6548: to_fp from constant real
diff --git a/regression/smt2_solver/fp-issues/z3-6548-to-fp-const.smt2 b/regression/smt2_solver/fp-issues/z3-6548-to-fp-const.smt2
new file mode 100644
index 00000000000..d02288b2403
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6548-to-fp-const.smt2
@@ -0,0 +1,4 @@
+; Z3#6548: to_fp from constant real
+(set-logic QF_FP)
+(assert (fp.eq ((_ to_fp 8 24) RNE 3.14) ((_ to_fp 8 24) RNE 3.14)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6553-rem.desc b/regression/smt2_solver/fp-issues/z3-6553-rem.desc
new file mode 100644
index 00000000000..16603ad4932
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6553-rem.desc
@@ -0,0 +1,9 @@
+FUTURE
+z3-6553-rem.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#6553: fp.rem with Float64 operands times out due to the large
+integer-width encoding in the FMA-based remainder algorithm.
diff --git a/regression/smt2_solver/fp-issues/z3-6553-rem.desc.orig b/regression/smt2_solver/fp-issues/z3-6553-rem.desc.orig
new file mode 100644
index 00000000000..f7661bcaef9
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6553-rem.desc.orig
@@ -0,0 +1,17 @@
+<<<<<<< HEAD
+FUTURE
+=======
+KNOWNBUG
+>>>>>>> fa7a81e906 (Add comprehensive SMT-LIB tests for external FP solver issues)
+z3-6553-rem.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+<<<<<<< HEAD
+Z3#6553: fp.rem with Float64 operands times out due to the large
+integer-width encoding in the FMA-based remainder algorithm.
+=======
+Z3#6553: fp.rem bug (always returns +0)
+>>>>>>> fa7a81e906 (Add comprehensive SMT-LIB tests for external FP solver issues)
diff --git a/regression/smt2_solver/fp-issues/z3-6553-rem.smt2 b/regression/smt2_solver/fp-issues/z3-6553-rem.smt2
new file mode 100644
index 00000000000..49642851f62
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6553-rem.smt2
@@ -0,0 +1,11 @@
+; Z3#6553: fp.rem can be zero for non-zero inputs
+(set-logic QF_FP)
+(declare-const a (_ FloatingPoint 11 53))
+(declare-const b (_ FloatingPoint 11 53))
+(assert (not (fp.isNaN a)))
+(assert (not (fp.isNaN b)))
+(assert (not (fp.isZero b)))
+(assert (not (fp.isInfinite b)))
+(assert (fp.isZero (fp.rem a b)))
+(assert (not (fp.isZero a)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6633-to-real.desc b/regression/smt2_solver/fp-issues/z3-6633-to-real.desc
new file mode 100644
index 00000000000..9df5e80e9c2
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6633-to-real.desc
@@ -0,0 +1,8 @@
+CORE
+z3-6633-to-real.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.to_real: find FP value matching real constant.
diff --git a/regression/smt2_solver/fp-issues/z3-6633-to-real.smt2 b/regression/smt2_solver/fp-issues/z3-6633-to-real.smt2
new file mode 100644
index 00000000000..ae502640f60
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6633-to-real.smt2
@@ -0,0 +1,5 @@
+; Z3#6633: fp.to_real unsupported
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 24))
+(assert (= (fp.to_real x) 2.0))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6674-fma-nonstandard.desc b/regression/smt2_solver/fp-issues/z3-6674-fma-nonstandard.desc
new file mode 100644
index 00000000000..c119f9ca7fe
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6674-fma-nonstandard.desc
@@ -0,0 +1,8 @@
+CORE
+z3-6674-fma-nonstandard.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.fma now supported.
diff --git a/regression/smt2_solver/fp-issues/z3-6674-fma-nonstandard.desc.orig b/regression/smt2_solver/fp-issues/z3-6674-fma-nonstandard.desc.orig
new file mode 100644
index 00000000000..78a5da3f942
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6674-fma-nonstandard.desc.orig
@@ -0,0 +1,16 @@
+<<<<<<< HEAD
+KNOWNBUG
+=======
+CORE
+>>>>>>> 0cd1170412 (Add __CPROVER_fma built-in and floatbv_fma_exprt expression)
+z3-6674-fma-nonstandard.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+<<<<<<< HEAD
+Z3#6674: fp.fma on non-standard sort (unsupported)
+=======
+fp.fma now supported.
+>>>>>>> 0cd1170412 (Add __CPROVER_fma built-in and floatbv_fma_exprt expression)
diff --git a/regression/smt2_solver/fp-issues/z3-6674-fma-nonstandard.smt2 b/regression/smt2_solver/fp-issues/z3-6674-fma-nonstandard.smt2
new file mode 100644
index 00000000000..c95b051576d
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6674-fma-nonstandard.smt2
@@ -0,0 +1,5 @@
+; Z3#6674: fp.fma on non-standard sort (_ FloatingPoint 3 2).
+(set-logic QF_FP)
+(declare-fun x () (_ FloatingPoint 3 2))
+(assert (= (fp #b0 #b000 #b0) (fp.fma RNE x x (fp #b0 #b000 #b0))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6728-nan-uf-simple.desc b/regression/smt2_solver/fp-issues/z3-6728-nan-uf-simple.desc
new file mode 100644
index 00000000000..24c0a7f10d7
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6728-nan-uf-simple.desc
@@ -0,0 +1,8 @@
+CORE
+z3-6728-nan-uf-simple.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#6728: NaN structural equality through UF
diff --git a/regression/smt2_solver/fp-issues/z3-6728-nan-uf-simple.smt2 b/regression/smt2_solver/fp-issues/z3-6728-nan-uf-simple.smt2
new file mode 100644
index 00000000000..76f3c72d7ea
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6728-nan-uf-simple.smt2
@@ -0,0 +1,6 @@
+; Z3#6728: NaN structural equality through UF
+(set-logic QF_FPUF)
+(declare-fun f ((_ FloatingPoint 8 24)) Bool)
+(assert (f (_ NaN 8 24)))
+(assert (not (f (_ NaN 8 24))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6970-to-fp-bv-eq.desc b/regression/smt2_solver/fp-issues/z3-6970-to-fp-bv-eq.desc
new file mode 100644
index 00000000000..363ee907ee2
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6970-to-fp-bv-eq.desc
@@ -0,0 +1,8 @@
+CORE
+z3-6970-to-fp-bv-eq.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#6970: to_fp from BV with bvxnor
diff --git a/regression/smt2_solver/fp-issues/z3-6970-to-fp-bv-eq.smt2 b/regression/smt2_solver/fp-issues/z3-6970-to-fp-bv-eq.smt2
new file mode 100644
index 00000000000..a1aa4e40f78
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6970-to-fp-bv-eq.smt2
@@ -0,0 +1,6 @@
+; Z3#6970: to_fp from BV with fp.leq and bvxnor
+(set-logic QF_FP)
+(declare-fun bv () (_ BitVec 32))
+(assert (fp.leq ((_ to_fp 8 24) bv) (fp #b0 #b00000000 #b00000000000000000000000)))
+(assert (not (fp.geq ((_ to_fp 8 24) (bvxnor (_ bv0 32) bv)) (fp #b0 #b00000000 #b00000000000000000000000))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6972-quant-to-fp-isnan.desc b/regression/smt2_solver/fp-issues/z3-6972-quant-to-fp-isnan.desc
new file mode 100644
index 00000000000..26f15158311
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6972-quant-to-fp-isnan.desc
@@ -0,0 +1,9 @@
+CORE
+z3-6972-quant-to-fp-isnan.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#6972: quantified to_fp/isNaN — counterexample found via BV
+boundary values (NaN pattern) in relevant value set.
diff --git a/regression/smt2_solver/fp-issues/z3-6972-quant-to-fp-isnan.smt2 b/regression/smt2_solver/fp-issues/z3-6972-quant-to-fp-isnan.smt2
new file mode 100644
index 00000000000..127c0c5d78b
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6972-quant-to-fp-isnan.smt2
@@ -0,0 +1,7 @@
+; Z3#6972: quantified formula with to_fp from BV and fp.isNaN
+(set-logic FP)
+(declare-fun bv () (_ BitVec 32))
+(assert (forall ((x (_ BitVec 32)))
+  (= (fp.isNaN ((_ to_fp 8 24) x))
+     (fp.isNaN ((_ to_fp 8 24) bv)))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6972-to-fp-bv-isnan.desc b/regression/smt2_solver/fp-issues/z3-6972-to-fp-bv-isnan.desc
new file mode 100644
index 00000000000..8b3229c5798
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6972-to-fp-bv-isnan.desc
@@ -0,0 +1,8 @@
+CORE
+z3-6972-to-fp-bv-isnan.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#6972: to_fp from BV 0x7FC00000 is NaN
diff --git a/regression/smt2_solver/fp-issues/z3-6972-to-fp-bv-isnan.smt2 b/regression/smt2_solver/fp-issues/z3-6972-to-fp-bv-isnan.smt2
new file mode 100644
index 00000000000..3778e0cd460
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6972-to-fp-bv-isnan.smt2
@@ -0,0 +1,6 @@
+; Z3#6972: to_fp from BV and fp.isNaN
+(set-logic QF_FP)
+(declare-fun bv () (_ BitVec 32))
+; to_fp(0x7FC00000) should be NaN (quiet NaN)
+(assert (not (fp.isNaN ((_ to_fp 8 24) (_ bv2143289344 32)))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-6974-to-fp-roundtrip.desc b/regression/smt2_solver/fp-issues/z3-6974-to-fp-roundtrip.desc
new file mode 100644
index 00000000000..ab93d7068fd
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6974-to-fp-roundtrip.desc
@@ -0,0 +1,8 @@
+CORE
+z3-6974-to-fp-roundtrip.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#6974: to_fp/to_sbv roundtrip identity
diff --git a/regression/smt2_solver/fp-issues/z3-6974-to-fp-roundtrip.smt2 b/regression/smt2_solver/fp-issues/z3-6974-to-fp-roundtrip.smt2
new file mode 100644
index 00000000000..4950a28c957
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-6974-to-fp-roundtrip.smt2
@@ -0,0 +1,9 @@
+; Z3#6974: to_fp from signed BV and back should be identity for small values.
+; Converting a signed 8-bit integer to Float32 with RTZ and back should
+; preserve the value (all 8-bit integers are exactly representable in Float32).
+(set-logic QF_FP)
+(declare-fun s1 () (_ BitVec 8))
+(define-fun s2 () (_ FloatingPoint 8 24) ((_ to_fp 8 24) RTZ s1))
+(define-fun s3 () (_ BitVec 8) ((_ fp.to_sbv 8) RTZ s2))
+(assert (not (= s1 s3)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-7056-roundToIntegral-to-ubv.desc b/regression/smt2_solver/fp-issues/z3-7056-roundToIntegral-to-ubv.desc
new file mode 100644
index 00000000000..138679bf3ed
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7056-roundToIntegral-to-ubv.desc
@@ -0,0 +1,8 @@
+CORE
+z3-7056-roundToIntegral-to-ubv.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#7056: roundToIntegral RTZ + to_ubv + to_fp_unsigned roundtrip
diff --git a/regression/smt2_solver/fp-issues/z3-7056-roundToIntegral-to-ubv.smt2 b/regression/smt2_solver/fp-issues/z3-7056-roundToIntegral-to-ubv.smt2
new file mode 100644
index 00000000000..17fc149e90a
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7056-roundToIntegral-to-ubv.smt2
@@ -0,0 +1,14 @@
+; Z3#7056: roundToIntegral RTZ with to_fp_unsigned and fp.to_ubv
+(set-logic QF_FP)
+(declare-fun x () (_ BitVec 16))
+(define-fun fval () (_ FloatingPoint 8 8) ((_ to_fp 8 8) x))
+(define-fun rounded () (_ FloatingPoint 8 8) (fp.roundToIntegral RTZ fval))
+(define-fun as_ubv () (_ BitVec 128) ((_ fp.to_ubv 128) RTZ rounded))
+(define-fun back () (_ FloatingPoint 8 8) ((_ to_fp_unsigned 8 8) RTZ as_ubv))
+; For positive non-zero finite values, roundtrip should preserve
+(assert (fp.isPositive rounded))
+(assert (not (fp.isZero rounded)))
+(assert (not (fp.isNaN rounded)))
+(assert (not (fp.isInfinite rounded)))
+(assert (not (fp.eq back rounded)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-7135-bvfp-to-fp.desc b/regression/smt2_solver/fp-issues/z3-7135-bvfp-to-fp.desc
new file mode 100644
index 00000000000..072c84e595e
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7135-bvfp-to-fp.desc
@@ -0,0 +1,8 @@
+CORE
+z3-7135-bvfp-to-fp.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#7135: to_fp from BV with fp.gt on Float64
diff --git a/regression/smt2_solver/fp-issues/z3-7135-bvfp-to-fp.smt2 b/regression/smt2_solver/fp-issues/z3-7135-bvfp-to-fp.smt2
new file mode 100644
index 00000000000..e45232d8595
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7135-bvfp-to-fp.smt2
@@ -0,0 +1,10 @@
+; Z3#7135: to_fp from BV with fp.gt on Float64
+(set-logic QF_FP)
+(declare-fun bv4 () (_ BitVec 64))
+(declare-fun bv0 () (_ BitVec 64))
+(assert (not (fp.gt ((_ to_fp 11 53) bv4) ((_ to_fp 11 53) bv0))))
+(assert (fp.isNormal ((_ to_fp 11 53) bv4)))
+(assert (fp.isNormal ((_ to_fp 11 53) bv0)))
+(assert (fp.gt ((_ to_fp 11 53) bv4) (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000)))
+(assert (fp.gt ((_ to_fp 11 53) bv0) (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-7162-fma.desc b/regression/smt2_solver/fp-issues/z3-7162-fma.desc
new file mode 100644
index 00000000000..ac7032ad628
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7162-fma.desc
@@ -0,0 +1,8 @@
+CORE
+z3-7162-fma.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.fma now supported.
diff --git a/regression/smt2_solver/fp-issues/z3-7162-fma.desc.orig b/regression/smt2_solver/fp-issues/z3-7162-fma.desc.orig
new file mode 100644
index 00000000000..1fb1a1d81de
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7162-fma.desc.orig
@@ -0,0 +1,16 @@
+<<<<<<< HEAD
+KNOWNBUG
+=======
+CORE
+>>>>>>> 0cd1170412 (Add __CPROVER_fma built-in and floatbv_fma_exprt expression)
+z3-7162-fma.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+<<<<<<< HEAD
+Z3#7162: fp.fma unsupported
+=======
+fp.fma now supported.
+>>>>>>> 0cd1170412 (Add __CPROVER_fma built-in and floatbv_fma_exprt expression)
diff --git a/regression/smt2_solver/fp-issues/z3-7162-fma.smt2 b/regression/smt2_solver/fp-issues/z3-7162-fma.smt2
new file mode 100644
index 00000000000..697872ac2dd
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7162-fma.smt2
@@ -0,0 +1,9 @@
+; Z3#7162: fp.sub RNA with fp.fma RTN on Float64.
+(set-logic QF_FP)
+(declare-const a0 (_ FloatingPoint 11 53))
+(declare-const a1 (_ FloatingPoint 11 53))
+(declare-const a3 (_ FloatingPoint 11 53))
+(declare-const a4 (_ FloatingPoint 11 53))
+(assert (= (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000)
+  (fp.sub RNA a4 (fp.fma RTN a3 a1 a0))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-7321-to-real.desc b/regression/smt2_solver/fp-issues/z3-7321-to-real.desc
new file mode 100644
index 00000000000..0a6a043b7bb
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7321-to-real.desc
@@ -0,0 +1,8 @@
+CORE
+z3-7321-to-real.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.to_real: find FP value matching real constant.
diff --git a/regression/smt2_solver/fp-issues/z3-7321-to-real.smt2 b/regression/smt2_solver/fp-issues/z3-7321-to-real.smt2
new file mode 100644
index 00000000000..62262515ef8
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7321-to-real.smt2
@@ -0,0 +1,5 @@
+; Z3#7321: fp.to_real unsupported
+(set-logic QF_FP)
+(declare-fun s0 () (_ FloatingPoint 4 4))
+(assert (= (fp.to_real s0) 1.0))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-7431-to-fp-real-nonconst.desc b/regression/smt2_solver/fp-issues/z3-7431-to-fp-real-nonconst.desc
new file mode 100644
index 00000000000..186732ad40a
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7431-to-fp-real-nonconst.desc
@@ -0,0 +1,8 @@
+KNOWNBUG
+z3-7431-to-fp-real-nonconst.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#7431: to_fp from non-constant Real (unsupported)
diff --git a/regression/smt2_solver/fp-issues/z3-7431-to-fp-real-nonconst.smt2 b/regression/smt2_solver/fp-issues/z3-7431-to-fp-real-nonconst.smt2
new file mode 100644
index 00000000000..9052596fa48
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7431-to-fp-real-nonconst.smt2
@@ -0,0 +1,5 @@
+; Z3#7431: to_fp from non-constant Real on non-standard sort (unsupported)
+(set-logic QF_FP)
+(declare-fun v () Real)
+(assert (= ((_ to_fp 2 6) RTZ v) (fp #b1 #b00 #b00000)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-7842-nan-bits.desc b/regression/smt2_solver/fp-issues/z3-7842-nan-bits.desc
new file mode 100644
index 00000000000..dd0eed639ac
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7842-nan-bits.desc
@@ -0,0 +1,8 @@
+CORE
+z3-7842-nan-bits.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#7842: multiple NaN bit patterns exist
diff --git a/regression/smt2_solver/fp-issues/z3-7842-nan-bits.smt2 b/regression/smt2_solver/fp-issues/z3-7842-nan-bits.smt2
new file mode 100644
index 00000000000..9278f95035a
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-7842-nan-bits.smt2
@@ -0,0 +1,6 @@
+; Z3#7842: multiple NaN bit patterns exist
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 24))
+(assert (fp.isNaN x))
+(assert (not (= x (_ NaN 8 24))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-8097-uf-fp.desc b/regression/smt2_solver/fp-issues/z3-8097-uf-fp.desc
new file mode 100644
index 00000000000..17fe2606fca
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8097-uf-fp.desc
@@ -0,0 +1,8 @@
+CORE
+z3-8097-uf-fp.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#8097: UF with FP arguments
diff --git a/regression/smt2_solver/fp-issues/z3-8097-uf-fp.smt2 b/regression/smt2_solver/fp-issues/z3-8097-uf-fp.smt2
new file mode 100644
index 00000000000..af4d9e6dcbf
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8097-uf-fp.smt2
@@ -0,0 +1,7 @@
+; Z3#8097: UF with FP arguments
+(set-logic QF_FPUF)
+(declare-fun f ((_ FloatingPoint 8 24) (_ FloatingPoint 8 24)) (_ FloatingPoint 8 24))
+(declare-const x (_ FloatingPoint 8 24))
+(define-fun pz () (_ FloatingPoint 8 24) (fp #b0 #b00000000 #b00000000000000000000000))
+(assert (fp.eq (f x pz) pz))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-8169-nonstandard-add.desc b/regression/smt2_solver/fp-issues/z3-8169-nonstandard-add.desc
new file mode 100644
index 00000000000..0f031d0bda1
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8169-nonstandard-add.desc
@@ -0,0 +1,8 @@
+CORE
+z3-8169-nonstandard-add.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#8169: adding +0 to x gives x
diff --git a/regression/smt2_solver/fp-issues/z3-8169-nonstandard-add.smt2 b/regression/smt2_solver/fp-issues/z3-8169-nonstandard-add.smt2
new file mode 100644
index 00000000000..e2726c509d7
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8169-nonstandard-add.smt2
@@ -0,0 +1,6 @@
+; Z3#8169: fp.add on non-standard sort (_ FloatingPoint 2 24)
+; adding +0 to x gives x, so x > x is always false
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 2 24))
+(assert (fp.gt (fp.add RNE x (fp #b0 #b00 #b00000000000000000000000)) x))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-8183-to-fp-overflow.desc b/regression/smt2_solver/fp-issues/z3-8183-to-fp-overflow.desc
new file mode 100644
index 00000000000..c8d9b91788e
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8183-to-fp-overflow.desc
@@ -0,0 +1,8 @@
+CORE
+z3-8183-to-fp-overflow.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#8183: to_fp from large constant Real overflows to infinity.
diff --git a/regression/smt2_solver/fp-issues/z3-8183-to-fp-overflow.smt2 b/regression/smt2_solver/fp-issues/z3-8183-to-fp-overflow.smt2
new file mode 100644
index 00000000000..076a182f2a9
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8183-to-fp-overflow.smt2
@@ -0,0 +1,4 @@
+; Z3#8183: to_fp from large constant Real should produce infinity
+(set-logic QF_FP)
+(assert (not (fp.isInfinite ((_ to_fp 8 24) RNE 10000000000000000000000000000000000000000.0))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-8185-to-real.desc b/regression/smt2_solver/fp-issues/z3-8185-to-real.desc
new file mode 100644
index 00000000000..1ae8aa13800
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8185-to-real.desc
@@ -0,0 +1,8 @@
+CORE
+z3-8185-to-real.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.to_real: find FP value matching real constant.
diff --git a/regression/smt2_solver/fp-issues/z3-8185-to-real.smt2 b/regression/smt2_solver/fp-issues/z3-8185-to-real.smt2
new file mode 100644
index 00000000000..6a13b03bf79
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8185-to-real.smt2
@@ -0,0 +1,5 @@
+; Z3#8185: fp.to_real unsupported
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 24))
+(assert (= (fp.to_real x) 0.5))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-8282-perf.desc b/regression/smt2_solver/fp-issues/z3-8282-perf.desc
new file mode 100644
index 00000000000..02b82e1158d
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8282-perf.desc
@@ -0,0 +1,8 @@
+CORE
+z3-8282-perf.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Z3#8282: basic FP formula
diff --git a/regression/smt2_solver/fp-issues/z3-8282-perf.smt2 b/regression/smt2_solver/fp-issues/z3-8282-perf.smt2
new file mode 100644
index 00000000000..07cf198e95d
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8282-perf.smt2
@@ -0,0 +1,10 @@
+; Z3#8282: basic FP formula (performance baseline)
+(set-logic QF_FP)
+(declare-const a (_ FloatingPoint 8 24))
+(declare-const b (_ FloatingPoint 8 24))
+(assert (not (fp.isNaN a)))
+(assert (not (fp.isNaN b)))
+(assert (not (fp.isInfinite a)))
+(assert (not (fp.isInfinite b)))
+(assert (fp.gt (fp.add RNE a b) (fp.mul RNE a b)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-8345-to-real.desc b/regression/smt2_solver/fp-issues/z3-8345-to-real.desc
new file mode 100644
index 00000000000..afc53ebdb3a
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8345-to-real.desc
@@ -0,0 +1,8 @@
+CORE
+z3-8345-to-real.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.to_real: find FP value matching real constant.
diff --git a/regression/smt2_solver/fp-issues/z3-8345-to-real.smt2 b/regression/smt2_solver/fp-issues/z3-8345-to-real.smt2
new file mode 100644
index 00000000000..757f8bb5b23
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-8345-to-real.smt2
@@ -0,0 +1,5 @@
+; Z3#8345: fp.to_real unsupported
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 11 53))
+(assert (= (fp.to_real x) 1.0))
+(check-sat)
diff --git a/regression/smt2_solver/fp-issues/z3-isZero-neg-zero.desc b/regression/smt2_solver/fp-issues/z3-isZero-neg-zero.desc
new file mode 100644
index 00000000000..62aa9746309
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-isZero-neg-zero.desc
@@ -0,0 +1,9 @@
+CORE
+z3-isZero-neg-zero.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+fp.isZero(-0) is true. Fixed by using ieee_float_equal with +0
+instead of checking bitvector non-zero.
diff --git a/regression/smt2_solver/fp-issues/z3-isZero-neg-zero.smt2 b/regression/smt2_solver/fp-issues/z3-isZero-neg-zero.smt2
new file mode 100644
index 00000000000..fe1c916bc62
--- /dev/null
+++ b/regression/smt2_solver/fp-issues/z3-isZero-neg-zero.smt2
@@ -0,0 +1,4 @@
+; fp.isZero(-0) should be true (currently returns false - bug)
+(set-logic QF_FP)
+(assert (not (fp.isZero (fp #b1 #b00000000 #b00000000000000000000000))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-nan-eq-uf/nan-eq-uf1.desc b/regression/smt2_solver/fp-nan-eq-uf/nan-eq-uf1.desc
new file mode 100644
index 00000000000..c856cf71b3a
--- /dev/null
+++ b/regression/smt2_solver/fp-nan-eq-uf/nan-eq-uf1.desc
@@ -0,0 +1,8 @@
+CORE
+nan-eq-uf1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Based on Z3#6728: NaN equality must be preserved through uninterpreted functions.
diff --git a/regression/smt2_solver/fp-nan-eq-uf/nan-eq-uf1.smt2 b/regression/smt2_solver/fp-nan-eq-uf/nan-eq-uf1.smt2
new file mode 100644
index 00000000000..6786c7239e7
--- /dev/null
+++ b/regression/smt2_solver/fp-nan-eq-uf/nan-eq-uf1.smt2
@@ -0,0 +1,16 @@
+; Based on Z3#6728: NaN equality with uninterpreted functions
+; In SMT-LIB, (= NaN NaN) is true (structural equality).
+; If (= t1 t2) is true, then (= (f t1) (f t2)) must also be true
+; for any uninterpreted function f (congruence).
+; This test checks that the solver handles NaN correctly through UFs.
+
+(set-logic QF_FPUF)
+(declare-const x (_ FloatingPoint 8 24))
+(declare-fun f ((_ FloatingPoint 8 24)) (_ FloatingPoint 8 24))
+
+; fp.add of anything with NaN is NaN
+; Both sides produce NaN, so they are equal (structural =)
+; Therefore f applied to both must also be equal
+(assert (not (= (f (fp.add RNE x (_ NaN 8 24)))
+              (f (fp.add RNE (_ NaN 8 24) x)))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-predicates/fp-predicates1.desc b/regression/smt2_solver/fp-predicates/fp-predicates1.desc
new file mode 100644
index 00000000000..527b5195c7e
--- /dev/null
+++ b/regression/smt2_solver/fp-predicates/fp-predicates1.desc
@@ -0,0 +1,8 @@
+CORE
+fp-predicates1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Test fp.isSubnormal, fp.isNegative, fp.isPositive predicates.
diff --git a/regression/smt2_solver/fp-predicates/fp-predicates1.smt2 b/regression/smt2_solver/fp-predicates/fp-predicates1.smt2
new file mode 100644
index 00000000000..896ecb1b882
--- /dev/null
+++ b/regression/smt2_solver/fp-predicates/fp-predicates1.smt2
@@ -0,0 +1,22 @@
+; Test fp.isSubnormal, fp.isNegative, fp.isPositive predicates.
+
+(set-logic QF_FP)
+
+; A subnormal Float32 exists
+(declare-const s (_ FloatingPoint 8 24))
+(assert (fp.isSubnormal s))
+
+; A negative normal value exists
+(declare-const n (_ FloatingPoint 8 24))
+(assert (fp.isNegative n))
+(assert (fp.isNormal n))
+
+; A positive value exists
+(declare-const p (_ FloatingPoint 8 24))
+(assert (fp.isPositive p))
+
+; NaN is neither negative nor positive
+(assert (not (fp.isNegative (_ NaN 8 24))))
+(assert (not (fp.isPositive (_ NaN 8 24))))
+
+(check-sat)
diff --git a/regression/smt2_solver/fp-rem-nonstandard/fp-rem-nonstandard1.desc b/regression/smt2_solver/fp-rem-nonstandard/fp-rem-nonstandard1.desc
new file mode 100644
index 00000000000..1dcd7dc6ff2
--- /dev/null
+++ b/regression/smt2_solver/fp-rem-nonstandard/fp-rem-nonstandard1.desc
@@ -0,0 +1,7 @@
+CORE
+fp-rem-nonstandard1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+--
+Based on Z3#8414: fp.rem on non-standard FP sort should not crash.
diff --git a/regression/smt2_solver/fp-rem-nonstandard/fp-rem-nonstandard1.smt2 b/regression/smt2_solver/fp-rem-nonstandard/fp-rem-nonstandard1.smt2
new file mode 100644
index 00000000000..498c2946a5b
--- /dev/null
+++ b/regression/smt2_solver/fp-rem-nonstandard/fp-rem-nonstandard1.smt2
@@ -0,0 +1,9 @@
+; Based on Z3#8414: fp.rem on non-standard FP sort (_ FloatingPoint 1 37).
+; Z3 crashes with assertion violation in mpf.cpp.
+; Test that CBMC handles this without crashing.
+
+(set-logic QF_FP)
+(assert (fp.isZero (fp.rem
+  (fp (_ bv0 1) #b111100110000111111100101110000000011 (_ bv0 1))
+  (fp (_ bv0 1) (_ bv1 36) (_ bv0 1)))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-rem-nonstandard/fp-rem1.desc b/regression/smt2_solver/fp-rem-nonstandard/fp-rem1.desc
new file mode 100644
index 00000000000..5db21799910
--- /dev/null
+++ b/regression/smt2_solver/fp-rem-nonstandard/fp-rem1.desc
@@ -0,0 +1,8 @@
+CORE
+fp-rem1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+Z3#2381: fp.rem(3.0, 2.0) == -1.0 (IEEE 754 remainder tie-breaking).
diff --git a/regression/smt2_solver/fp-rem-nonstandard/fp-rem1.smt2 b/regression/smt2_solver/fp-rem-nonstandard/fp-rem1.smt2
new file mode 100644
index 00000000000..b3043b5b2c7
--- /dev/null
+++ b/regression/smt2_solver/fp-rem-nonstandard/fp-rem1.smt2
@@ -0,0 +1,21 @@
+; Based on Z3#2381: fp.rem producing incorrect result.
+; fp.rem(3.0, 2.0) should be -1.0 per IEEE 754 remainder:
+;   round(3.0/2.0) = round(1.5) = 2 (ties to even), so rem = 3 - 2*2 = -1
+; This formula asserts rem(3.0, 2.0) != -1.0, which should be UNSAT.
+
+(set-logic QF_FP)
+
+; 3.0 as Float32: sign=0, exp=10000000, mant=10000000000000000000000
+(define-fun three () (_ FloatingPoint 8 24)
+  (fp #b0 #b10000000 #b10000000000000000000000))
+
+; 2.0 as Float32: sign=0, exp=10000000, mant=00000000000000000000000
+(define-fun two () (_ FloatingPoint 8 24)
+  (fp #b0 #b10000000 #b00000000000000000000000))
+
+; -1.0 as Float32: sign=1, exp=01111111, mant=00000000000000000000000
+(define-fun neg_one () (_ FloatingPoint 8 24)
+  (fp #b1 #b01111111 #b00000000000000000000000))
+
+(assert (not (= (fp.rem three two) neg_one)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-combined1.desc b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-combined1.desc
new file mode 100644
index 00000000000..466f84bbae8
--- /dev/null
+++ b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-combined1.desc
@@ -0,0 +1,9 @@
+CORE
+roundToIntegral-combined1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Based on Z3#4841: Combined constraints on non-standard FP sort.
+Satisfiable with NaN values (NaN + Z = NaN, NaN / Z = NaN, etc.).
diff --git a/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-combined1.smt2 b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-combined1.smt2
new file mode 100644
index 00000000000..9a25692823b
--- /dev/null
+++ b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-combined1.smt2
@@ -0,0 +1,15 @@
+; Based on Z3#4841: Combined fp.add, fp.div, fp.roundToIntegral on
+; non-standard sort (_ FloatingPoint 2 6).
+; X = Y+Z = Y/Z = roundToIntegral(RTZ, Y), Y != Z.
+; Z3 produced an invalid model for this. CBMC also produces an invalid
+; model due to the roundToIntegral bug on non-standard sorts.
+
+(set-logic QF_FP)
+(declare-fun X () (_ FloatingPoint 2 6))
+(declare-fun Y () (_ FloatingPoint 2 6))
+(declare-fun Z () (_ FloatingPoint 2 6))
+(assert (and (= X (fp.add RTZ Y Z))
+             (= X (fp.div RTZ Y Z))
+             (= X (fp.roundToIntegral RTZ Y))
+             (not (= Y Z))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-float32-1.desc b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-float32-1.desc
new file mode 100644
index 00000000000..a2bcc8923b4
--- /dev/null
+++ b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-float32-1.desc
@@ -0,0 +1,8 @@
+CORE
+roundToIntegral-float32-1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+roundToIntegral RTZ 3.5f == 3.0f on standard Float32.
diff --git a/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-float32-1.smt2 b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-float32-1.smt2
new file mode 100644
index 00000000000..2ee55025eb6
--- /dev/null
+++ b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-float32-1.smt2
@@ -0,0 +1,9 @@
+; roundToIntegral RTZ 3.5f should be 3.0f (Float32).
+; 3.5 = fp #b0 #b10000000 #b11000000000000000000000
+; 3.0 = fp #b0 #b10000000 #b10000000000000000000000
+
+(set-logic QF_FP)
+(assert (not (= (fp.roundToIntegral RTZ
+  (fp #b0 #b10000000 #b11000000000000000000000))
+  (fp #b0 #b10000000 #b10000000000000000000000))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-nonstandard1.desc b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-nonstandard1.desc
new file mode 100644
index 00000000000..4e442b0db78
--- /dev/null
+++ b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-nonstandard1.desc
@@ -0,0 +1,10 @@
+CORE
+roundToIntegral-nonstandard1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+roundToIntegral RTZ on non-standard FP sort (_ FloatingPoint 2 6).
+Previously returned input unchanged; fixed by converting to wider
+format where the magic-number trick works.
diff --git a/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-nonstandard1.smt2 b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-nonstandard1.smt2
new file mode 100644
index 00000000000..7a89b065109
--- /dev/null
+++ b/regression/smt2_solver/fp-roundToIntegral/roundToIntegral-nonstandard1.smt2
@@ -0,0 +1,10 @@
+; Based on Z3#4841: roundToIntegral on non-standard FP sort.
+; roundToIntegral RTZ 3.96875 should be 3.0 in (_ FloatingPoint 2 6).
+; 3.96875 = fp #b0 #b10 #b11111
+; 3.0     = fp #b0 #b10 #b10000
+; This formula asserts the result is NOT 3.0, so it should be UNSAT.
+
+(set-logic QF_FP)
+(assert (not (= (fp.roundToIntegral RTZ (fp #b0 #b10 #b11111))
+               (fp #b0 #b10 #b10000))))
+(check-sat)
diff --git a/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-all-rm1.desc b/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-all-rm1.desc
new file mode 100644
index 00000000000..31189337a83
--- /dev/null
+++ b/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-all-rm1.desc
@@ -0,0 +1,9 @@
+CORE
+fp-sub-all-rm1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Based on Z3#7162: fp.sub with all rounding modes on Float64.
+IEEE 754: x - x == +0 for RNE/RNA/RTP/RTZ, -0 for RTN.
diff --git a/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-all-rm1.smt2 b/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-all-rm1.smt2
new file mode 100644
index 00000000000..4991a5e90ab
--- /dev/null
+++ b/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-all-rm1.smt2
@@ -0,0 +1,38 @@
+; Based on Z3#7162: Test all rounding modes with fp.sub on Float64.
+; IEEE 754: x - x == +0 for all rounding modes except RTN, where it is -0.
+
+(set-logic QF_FP)
+(declare-const a1 (_ FloatingPoint 11 53))
+(declare-const a2 (_ FloatingPoint 11 53))
+(declare-const a3 (_ FloatingPoint 11 53))
+(declare-const a4 (_ FloatingPoint 11 53))
+(declare-const a5 (_ FloatingPoint 11 53))
+
+(define-fun pzero () (_ FloatingPoint 11 53)
+  (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000))
+(define-fun nzero () (_ FloatingPoint 11 53)
+  (fp #b1 #b00000000000 #b0000000000000000000000000000000000000000000000000000))
+
+; x - x == +0 for RNE, RNA, RTP, RTZ (when x is finite)
+(assert (not (fp.isNaN a1)))
+(assert (not (fp.isInfinite a1)))
+(assert (= (fp.sub RNE a1 a1) pzero))
+
+(assert (not (fp.isNaN a2)))
+(assert (not (fp.isInfinite a2)))
+(assert (= (fp.sub RNA a2 a2) pzero))
+
+(assert (not (fp.isNaN a3)))
+(assert (not (fp.isInfinite a3)))
+(assert (= (fp.sub RTP a3 a3) pzero))
+
+; x - x == -0 for RTN (round toward negative)
+(assert (not (fp.isNaN a4)))
+(assert (not (fp.isInfinite a4)))
+(assert (= (fp.sub RTN a4 a4) nzero))
+
+(assert (not (fp.isNaN a5)))
+(assert (not (fp.isInfinite a5)))
+(assert (= (fp.sub RTZ a5 a5) pzero))
+
+(check-sat)
diff --git a/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-rna1.desc b/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-rna1.desc
new file mode 100644
index 00000000000..57a5a067a09
--- /dev/null
+++ b/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-rna1.desc
@@ -0,0 +1,8 @@
+CORE
+fp-sub-rna1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Based on Z3#7162: fp.sub with RNA rounding on Float64.
diff --git a/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-rna1.smt2 b/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-rna1.smt2
new file mode 100644
index 00000000000..8bdcf788e68
--- /dev/null
+++ b/regression/smt2_solver/fp-sub-fma-rounding/fp-sub-rna1.smt2
@@ -0,0 +1,14 @@
+; Based on Z3#7162: fp.sub with RNA rounding on Float64
+; The original issue involves fp.fma (not supported by CBMC's SMT2 solver),
+; so this is a simplified version testing fp.sub with RNA rounding.
+; The assertion says: a4 - (a3 * a1 + a0) == +0.0
+; Simplified to just test fp.sub RNA produces valid results.
+
+(set-logic QF_FP)
+(declare-const a (_ FloatingPoint 11 53))
+(declare-const b (_ FloatingPoint 11 53))
+
+; fp.sub RNA a b == +0.0 should be satisfiable (e.g., a == b)
+(assert (= (fp.sub RNA a b)
+  (fp #b0 #b00000000000 #b0000000000000000000000000000000000000000000000000000)))
+(check-sat)
diff --git a/regression/smt2_solver/fp-to-bv/fp-to-bv1.desc b/regression/smt2_solver/fp-to-bv/fp-to-bv1.desc
new file mode 100644
index 00000000000..65e854d1fc5
--- /dev/null
+++ b/regression/smt2_solver/fp-to-bv/fp-to-bv1.desc
@@ -0,0 +1,9 @@
+CORE
+fp-to-bv1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.to_sbv and fp.to_ubv with various rounding modes.
+Previously crashed with non-RTZ rounding modes.
diff --git a/regression/smt2_solver/fp-to-bv/fp-to-bv1.smt2 b/regression/smt2_solver/fp-to-bv/fp-to-bv1.smt2
new file mode 100644
index 00000000000..4f2cb518bce
--- /dev/null
+++ b/regression/smt2_solver/fp-to-bv/fp-to-bv1.smt2
@@ -0,0 +1,14 @@
+; Test fp.to_sbv and fp.to_ubv with various rounding modes.
+; Previously crashed with non-RTZ rounding modes.
+
+(set-logic QF_FP)
+
+; fp.to_sbv RNE 41.5 == 42 (ties to even)
+(assert (= ((_ fp.to_sbv 32) RNE
+  (fp #b0 #b10000100 #b01001100000000000000000)) (_ bv42 32)))
+
+; fp.to_ubv RTZ 3.125 == 3 (truncation)
+(assert (= ((_ fp.to_ubv 32) RTZ
+  (fp #b0 #b10000000 #b10010000000000000000000)) (_ bv3 32)))
+
+(check-sat)
diff --git a/regression/smt2_solver/fp/fp-fma1.desc b/regression/smt2_solver/fp/fp-fma1.desc
new file mode 100644
index 00000000000..0162e2dcfb4
--- /dev/null
+++ b/regression/smt2_solver/fp/fp-fma1.desc
@@ -0,0 +1,8 @@
+CORE
+fp-fma.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.fma now supported.
diff --git a/regression/smt2_solver/fp/fp-fma1.smt2 b/regression/smt2_solver/fp/fp-fma1.smt2
new file mode 100644
index 00000000000..a1fd4558846
--- /dev/null
+++ b/regression/smt2_solver/fp/fp-fma1.smt2
@@ -0,0 +1,10 @@
+; fp.fma is now supported. Tests basic fp.fma satisfiability.
+; Based on Z3#7162 and CVC5#11139.
+
+(set-logic QF_FP)
+(declare-const a (_ FloatingPoint 11 53))
+(declare-const b (_ FloatingPoint 11 53))
+(declare-const c (_ FloatingPoint 11 53))
+(assert (= (fp.fma RNE a b c)
+  (fp #b0 #b01111111111 #b0000000000000000000000000000000000000000000000000000)))
+(check-sat)
diff --git a/regression/smt2_solver/fp/fp-overflow1.desc b/regression/smt2_solver/fp/fp-overflow1.desc
new file mode 100644
index 00000000000..ec49b825c97
--- /dev/null
+++ b/regression/smt2_solver/fp/fp-overflow1.desc
@@ -0,0 +1,9 @@
+CORE
+fp-overflow1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+Based on Z3#4673: Overflow should produce infinity, not saturate.
+x > 0 and (x * 2) * 0.5 > x is satisfiable (x = FLT_MAX).
diff --git a/regression/smt2_solver/fp/fp-overflow1.smt2 b/regression/smt2_solver/fp/fp-overflow1.smt2
new file mode 100644
index 00000000000..9128999eafd
--- /dev/null
+++ b/regression/smt2_solver/fp/fp-overflow1.smt2
@@ -0,0 +1,12 @@
+; Based on Z3#4673: Overflow should produce infinity.
+; x > 0, (x * 2) * 0.5 > x should be satisfiable.
+; When x = FLT_MAX, x*2 overflows to +inf, then +inf * 0.5 = +inf > FLT_MAX.
+
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 24))
+(assert (fp.gt x (fp #b0 #b00000000 #b00000000000000000000000)))
+(assert (fp.gt
+  (fp.mul RNE (fp.mul RNE x (fp #b0 #b10000000 #b00000000000000000000000))
+              (fp #b0 #b01111110 #b00000000000000000000000))
+  x))
+(check-sat)
diff --git a/regression/smt2_solver/fp/fp-to-fp-bv-unsupported1.desc b/regression/smt2_solver/fp/fp-to-fp-bv-unsupported1.desc
new file mode 100644
index 00000000000..09868dd9353
--- /dev/null
+++ b/regression/smt2_solver/fp/fp-to-fp-bv-unsupported1.desc
@@ -0,0 +1,8 @@
+CORE
+fp-to-fp-bv-unsupported1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+to_fp from bitvector (reinterpret cast): 0x3F800000 == 1.0f.
diff --git a/regression/smt2_solver/fp/fp-to-fp-bv-unsupported1.smt2 b/regression/smt2_solver/fp/fp-to-fp-bv-unsupported1.smt2
new file mode 100644
index 00000000000..ecd991c970b
--- /dev/null
+++ b/regression/smt2_solver/fp/fp-to-fp-bv-unsupported1.smt2
@@ -0,0 +1,7 @@
+; Test to_fp from bitvector (reinterpret cast).
+; 0x3F800000 reinterpreted as Float32 should be 1.0.
+
+(set-logic QF_FP)
+(assert (not (fp.eq ((_ to_fp 8 24) (_ bv1065353216 32))
+                    (fp #b0 #b01111111 #b00000000000000000000000))))
+(check-sat)
diff --git a/regression/smt2_solver/fp/fp-to-fp-convert1.desc b/regression/smt2_solver/fp/fp-to-fp-convert1.desc
new file mode 100644
index 00000000000..b8af8385407
--- /dev/null
+++ b/regression/smt2_solver/fp/fp-to-fp-convert1.desc
@@ -0,0 +1,8 @@
+CORE
+fp-to-fp-convert1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^unsat$
+--
+to_fp conversion from Float64 to Float32 preserves value of 1.0.
diff --git a/regression/smt2_solver/fp/fp-to-fp-convert1.smt2 b/regression/smt2_solver/fp/fp-to-fp-convert1.smt2
new file mode 100644
index 00000000000..710387030f6
--- /dev/null
+++ b/regression/smt2_solver/fp/fp-to-fp-convert1.smt2
@@ -0,0 +1,13 @@
+; Test to_fp conversion between FP sorts (double to float).
+; Converting 1.0 (Float64) to Float32 should give 1.0 (Float32).
+
+(set-logic QF_FP)
+; 1.0 as Float64
+(define-fun one_d () (_ FloatingPoint 11 53)
+  (fp #b0 #b01111111111 #b0000000000000000000000000000000000000000000000000000))
+; 1.0 as Float32
+(define-fun one_f () (_ FloatingPoint 8 24)
+  (fp #b0 #b01111111 #b00000000000000000000000))
+
+(assert (not (= ((_ to_fp 8 24) RNE one_d) one_f)))
+(check-sat)
diff --git a/regression/smt2_solver/fp/fp-to-real-unsupported1.desc b/regression/smt2_solver/fp/fp-to-real-unsupported1.desc
new file mode 100644
index 00000000000..6c7ce6aae49
--- /dev/null
+++ b/regression/smt2_solver/fp/fp-to-real-unsupported1.desc
@@ -0,0 +1,8 @@
+CORE
+fp-to-real-unsupported1.smt2
+
+^EXIT=0$
+^SIGNAL=0$
+^sat$
+--
+fp.to_real: find FP value matching real constant 1.0.
diff --git a/regression/smt2_solver/fp/fp-to-real-unsupported1.smt2 b/regression/smt2_solver/fp/fp-to-real-unsupported1.smt2
new file mode 100644
index 00000000000..71b4a1becc9
--- /dev/null
+++ b/regression/smt2_solver/fp/fp-to-real-unsupported1.smt2
@@ -0,0 +1,7 @@
+; Based on Z3#7321, Z3#8169: fp.to_real is not supported by CBMC's SMT2 solver.
+; This test documents the gap.
+
+(set-logic QF_FP)
+(declare-const x (_ FloatingPoint 8 24))
+(assert (= (fp.to_real x) 1.0))
+(check-sat)
diff --git a/src/ansi-c/c_typecheck_expr.cpp b/src/ansi-c/c_typecheck_expr.cpp
index d2219a7a29a..e85a21d50b1 100644
--- a/src/ansi-c/c_typecheck_expr.cpp
+++ b/src/ansi-c/c_typecheck_expr.cpp
@@ -3341,7 +3341,8 @@ exprt c_typecheck_baset::do_special_functions(
   else if(
     identifier == CPROVER_PREFIX "fmod" ||
     identifier == CPROVER_PREFIX "fmodf" ||
-    identifier == CPROVER_PREFIX "fmodl")
+    identifier == CPROVER_PREFIX "fmodl" ||
+    identifier == CPROVER_PREFIX "fmodf16")
   {
     if(expr.arguments().size() != 2)
     {
@@ -3362,10 +3363,76 @@ exprt c_typecheck_baset::do_special_functions(
 
     return std::move(fmod_expr);
   }
+  else if(
+    identifier == CPROVER_PREFIX "fmin" ||
+    identifier == CPROVER_PREFIX "fminf" ||
+    identifier == CPROVER_PREFIX "fminl")
+  {
+    if(expr.arguments().size() != 2)
+    {
+      error().source_location = f_op.source_location();
+      error() << "fmin-functions expect two operands" << eom;
+      throw 0;
+    }
+
+    typecheck_function_call_arguments(expr);
+
+    binary_exprt fmin_expr(
+      expr.arguments()[0], ID_floatbv_min, expr.arguments()[1]);
+
+    fmin_expr.add_source_location() = source_location;
+
+    return std::move(fmin_expr);
+  }
+  else if(
+    identifier == CPROVER_PREFIX "fmax" ||
+    identifier == CPROVER_PREFIX "fmaxf" ||
+    identifier == CPROVER_PREFIX "fmaxl")
+  {
+    if(expr.arguments().size() != 2)
+    {
+      error().source_location = f_op.source_location();
+      error() << "fmax-functions expect two operands" << eom;
+      throw 0;
+    }
+
+    typecheck_function_call_arguments(expr);
+
+    binary_exprt fmax_expr(
+      expr.arguments()[0], ID_floatbv_max, expr.arguments()[1]);
+
+    fmax_expr.add_source_location() = source_location;
+
+    return std::move(fmax_expr);
+  }
+  else if(
+    identifier == CPROVER_PREFIX "sqrt" ||
+    identifier == CPROVER_PREFIX "sqrtf" ||
+    identifier == CPROVER_PREFIX "sqrtl")
+  {
+    if(expr.arguments().size() != 1)
+    {
+      error().source_location = f_op.source_location();
+      error() << "sqrt-functions expect one operand" << eom;
+      throw 0;
+    }
+
+    typecheck_function_call_arguments(expr);
+
+    // Create as binary_exprt; adjust_float_expressions will add
+    // the rounding mode as a third operand.
+    binary_exprt sqrt_expr(
+      expr.arguments()[0], ID_floatbv_sqrt, expr.arguments()[0]);
+
+    sqrt_expr.add_source_location() = source_location;
+
+    return std::move(sqrt_expr);
+  }
   else if(
     identifier == CPROVER_PREFIX "remainder" ||
     identifier == CPROVER_PREFIX "remainderf" ||
-    identifier == CPROVER_PREFIX "remainderl")
+    identifier == CPROVER_PREFIX "remainderl" ||
+    identifier == CPROVER_PREFIX "remainderf16")
   {
     if(expr.arguments().size() != 2)
     {
@@ -3386,6 +3453,29 @@ exprt c_typecheck_baset::do_special_functions(
 
     return std::move(floatbv_rem_expr);
   }
+  else if(
+    identifier == CPROVER_PREFIX "fma" || identifier == CPROVER_PREFIX "fmaf" ||
+    identifier == CPROVER_PREFIX "fmal" ||
+    identifier == CPROVER_PREFIX "fmaf16")
+  {
+    if(expr.arguments().size() != 3)
+    {
+      error().source_location = f_op.source_location();
+      error() << "fma-functions expect three operands" << eom;
+      throw 0;
+    }
+
+    typecheck_function_call_arguments(expr);
+
+    // Create with 3 operands; adjust_float_expressions adds rounding mode
+    typet result_type = expr.arguments()[0].type();
+    multi_ary_exprt fma_expr(
+      ID_floatbv_fma, expr.arguments(), std::move(result_type));
+
+    fma_expr.add_source_location() = source_location;
+
+    return std::move(fma_expr);
+  }
   else if(identifier==CPROVER_PREFIX "allocate")
   {
     if(expr.arguments().size()!=2)
diff --git a/src/ansi-c/cprover_builtin_headers.h b/src/ansi-c/cprover_builtin_headers.h
index e7fd55c4ac1..ba2ebf7e8d7 100644
--- a/src/ansi-c/cprover_builtin_headers.h
+++ b/src/ansi-c/cprover_builtin_headers.h
@@ -110,9 +110,21 @@ float __CPROVER_fabsf(float x);
 double __CPROVER_fmod(double, double);
 float __CPROVER_fmodf(float, float);
 long double __CPROVER_fmodl(long double, long double);
+double __CPROVER_fmin(double, double);
+float __CPROVER_fminf(float, float);
+long double __CPROVER_fminl(long double, long double);
+double __CPROVER_fmax(double, double);
+float __CPROVER_fmaxf(float, float);
+long double __CPROVER_fmaxl(long double, long double);
+double __CPROVER_sqrt(double);
+float __CPROVER_sqrtf(float);
+long double __CPROVER_sqrtl(long double);
 double __CPROVER_remainder(double, double);
 float __CPROVER_remainderf(float, float);
 long double __CPROVER_remainderl(long double, long double);
+double __CPROVER_fma(double, double, double);
+float __CPROVER_fmaf(float, float, float);
+long double __CPROVER_fmal(long double, long double, long double);
 
 // arrays
 __CPROVER_bool __CPROVER_array_equal(const void *array1, const void *array2);
diff --git a/src/ansi-c/expr2c.cpp b/src/ansi-c/expr2c.cpp
index c7e38d5c8c6..0282b2e33fc 100644
--- a/src/ansi-c/expr2c.cpp
+++ b/src/ansi-c/expr2c.cpp
@@ -3734,6 +3734,16 @@ std::string expr2ct::convert_with_precedence(
       return convert_function(src, "SIGN");
   }
 
+  else if(src.id() == ID_floatbv_fma)
+  {
+    // Print only the 3 mathematical operands, omitting the rounding mode
+    // (4th operand) to produce valid C syntax: fma(a, b, c)
+    const auto &fma_expr = to_floatbv_fma_expr(src);
+    return "fma(" + convert(fma_expr.op_multiply_lhs()) + ", " +
+           convert(fma_expr.op_multiply_rhs()) + ", " +
+           convert(fma_expr.op_add()) + ")";
+  }
+
   else if(src.id()==ID_popcount)
   {
     if(config.ansi_c.mode==configt::ansi_ct::flavourt::VISUAL_STUDIO)
@@ -4135,6 +4145,7 @@ std::optional<std::string> expr2ct::convert_function(const exprt &src)
     {ID_separate, "SEPARATE"},
     {ID_floatbv_div, "FLOAT/"},
     {ID_floatbv_minus, "FLOAT-"},
+    {ID_floatbv_mod, "fmod"},
     {ID_floatbv_mult, "FLOAT*"},
     {ID_floatbv_plus, "FLOAT+"},
     {ID_floatbv_rem, "FLOAT%"},
diff --git a/src/ansi-c/library/math.c b/src/ansi-c/library/math.c
index c8cf190fc8e..a80e05d2ea8 100644
--- a/src/ansi-c/library/math.c
+++ b/src/ansi-c/library/math.c
@@ -822,261 +822,38 @@ __CPROVER_hide:;
 
 /* FUNCTION: sqrtf */
 
-/* This code is *WRONG* in some circumstances, specifically:
- *
- *   1. If run with a rounding mode other than RNE the
- *      answer will be out by one or two ULP.  This could be fixed
- *      with careful choice of round mode for the multiplications.
- *
- *   2. Subnormals have the unusual property that there are
- *      multiple numbers that square to give them.  I.E. if
- *      f is subnormal then there are multiple f1 != f2 such that
- *      f1 * f1 == f == f2 * f2.  This code will return *a*
- *      square root of a subnormal input but not necessarily *the*
- *      square root (i.e. the real value of the square root rounded).
- */
-
 #ifndef __CPROVER_MATH_H_INCLUDED
 #include <math.h>
 #define __CPROVER_MATH_H_INCLUDED
 #endif
 
-#ifndef __CPROVER_FENV_H_INCLUDED
-#include <fenv.h>
-#define __CPROVER_FENV_H_INCLUDED
-#endif
-
-float nextUpf(float f);
-
-float __VERIFIER_nondet_float(void);
-
 float sqrtf(float f)
 {
- __CPROVER_hide:;
-
-  if ( f < 0.0f )
-#pragma CPROVER check push
-#pragma CPROVER check disable "float-div-by-zero"
-    return 0.0f/0.0f; // NaN
-#pragma CPROVER check pop
-  else if (__CPROVER_isinff(f) ||   // +Inf only
-           f == 0.0f          ||   // Includes -0
-           __CPROVER_isnanf(f))
-    return f;
-  else if (__CPROVER_isnormalf(f))
-  {
-    float lower=__VERIFIER_nondet_float();
-    __CPROVER_assume(lower > 0.0f);
-    __CPROVER_assume(__CPROVER_isnormalf(lower));
-    // Tighter bounds can be given but are dependent on the
-    // number of exponent and significand bits.  Thus they are
-    // given implicitly...
-
-#pragma CPROVER check push
-#pragma CPROVER check disable "float-overflow"
-    float lowerSquare = lower * lower;
-    __CPROVER_assume(__CPROVER_isnormalf(lowerSquare));
-
-    float upper = nextUpf(lower);
-    float upperSquare = upper * upper;  // Might be +Inf
-#pragma CPROVER check pop
-
-    // Restrict these to bound f and thus compute the possible
-    // values for the square root.  Note that the lower bound
-    // can be equal, this is important to catch edge cases such as
-    // 0x1.fffffep+127f and relies on the smallest normal number
-    // being a perfect square (which it will be for any sensible
-    // bit width).
-    __CPROVER_assume(lowerSquare <= f);
-    __CPROVER_assume(f < upperSquare);
-
-    // Select between them to work out which to return
-    switch(fegetround())
-    {
-    case FE_TONEAREST :
-      return (f - lowerSquare < upperSquare - f) ? lower : upper; break;
-    case FE_UPWARD :
-      return (f - lowerSquare == 0.0f) ? lower : upper; break;
-    case FE_DOWNWARD : // Fall through
-    case FE_TOWARDZERO :
-      return (f - lowerSquare == 0.0f) ? lower : upper; break;
-    default:;
-      return __VERIFIER_nondet_float();
-    }
-
-  }
-  else
-  {
-    //assert(fpclassify(f) == FP_SUBNORMAL);
-    //assert(f > 0.0f);
-
-    // With respect to the algebra of floating point number
-    // all subnormals seem to be perfect squares, thus ...
-
-    float root=__VERIFIER_nondet_float();
-    __CPROVER_assume(root >= 0.0f);
-
-    __CPROVER_assume(root * root == f);
-
-    return root;
-  }
+  return __CPROVER_sqrtf(f);
 }
 
-
-
-
 /* FUNCTION: sqrt */
 
-/* The same caveats as sqrtf apply */
-
 #ifndef __CPROVER_MATH_H_INCLUDED
 #include <math.h>
 #define __CPROVER_MATH_H_INCLUDED
 #endif
 
-#ifndef __CPROVER_FENV_H_INCLUDED
-#include <fenv.h>
-#define __CPROVER_FENV_H_INCLUDED
-#endif
-
-double nextUp(double d);
-
-double __VERIFIER_nondet_double(void);
-
 double sqrt(double d)
 {
- __CPROVER_hide:;
-
-  if ( d < 0.0 )
-#pragma CPROVER check push
-#pragma CPROVER check disable "float-div-by-zero"
-    return 0.0/0.0; // NaN
-#pragma CPROVER check pop
-  else if (__CPROVER_isinfd(d) ||   // +Inf only
-           d == 0.0            ||   // Includes -0
-           __CPROVER_isnand(d))
-    return d;
-  else if (__CPROVER_isnormald(d))
-  {
-    double lower=__VERIFIER_nondet_double();
-    __CPROVER_assume(lower > 0.0);
-    __CPROVER_assume(__CPROVER_isnormald(lower));
-
-#pragma CPROVER check push
-#pragma CPROVER check disable "float-overflow"
-    double lowerSquare = lower * lower;
-    __CPROVER_assume(__CPROVER_isnormald(lowerSquare));
-
-    double upper = nextUp(lower);
-    double upperSquare = upper * upper;  // Might be +Inf
-#pragma CPROVER check pop
-
-    __CPROVER_assume(lowerSquare <= d);
-    __CPROVER_assume(d < upperSquare);
-
-    switch(fegetround())
-    {
-    case FE_TONEAREST:
-      return (d - lowerSquare < upperSquare - d) ? lower : upper; break;
-    case FE_UPWARD:
-      return (d - lowerSquare == 0.0f) ? lower : upper; break;
-    case FE_DOWNWARD: // Fall through
-    case FE_TOWARDZERO:
-      return (d - lowerSquare == 0.0) ? lower : upper; break;
-    default:;
-      return __VERIFIER_nondet_double();
-    }
-
-  }
-  else
-  {
-    //assert(fpclassify(d) == FP_SUBNORMAL);
-    //assert(d > 0.0);
-
-    double root=__VERIFIER_nondet_double();
-    __CPROVER_assume(root >= 0.0);
-
-    __CPROVER_assume(root * root == d);
-
-    return root;
-  }
+  return __CPROVER_sqrt(d);
 }
 
 /* FUNCTION: sqrtl */
 
-/* The same caveats as sqrtf apply */
-
 #ifndef __CPROVER_MATH_H_INCLUDED
 #include <math.h>
 #define __CPROVER_MATH_H_INCLUDED
 #endif
 
-#ifndef __CPROVER_FENV_H_INCLUDED
-#include <fenv.h>
-#define __CPROVER_FENV_H_INCLUDED
-#endif
-
-long double nextUpl(long double d);
-
-long double __VERIFIER_nondet_long_double(void);
-
 long double sqrtl(long double d)
 {
- __CPROVER_hide:;
-
-  if(d < 0.0l)
-#pragma CPROVER check push
-#pragma CPROVER check disable "float-div-by-zero"
-    return 0.0l/0.0l; // NaN
-#pragma CPROVER check pop
-  else if (__CPROVER_isinfld(d) ||   // +Inf only
-           d == 0.0l            ||   // Includes -0
-           __CPROVER_isnanld(d))
-    return d;
-  else if (__CPROVER_isnormalld(d))
-  {
-    long double lower=__VERIFIER_nondet_long_double();
-    __CPROVER_assume(lower > 0.0l);
-    __CPROVER_assume(__CPROVER_isnormalld(lower));
-
-#pragma CPROVER check push
-#pragma CPROVER check disable "float-overflow"
-    long double lowerSquare = lower * lower;
-    __CPROVER_assume(__CPROVER_isnormalld(lowerSquare));
-
-    long double upper = nextUpl(lower);
-    long double upperSquare = upper * upper;  // Might be +Inf
-#pragma CPROVER check pop
-
-    __CPROVER_assume(lowerSquare <= d);
-    __CPROVER_assume(d < upperSquare);
-
-    switch(fegetround())
-    {
-    case FE_TONEAREST:
-      return (d - lowerSquare < upperSquare - d) ? lower : upper; break;
-    case FE_UPWARD:
-      return (d - lowerSquare == 0.0l) ? lower : upper; break;
-    case FE_DOWNWARD: // Fall through
-    case FE_TOWARDZERO:
-      return (d - lowerSquare == 0.0l) ? lower : upper; break;
-    default:;
-      return __VERIFIER_nondet_long_double();
-    }
-
-  }
-  else
-  {
-    //assert(fpclassify(d) == FP_SUBNORMAL);
-    //assert(d > 0.0l);
-
-    long double root=__VERIFIER_nondet_long_double();
-    __CPROVER_assume(root >= 0.0l);
-
-    __CPROVER_assume(root * root == d);
-
-    return root;
-  }
+  return __CPROVER_sqrtl(d);
 }
 
 
@@ -1108,7 +885,7 @@ long double sqrtl(long double d)
 #endif
 
 // TODO : Should call a __CPROVER_function so that it can be converted to SMT-LIB
-double fmax(double f, double g) { return ((f >= g) || isnan(g)) ? f : g; }
+double fmax(double f, double g) { return __CPROVER_fmax(f, g); }
 
 /* FUNCTION: fmaxf */
 
@@ -1118,7 +895,7 @@ double fmax(double f, double g) { return ((f >= g) || isnan(g)) ? f : g; }
 #endif
 
 // TODO : Should call a __CPROVER_function so that it can be converted to SMT-LIB
-float fmaxf(float f, float g) { return ((f >= g) || isnan(g)) ? f : g; }
+float fmaxf(float f, float g) { return __CPROVER_fmaxf(f, g); }
 
 /* FUNCTION: fmaxl */
 
@@ -1128,7 +905,7 @@ float fmaxf(float f, float g) { return ((f >= g) || isnan(g)) ? f : g; }
 #endif
 
 // TODO : Should call a __CPROVER_function so that it can be converted to SMT-LIB
-long double fmaxl(long double f, long double g) { return ((f >= g) || isnan(g)) ? f : g; }
+long double fmaxl(long double f, long double g) { return __CPROVER_fmaxl(f, g); }
 
 
 /* ISO 9899:2011
@@ -1151,7 +928,7 @@ long double fmaxl(long double f, long double g) { return ((f >= g) || isnan(g))
 #endif
  
 // TODO : Should call a __CPROVER_function so that it can be converted to SMT-LIB
-double fmin(double f, double g) { return ((f <= g) || isnan(g)) ? f : g; }
+double fmin(double f, double g) { return __CPROVER_fmin(f, g); }
 
 /* FUNCTION: fminf */
 
@@ -1161,7 +938,7 @@ double fmin(double f, double g) { return ((f <= g) || isnan(g)) ? f : g; }
 #endif
 
 // TODO : Should call a __CPROVER_function so that it can be converted to SMT-LIB 
-float fminf(float f, float g) { return ((f <= g) || isnan(g)) ? f : g; }
+float fminf(float f, float g) { return __CPROVER_fminf(f, g); }
 
 /* FUNCTION: fminl */
 
@@ -1171,7 +948,7 @@ float fminf(float f, float g) { return ((f <= g) || isnan(g)) ? f : g; }
 #endif
 
 // TODO : Should call a __CPROVER_function so that it can be converted to SMT-LIB 
-long double fminl(long double f, long double g) { return ((f <= g) || isnan(g)) ? f : g; }
+long double fminl(long double f, long double g) { return __CPROVER_fminl(f, g); }
 
 
 /* ISO 9899:2011
@@ -1897,55 +1674,6 @@ long double modfl(long double x, long double *iptr)
   return (x - *iptr);
 }
 
-
-
-/* FUNCTION: __sort_of_CPROVER_remainder */
-// TODO : Should be a real __CPROVER function to convert to SMT-LIB
-
-double __sort_of_CPROVER_remainder (int rounding_mode, double x, double y)
-{
-  if (x == 0.0 || __CPROVER_isinfd(y))
-    return x;
-
-  // Extended precision helps... a bit...
-  long double div = x/y;
-  long double n = __CPROVER_round_to_integrald(rounding_mode, div);
-  long double res = (-y * n) + x;   // TODO : FMA would be an improvement
-  return res;
-}
-
-/* FUNCTION: __sort_of_CPROVER_remainderf */
-// TODO : Should be a real __CPROVER function to convert to SMT-LIB
-
-float __sort_of_CPROVER_remainderf (int rounding_mode, float x, float y)
-{
-  if (x == 0.0f || __CPROVER_isinff(y))
-    return x;
-
-  // Extended precision helps... a bit...
-  long double div = x/y;
-  long double n = __CPROVER_round_to_integralf(rounding_mode, div);
-  long double res = (-y * n) + x;   // TODO : FMA would be an improvement
-  return res;
-}
-
-/* FUNCTION: __sort_of_CPROVER_remainderl */
-// TODO : Should be a real __CPROVER function to convert to SMT-LIB
-
-long double __sort_of_CPROVER_remainderl (int rounding_mode, long double x, long double y)
-{
-  if (x == 0.0 || __CPROVER_isinfld(y))
-    return x;
-
-  // Extended precision helps... a bit...
-  long double div = x/y;
-  long double n = __CPROVER_round_to_integralld(rounding_mode, div);
-  long double res = (-y * n) + x;   // TODO : FMA would be an improvement
-  return res;
-}
-
-
-
 /* ISO 9899:2011
  *
  * The fmod functions return the value x - ny, for some
@@ -2026,15 +1754,10 @@ long double fmodl(long double x, long double y)
 #define __CPROVER_MATH_H_INCLUDED
 #endif
 
-#ifndef __CPROVER_FENV_H_INCLUDED
-#include <fenv.h>
-#define __CPROVER_FENV_H_INCLUDED
-#endif
-
-double __sort_of_CPROVER_remainder (int rounding_mode, double x, double y);
-
-double remainder(double x, double y) { return __sort_of_CPROVER_remainder(FE_TONEAREST, x, y); }
-
+double remainder(double x, double y)
+{
+  return __CPROVER_remainder(x, y);
+}
 
 /* FUNCTION: remainderf */
 
@@ -2043,15 +1766,10 @@ double remainder(double x, double y) { return __sort_of_CPROVER_remainder(FE_TON
 #define __CPROVER_MATH_H_INCLUDED
 #endif
 
-#ifndef __CPROVER_FENV_H_INCLUDED
-#include <fenv.h>
-#define __CPROVER_FENV_H_INCLUDED
-#endif
-
-float __sort_of_CPROVER_remainderf (int rounding_mode, float x, float y);
-
-float remainderf(float x, float y) { return __sort_of_CPROVER_remainderf(FE_TONEAREST, x, y); }
-
+float remainderf(float x, float y)
+{
+  return __CPROVER_remainderf(x, y);
+}
 
 /* FUNCTION: remainderl */
 
@@ -2060,17 +1778,10 @@ float remainderf(float x, float y) { return __sort_of_CPROVER_remainderf(FE_TONE
 #define __CPROVER_MATH_H_INCLUDED
 #endif
 
-#ifndef __CPROVER_FENV_H_INCLUDED
-#include <fenv.h>
-#define __CPROVER_FENV_H_INCLUDED
-#endif
-
-long double __sort_of_CPROVER_remainderl (int rounding_mode, long double x, long double y);
-
-long double remainderl(long double x, long double y) { return __sort_of_CPROVER_remainderl(FE_TONEAREST, x, y); }
-
-
-
+long double remainderl(long double x, long double y)
+{
+  return __CPROVER_remainderl(x, y);
+}
 
 /* ISO 9899:2011
  * The copysign functions produce a value with the magnitude of x and
@@ -3486,44 +3197,19 @@ long double powl(long double x, long double y)
 #  define __CPROVER_FENV_H_INCLUDED
 #endif
 
-double __builtin_inf(void);
-
 double fma(double x, double y, double z)
 {
-  // see man fma (https://linux.die.net/man/3/fma)
-#pragma CPROVER check push
-#pragma CPROVER check disable "float-div-by-zero"
-  if(isnan(x) || isnan(y))
-    return 0.0 / 0.0;
-  else if(
-    (isinf(x) || isinf(y)) &&
-    (fpclassify(x) == FP_ZERO || fpclassify(y) == FP_ZERO))
+  // IEEE 754: raise FE_INVALID for 0*inf or inf+(-inf)
+  if((__CPROVER_isinfd(x) && y == 0.0) || (x == 0.0 && __CPROVER_isinfd(y)))
   {
     feraiseexcept(FE_INVALID);
-    return 0.0 / 0.0;
   }
-  else if(isnan(z))
-    return 0.0 / 0.0;
-
-#pragma CPROVER check disable "float-overflow"
-  double x_times_y = x * y;
-  if(
-    isinf(x_times_y) && isinf(z) &&
-    __CPROVER_signd(x_times_y) != __CPROVER_signd(z))
+  else if((__CPROVER_isinfd(x) || __CPROVER_isinfd(y)) && __CPROVER_isinfd(z))
   {
     feraiseexcept(FE_INVALID);
-    return 0.0 / 0.0;
   }
-#pragma CPROVER check pop
-
-  if(isinf(x_times_y))
-  {
-    feraiseexcept(FE_OVERFLOW);
-    return __CPROVER_signd(x_times_y) ? -__builtin_inf() : __builtin_inf();
-  }
-  // TODO: detect underflow (FE_UNDERFLOW), return +/- 0
 
-  return x_times_y + z;
+  return __CPROVER_fma(x, y, z);
 }
 
 /* FUNCTION: fmaf */
@@ -3538,44 +3224,18 @@ double fma(double x, double y, double z)
 #  define __CPROVER_FENV_H_INCLUDED
 #endif
 
-float __builtin_inff(void);
-
 float fmaf(float x, float y, float z)
 {
-  // see man fma (https://linux.die.net/man/3/fma)
-#pragma CPROVER check push
-#pragma CPROVER check disable "float-div-by-zero"
-  if(isnanf(x) || isnanf(y))
-    return 0.0f / 0.0f;
-  else if(
-    (isinff(x) || isinff(y)) &&
-    (fpclassify(x) == FP_ZERO || fpclassify(y) == FP_ZERO))
+  if((__CPROVER_isinff(x) && y == 0.0f) || (x == 0.0f && __CPROVER_isinff(y)))
   {
     feraiseexcept(FE_INVALID);
-    return 0.0f / 0.0f;
   }
-  else if(isnanf(z))
-    return 0.0f / 0.0f;
-
-#pragma CPROVER check disable "float-overflow"
-  float x_times_y = x * y;
-  if(
-    isinff(x_times_y) && isinff(z) &&
-    __CPROVER_signf(x_times_y) != __CPROVER_signf(z))
+  else if((__CPROVER_isinff(x) || __CPROVER_isinff(y)) && __CPROVER_isinff(z))
   {
     feraiseexcept(FE_INVALID);
-    return 0.0f / 0.0f;
-  }
-#pragma CPROVER check pop
-
-  if(isinff(x_times_y))
-  {
-    feraiseexcept(FE_OVERFLOW);
-    return __CPROVER_signf(x_times_y) ? -__builtin_inff() : __builtin_inff();
   }
-  // TODO: detect underflow (FE_UNDERFLOW), return +/- 0
 
-  return x_times_y + z;
+  return __CPROVER_fmaf(x, y, z);
 }
 
 /* FUNCTION: fmal */
@@ -3590,53 +3250,19 @@ float fmaf(float x, float y, float z)
 #  define __CPROVER_FENV_H_INCLUDED
 #endif
 
-#ifndef __CPROVER_FLOAT_H_INCLUDED
-#  include <float.h>
-#  define __CPROVER_FLOAT_H_INCLUDED
-#endif
-
-long double __builtin_infl(void);
-
 long double fmal(long double x, long double y, long double z)
 {
-  // see man fma (https://linux.die.net/man/3/fma)
-#pragma CPROVER check push
-#pragma CPROVER check disable "float-div-by-zero"
-  if(isnanl(x) || isnanl(y))
-    return 0.0l / 0.0l;
-  else if(
-    (isinfl(x) || isinfl(y)) &&
-    (fpclassify(x) == FP_ZERO || fpclassify(y) == FP_ZERO))
+  if((__CPROVER_isinfld(x) && y == 0.0l) || (x == 0.0l && __CPROVER_isinfld(y)))
   {
     feraiseexcept(FE_INVALID);
-    return 0.0l / 0.0l;
   }
-  else if(isnanl(z))
-    return 0.0l / 0.0l;
-
-#pragma CPROVER check disable "float-overflow"
-  long double x_times_y = x * y;
-  if(
-    isinfl(x_times_y) && isinfl(z) &&
-    __CPROVER_signld(x_times_y) != __CPROVER_signld(z))
+  else if(
+    (__CPROVER_isinfld(x) || __CPROVER_isinfld(y)) && __CPROVER_isinfld(z))
   {
     feraiseexcept(FE_INVALID);
-    return 0.0l / 0.0l;
   }
-#pragma CPROVER check pop
 
-#if LDBL_MAX_EXP == DBL_MAX_EXP
-  return fma(x, y, z);
-#else
-  if(isinfl(x_times_y))
-  {
-    feraiseexcept(FE_OVERFLOW);
-    return __CPROVER_signld(x_times_y) ? -__builtin_infl() : __builtin_infl();
-  }
-  // TODO: detect underflow (FE_UNDERFLOW), return +/- 0
-
-  return x_times_y + z;
-#endif
+  return __CPROVER_fmal(x, y, z);
 }
 
 /* FUNCTION: __builtin_powi */
diff --git a/src/goto-programs/adjust_float_expressions.cpp b/src/goto-programs/adjust_float_expressions.cpp
index eafea9ed5a3..698ad16cf0a 100644
--- a/src/goto-programs/adjust_float_expressions.cpp
+++ b/src/goto-programs/adjust_float_expressions.cpp
@@ -31,15 +31,21 @@ irep_idt rounding_mode_identifier()
 /// yet.
 static bool have_to_adjust_float_expressions(const exprt &expr)
 {
-  if(expr.id()==ID_floatbv_plus ||
-     expr.id()==ID_floatbv_minus ||
-     expr.id()==ID_floatbv_mult ||
-     expr.id()==ID_floatbv_div ||
-     expr.id()==ID_floatbv_div ||
-     expr.id()==ID_floatbv_rem ||
-     expr.id()==ID_floatbv_typecast)
+  if(
+    expr.id() == ID_floatbv_plus || expr.id() == ID_floatbv_minus ||
+    expr.id() == ID_floatbv_mult || expr.id() == ID_floatbv_div ||
+    expr.id() == ID_floatbv_mod || expr.id() == ID_floatbv_rem ||
+    expr.id() == ID_floatbv_typecast)
+  {
+    return false;
+  }
+
+  if(expr.id() == ID_floatbv_sqrt && expr.operands().size() == 3)
     return false;
 
+  if(expr.id() == ID_floatbv_sqrt && expr.operands().size() == 2)
+    return true;
+
   const typet &type = expr.type();
 
   if(
@@ -53,6 +59,10 @@ static bool have_to_adjust_float_expressions(const exprt &expr)
       return true;
   }
 
+  // FMA needs rounding mode added (3 operands -> 4)
+  if(expr.id() == ID_floatbv_fma && expr.operands().size() == 3)
+    return true;
+
   if(expr.id()==ID_typecast)
   {
     const typecast_exprt &typecast_expr=to_typecast_expr(expr);
@@ -129,6 +139,20 @@ void adjust_float_expressions(exprt &expr, const exprt &rounding_mode)
       expr.operands().resize(3);
       to_ieee_float_op_expr(expr).rounding_mode() = rounding_mode;
     }
+
+    if(expr.id() == ID_floatbv_sqrt && expr.operands().size() == 2)
+    {
+      // sqrt: add rounding mode as 3rd operand
+      expr.operands().resize(3);
+      to_ieee_float_op_expr(expr).rounding_mode() = rounding_mode;
+    }
+  }
+
+  // Add rounding mode to FMA
+  if(expr.id() == ID_floatbv_fma && expr.operands().size() == 3)
+  {
+    expr.operands().resize(4);
+    to_floatbv_fma_expr(expr).rounding_mode() = rounding_mode;
   }
 
   if(expr.id()==ID_typecast)
diff --git a/src/solvers/Makefile b/src/solvers/Makefile
index 13b4d899dc9..0d562287a2f 100644
--- a/src/solvers/Makefile
+++ b/src/solvers/Makefile
@@ -103,7 +103,9 @@ SRC = $(BOOLEFORCE_SRC) \
       flattening/boolbv_equality.cpp \
       flattening/boolbv_extractbit.cpp \
       flattening/boolbv_extractbits.cpp \
+      flattening/boolbv_floatbv_fma.cpp \
       flattening/boolbv_floatbv_mod_rem.cpp \
+      flattening/boolbv_floatbv_min_max.cpp \
       flattening/boolbv_floatbv_op.cpp \
       flattening/boolbv_get.cpp \
       flattening/boolbv_ieee_float_rel.cpp \
diff --git a/src/solvers/flattening/boolbv.cpp b/src/solvers/flattening/boolbv.cpp
index 94813350942..57da856c81f 100644
--- a/src/solvers/flattening/boolbv.cpp
+++ b/src/solvers/flattening/boolbv.cpp
@@ -154,10 +154,18 @@ bvt boolbvt::convert_bitvector(const exprt &expr)
   {
     return convert_floatbv_op(to_ieee_float_op_expr(expr));
   }
+  else if(expr.id() == ID_floatbv_sqrt)
+  {
+    return convert_floatbv_op(to_ieee_float_op_expr(expr));
+  }
   else if(expr.id() == ID_floatbv_mod)
     return convert_floatbv_mod_rem(to_binary_expr(expr));
   else if(expr.id() == ID_floatbv_rem)
     return convert_floatbv_mod_rem(to_binary_expr(expr));
+  else if(expr.id() == ID_floatbv_min || expr.id() == ID_floatbv_max)
+    return convert_floatbv_min_max(to_binary_expr(expr));
+  else if(expr.id() == ID_floatbv_to_real)
+    return convert_floatbv_to_real(to_unary_expr(expr));
   else if(expr.id()==ID_floatbv_typecast)
     return convert_floatbv_typecast(to_floatbv_typecast_expr(expr));
   else if(expr.id() == ID_floatbv_round_to_integral)
diff --git a/src/solvers/flattening/boolbv.h b/src/solvers/flattening/boolbv.h
index 30677e94fbf..72893793499 100644
--- a/src/solvers/flattening/boolbv.h
+++ b/src/solvers/flattening/boolbv.h
@@ -33,6 +33,7 @@ class byte_update_exprt;
 class concatenation_exprt;
 class extractbit_exprt;
 class extractbits_exprt;
+class floatbv_fma_exprt;
 class floatbv_round_to_integral_exprt;
 class floatbv_typecast_exprt;
 class ieee_float_op_exprt;
@@ -178,6 +179,9 @@ class boolbvt:public arrayst
   virtual bvt convert_mod(const mod_exprt &expr);
   virtual bvt convert_floatbv_op(const ieee_float_op_exprt &);
   virtual bvt convert_floatbv_mod_rem(const binary_exprt &);
+  virtual bvt convert_floatbv_fma(const floatbv_fma_exprt &);
+  virtual bvt convert_floatbv_min_max(const binary_exprt &);
+  virtual bvt convert_floatbv_to_real(const unary_exprt &);
   virtual bvt convert_floatbv_typecast(const floatbv_typecast_exprt &expr);
   virtual bvt
   convert_floatbv_round_to_integral(const floatbv_round_to_integral_exprt &);
diff --git a/src/solvers/flattening/boolbv_floatbv_fma.cpp b/src/solvers/flattening/boolbv_floatbv_fma.cpp
new file mode 100644
index 00000000000..d7486e4aefa
--- /dev/null
+++ b/src/solvers/flattening/boolbv_floatbv_fma.cpp
@@ -0,0 +1,28 @@
+/*******************************************************************\
+
+Module:
+
+Author: Michael Tautschnig
+
+\*******************************************************************/
+
+#include <util/bitvector_types.h>
+#include <util/floatbv_expr.h>
+
+#include <solvers/floatbv/float_utils.h>
+
+#include "boolbv.h"
+
+bvt boolbvt::convert_floatbv_fma(const floatbv_fma_exprt &expr)
+{
+  float_utilst float_utils(prop);
+
+  float_utils.set_rounding_mode(convert_bv(expr.rounding_mode()));
+  float_utils.spec = ieee_float_spect(to_floatbv_type(expr.type()));
+
+  bvt multiply_lhs = convert_bv(expr.op_multiply_lhs());
+  bvt multiply_rhs = convert_bv(expr.op_multiply_rhs());
+  bvt addend = convert_bv(expr.op_add());
+
+  return float_utils.fma(multiply_lhs, multiply_rhs, addend);
+}
diff --git a/src/solvers/flattening/boolbv_floatbv_min_max.cpp b/src/solvers/flattening/boolbv_floatbv_min_max.cpp
new file mode 100644
index 00000000000..36d88e25cc5
--- /dev/null
+++ b/src/solvers/flattening/boolbv_floatbv_min_max.cpp
@@ -0,0 +1,51 @@
+/*******************************************************************\
+
+Module:
+
+Author: Michael Tautschnig
+
+\*******************************************************************/
+
+#include <util/bitvector_types.h>
+
+#include <solvers/floatbv/float_utils.h>
+
+#include "boolbv.h"
+
+bvt boolbvt::convert_floatbv_min_max(const binary_exprt &expr)
+{
+  if(expr.type().id() != ID_floatbv)
+    return conversion_failed(expr);
+
+  const bvt &bv0 = convert_bv(expr.lhs());
+  const bvt &bv1 = convert_bv(expr.rhs());
+
+  float_utilst float_utils(prop, to_floatbv_type(expr.type()));
+
+  literalt x_nan = float_utils.is_NaN(bv0);
+  literalt y_nan = float_utils.is_NaN(bv1);
+
+  // IEEE 754-2019: if one operand is NaN, return the other
+  // For min: return the smaller; ties (fp.eq) prefer negative sign
+  // For max: return the larger; ties prefer positive sign
+  literalt x_lt_y = float_utils.relation(bv0, float_utilst::relt::LT, bv1);
+  literalt x_eq_y = float_utils.relation(bv0, float_utilst::relt::EQ, bv1);
+  literalt x_sign = float_utilst::sign_bit(bv0);
+
+  literalt prefer_x;
+  if(expr.id() == ID_floatbv_min)
+  {
+    // min: prefer x if x < y, or if equal and x is negative
+    prefer_x = prop.lor(x_lt_y, prop.land(x_eq_y, x_sign));
+  }
+  else
+  {
+    // max: prefer x if x > y, or if equal and x is positive
+    literalt x_gt_y = float_utils.relation(bv0, float_utilst::relt::GT, bv1);
+    prefer_x = prop.lor(x_gt_y, prop.land(x_eq_y, !x_sign));
+  }
+
+  bvt non_nan = bv_utils.select(prefer_x, bv0, bv1);
+  bvt handle_y_nan = bv_utils.select(y_nan, bv0, non_nan);
+  return bv_utils.select(x_nan, bv1, handle_y_nan);
+}
diff --git a/src/solvers/flattening/boolbv_floatbv_mod_rem.cpp b/src/solvers/flattening/boolbv_floatbv_mod_rem.cpp
index 3a91c5adac6..7cc7e6349a7 100644
--- a/src/solvers/flattening/boolbv_floatbv_mod_rem.cpp
+++ b/src/solvers/flattening/boolbv_floatbv_mod_rem.cpp
@@ -19,7 +19,10 @@ bvt boolbvt::convert_floatbv_mod_rem(const binary_exprt &expr)
 
   float_utilst float_utils(prop);
 
-  auto rm = bv_utils.build_constant(ieee_floatt::ROUND_TO_EVEN, 32);
+  auto rm = bv_utils.build_constant(
+    expr.id() == ID_floatbv_rem ? ieee_floatt::ROUND_TO_EVEN
+                                : ieee_floatt::ROUND_TO_ZERO,
+    32);
   float_utils.set_rounding_mode(rm);
 
   float_utils.spec = ieee_float_spect(to_floatbv_type(expr.type()));
@@ -27,7 +30,7 @@ bvt boolbvt::convert_floatbv_mod_rem(const binary_exprt &expr)
   bvt lhs_as_bv = convert_bv(expr.lhs());
   bvt rhs_as_bv = convert_bv(expr.rhs());
 
-  // float_utilst::rem implements lhs-(lhs/rhs)*rhs, which matches
-  // neither fmod() nor IEEE
+  // float_utilst::rem computes fmod (ROUND_TO_ZERO) or IEEE remainder
+  // (ROUND_TO_EVEN) depending on the rounding mode set above.
   return float_utils.rem(lhs_as_bv, rhs_as_bv);
 }
diff --git a/src/solvers/flattening/boolbv_floatbv_op.cpp b/src/solvers/flattening/boolbv_floatbv_op.cpp
index eb6d7eec40d..d5575d7e51f 100644
--- a/src/solvers/flattening/boolbv_floatbv_op.cpp
+++ b/src/solvers/flattening/boolbv_floatbv_op.cpp
@@ -129,6 +129,8 @@ bvt boolbvt::convert_floatbv_op(const ieee_float_op_exprt &expr)
       return float_utils.mul(lhs_as_bv, rhs_as_bv);
     else if(expr.id()==ID_floatbv_div)
       return float_utils.div(lhs_as_bv, rhs_as_bv);
+    else if(expr.id() == ID_floatbv_sqrt)
+      return float_utils.sqrt(lhs_as_bv);
     else
       UNREACHABLE;
   }
diff --git a/src/solvers/flattening/boolbv_floatbv_to_real.cpp b/src/solvers/flattening/boolbv_floatbv_to_real.cpp
new file mode 100644
index 00000000000..db9ce2e8385
--- /dev/null
+++ b/src/solvers/flattening/boolbv_floatbv_to_real.cpp
@@ -0,0 +1,93 @@
+/*******************************************************************\
+
+Module:
+
+Author: Michael Tautschnig
+
+\*******************************************************************/
+
+/// \file
+/// Encoding of fp.to_real as a wide signed integer with implicit
+/// scaling factor 2^k. The real value is integer_value / 2^k where
+/// k = f + bias (sufficient to represent all FP values exactly).
+
+#include <util/arith_tools.h>
+#include <util/bitvector_types.h>
+#include <util/ieee_float.h>
+
+#include <solvers/floatbv/float_utils.h>
+
+#include "boolbv.h"
+
+bvt boolbvt::convert_floatbv_to_real(const unary_exprt &expr)
+{
+  PRECONDITION(expr.id() == ID_floatbv_to_real);
+  PRECONDITION(expr.op().type().id() == ID_floatbv);
+
+  const auto &fp_type = to_floatbv_type(expr.op().type());
+  const ieee_float_spect spec(fp_type);
+  const bvt &src = convert_bv(expr.op());
+
+  float_utilst float_utils(prop, fp_type);
+
+  const std::size_t int_width = boolbv_width(expr.type());
+  const std::size_t bias = (1u << (spec.e - 1)) - 1;
+
+  // Extract sign, exponent, fraction from the FP bitvector
+  literalt sign = src.back();
+  literalt is_zero = float_utils.is_zero(src);
+  literalt is_nan = float_utils.is_NaN(src);
+  literalt is_inf = float_utils.is_infinity(src);
+
+  // Extract exponent bits and fraction bits
+  bvt exp_bits = bv_utils.extract(src, spec.f, spec.f + spec.e - 1);
+  bvt frac_bits = bv_utils.extract(src, 0, spec.f - 1);
+
+  // Compute unbiased exponent (signed)
+  bvt exp_extended = bv_utils.zero_extension(exp_bits, int_width);
+  bvt bias_bv = bv_utils.build_constant(bias, int_width);
+  bvt exponent = bv_utils.sub(exp_extended, bias_bv);
+
+  // Build significand with hidden bit
+  // For normal: 1.fraction; for subnormal: 0.fraction
+  literalt is_normal = float_utils.is_normal(src);
+  bvt significand = bv_utils.zero_extension(frac_bits, int_width);
+  // Set the hidden bit (bit spec.f) for normal numbers
+  significand[spec.f] = is_normal;
+
+  // The real value is: (-1)^sign * significand * 2^(exponent - f)
+  // Scaled by 2^(f + bias): result = significand * 2^(exponent + bias)
+  // = significand << (exponent + bias)
+  // For subnormals: exponent = 1 - bias (not 0 - bias), so
+  // shift = 1 - bias + bias = 1. But subnormal significand has no
+  // hidden bit, so the value is correct: frac * 2^(1-bias) scaled by
+  // 2^(f+bias) = frac * 2^(f+1) = frac << (f+1). But our shift is
+  // exponent + bias = (0 - bias) + bias = 0 for subnormals (since
+  // exp_bits = 0). That gives frac << 0 = frac, which represents
+  // frac / 2^(f+bias). The actual value is frac * 2^(1-bias-f) =
+  // frac / 2^(f+bias-1). Off by factor 2.
+  // Fix: for subnormals, use exponent = 1 - bias instead of 0 - bias.
+  bvt one_bv = bv_utils.build_constant(1, int_width);
+  bvt subnormal_exp = bv_utils.sub(one_bv, bias_bv);
+  bvt normal_exp = exponent;
+  bvt actual_exp = bv_utils.select(is_normal, normal_exp, subnormal_exp);
+
+  // Shift amount = actual_exp + bias = actual_exp + bias
+  bvt shift_amount = bv_utils.add(actual_exp, bias_bv);
+
+  // Left-shift the significand
+  bvt shifted =
+    bv_utils.shift(significand, bv_utilst::shiftt::SHIFT_LEFT, shift_amount);
+
+  // Apply sign: negate if negative
+  bvt negated = bv_utils.negate(shifted);
+  bvt result = bv_utils.select(sign, negated, shifted);
+
+  // Zero for zero inputs, zero for NaN/infinity (no real representation)
+  bvt zero_bv = bv_utils.build_constant(0, int_width);
+  result = bv_utils.select(is_zero, zero_bv, result);
+  result = bv_utils.select(is_nan, zero_bv, result);
+  result = bv_utils.select(is_inf, zero_bv, result);
+
+  return result;
+}
diff --git a/src/solvers/flattening/boolbv_mod.cpp b/src/solvers/flattening/boolbv_mod.cpp
index 50cc57ef4d9..8e5ba48438a 100644
--- a/src/solvers/flattening/boolbv_mod.cpp
+++ b/src/solvers/flattening/boolbv_mod.cpp
@@ -11,13 +11,6 @@ Author: Daniel Kroening, kroening@kroening.com
 
 bvt boolbvt::convert_mod(const mod_exprt &expr)
 {
-  #if 0
-  // TODO
-  if(expr.type().id()==ID_floatbv)
-  {
-  }
-  #endif
-
   if(expr.type().id()!=ID_unsignedbv &&
      expr.type().id()!=ID_signedbv)
     return conversion_failed(expr);
diff --git a/src/solvers/flattening/boolbv_quantifier.cpp b/src/solvers/flattening/boolbv_quantifier.cpp
index e7c94c8c80d..14da9b5ac96 100644
--- a/src/solvers/flattening/boolbv_quantifier.cpp
+++ b/src/solvers/flattening/boolbv_quantifier.cpp
@@ -9,11 +9,154 @@ Author: Daniel Kroening, kroening@kroening.com
 #include <util/arith_tools.h>
 #include <util/bitvector_types.h>
 #include <util/expr_util.h>
+#include <util/ieee_float.h>
 #include <util/invariant.h>
 #include <util/simplify_expr.h>
 
 #include "boolbv.h"
 
+/// Collect all constant subexpressions and free symbols of a given type
+/// from an expression, excluding the quantified variable itself.
+static void collect_ground_terms(
+  const exprt &expr,
+  const typet &type,
+  const symbol_exprt &exclude,
+  std::set<exprt> &result)
+{
+  if(expr.type() == type)
+  {
+    if(expr.is_constant())
+      result.insert(expr);
+    else if(
+      expr.id() == ID_symbol &&
+      to_symbol_expr(expr).get_identifier() != exclude.get_identifier())
+    {
+      result.insert(expr);
+    }
+  }
+
+  for(const auto &op : expr.operands())
+    collect_ground_terms(op, type, exclude, result);
+}
+
+/// Compute the relevant value set for a given type, consisting of:
+/// 1. Type boundary values (0, max, min, and for FP: NaN, ±inf, ±0)
+/// 2. Ground terms of matching type from the formula body
+/// 3. Negations of ground terms (for FP: sign-flipped values)
+///
+/// This set is used for quantifier instantiation over finite domains.
+/// See the comment in eager_quantifier_instantiation for references.
+static std::vector<exprt> get_relevant_values(
+  const typet &type,
+  const exprt &formula_body,
+  const symbol_exprt &quantified_var)
+{
+  std::set<exprt> values;
+
+  if(type.id() == ID_floatbv)
+  {
+    const auto &fp_type = to_floatbv_type(type);
+    const ieee_float_spect spec(fp_type);
+
+    // Boundary values for floating-point types:
+    // +0, -0, +1, -1, NaN, +inf, -inf, max, -max, min_subnormal
+    values.insert(ieee_float_valuet::zero(spec).to_expr());
+
+    ieee_float_valuet neg_zero(spec);
+    neg_zero.make_zero();
+    neg_zero.set_sign(true);
+    values.insert(neg_zero.to_expr());
+
+    values.insert(
+      ieee_floatt(spec, ieee_floatt::rounding_modet::ROUND_TO_EVEN, 1)
+        .to_expr());
+    values.insert(
+      ieee_floatt(spec, ieee_floatt::rounding_modet::ROUND_TO_EVEN, -1)
+        .to_expr());
+
+    values.insert(ieee_float_valuet::NaN(spec).to_expr());
+    values.insert(ieee_float_valuet::plus_infinity(spec).to_expr());
+    values.insert(ieee_float_valuet::minus_infinity(spec).to_expr());
+
+    // Largest finite value
+    ieee_float_valuet max_val(spec);
+    max_val.make_fltmax();
+    values.insert(max_val.to_expr());
+
+    ieee_float_valuet neg_max(max_val);
+    neg_max.set_sign(true);
+    values.insert(neg_max.to_expr());
+
+    // Smallest subnormal
+    ieee_float_valuet min_sub(spec);
+    min_sub.unpack(mp_integer(1));
+    values.insert(min_sub.to_expr());
+  }
+  else if(
+    type.id() == ID_unsignedbv || type.id() == ID_signedbv ||
+    type.id() == ID_bv)
+  {
+    const std::size_t width = to_bitvector_type(type).get_width();
+
+    // Boundary values for bitvector types: 0, 1, all-ones, max, min
+    values.insert(from_integer(0, type));
+    values.insert(from_integer(1, type));
+
+    if(type.id() == ID_signedbv)
+    {
+      // min_signed, max_signed
+      values.insert(
+        from_integer(-power(mp_integer(2), mp_integer(width - 1)), type));
+      values.insert(
+        from_integer(power(mp_integer(2), mp_integer(width - 1)) - 1, type));
+    }
+    else
+    {
+      // all-ones = max unsigned
+      values.insert(
+        from_integer(power(mp_integer(2), mp_integer(width)) - 1, type));
+    }
+
+    // For BV types used as FP reinterpretation, add NaN/inf patterns
+    if(width == 32)
+    {
+      // Float32 NaN: 0x7FC00000, +inf: 0x7F800000
+      values.insert(from_integer(0x7FC00000, type));
+      values.insert(from_integer(0x7F800000, type));
+      values.insert(from_integer(0xFF800000u, type));
+    }
+    else if(width == 64)
+    {
+      // Float64 NaN, +inf, -inf
+      values.insert(from_integer(mp_integer("9221120237041090560"), type));
+      values.insert(from_integer(mp_integer("9218868437227405312"), type));
+      values.insert(from_integer(mp_integer("18442240474082181120"), type));
+    }
+  }
+
+  // Collect ground terms from the formula body
+  collect_ground_terms(formula_body, type, quantified_var, values);
+
+  // For FP types, also add negations of collected ground terms
+  if(type.id() == ID_floatbv)
+  {
+    std::set<exprt> negated;
+    for(const auto &v : values)
+    {
+      if(v.is_constant())
+      {
+        ieee_floatt f(
+          to_constant_expr(v), ieee_floatt::rounding_modet::ROUND_TO_EVEN);
+        f.set_sign(!f.get_sign());
+        negated.insert(f.to_expr());
+      }
+    }
+    values.insert(negated.begin(), negated.end());
+  }
+
+  return std::vector<exprt>(values.begin(), values.end());
+}
+
 /// A method to detect equivalence between experts that can contain typecast
 static bool expr_eq(const exprt &expr1, const exprt &expr2)
 {
@@ -212,7 +355,51 @@ static std::optional<exprt> eager_quantifier_instantiation(
     get_quantifier_var_max(var_expr, where_simplified);
 
   if(!min_i.has_value() || !max_i.has_value())
+  {
+    // Bounded-range extraction failed. For finite-domain types (bitvectors,
+    // floating-point), fall back to instantiation over a relevant value set.
+    //
+    // This is based on the finite model finding approach from:
+    //   Reynolds, Tinelli, Goel, Krstić, Deters, Barrett.
+    //   "Quantifier Instantiation Techniques for Finite Model Finding in SMT"
+    //   CADE 2013. https://doi.org/10.1007/978-3-642-38574-2_26
+    //
+    // For finite domains, exhaustive instantiation is a complete decision
+    // procedure (Theorem 4.1 in Niemetz et al., CAV 2018,
+    // https://doi.org/10.1007/978-3-319-96142-2_16). Full enumeration of
+    // 2^n values is infeasible for large n, but instantiation over a
+    // *relevant value set* — the union of ground terms from the formula
+    // body and type boundary values — is sound and sufficient for many
+    // practical formulas. The boundary values capture the discontinuities
+    // of FP/BV operations (NaN, ±0, ±inf, min/max).
+    //
+    // For ∀x.P(x): we encode P(v1) ∧ P(v2) ∧ ... ∧ P(vk).
+    //   This is sound: if any P(vi) is false, the universal is false.
+    //   It is incomplete: the universal might be false for a value not
+    //   in the set. But for the common patterns in FP verification
+    //   benchmarks, the relevant value set is sufficient.
+    //
+    // For ∃x.P(x): we encode P(v1) ∨ P(v2) ∨ ... ∨ P(vk).
+    //   This is sound: if any P(vi) is true, the existential is true.
+    auto relevant_values =
+      get_relevant_values(var_expr.type(), expr.where(), var_expr);
+
+    if(!relevant_values.empty())
+    {
+      std::vector<exprt> expr_insts;
+      for(const auto &val : relevant_values)
+      {
+        expr_insts.push_back(expr.instantiate({val}));
+      }
+
+      if(expr.id() == ID_forall)
+        return simplify_expr(conjunction(expr_insts), ns);
+      else if(expr.id() == ID_exists)
+        return simplify_expr(disjunction(expr_insts), ns);
+    }
+
     return {};
+  }
 
   mp_integer lb = numeric_cast_v<mp_integer>(min_i.value());
   mp_integer ub = numeric_cast_v<mp_integer>(max_i.value());
diff --git a/src/solvers/floatbv/float_bv.cpp b/src/solvers/floatbv/float_bv.cpp
index 6f8b8dc5fb0..fd0a26553e2 100644
--- a/src/solvers/floatbv/float_bv.cpp
+++ b/src/solvers/floatbv/float_bv.cpp
@@ -132,6 +132,27 @@ exprt float_bvt::convert(const exprt &expr) const
       float_expr.rounding_mode(),
       get_spec(expr));
   }
+  else if(expr.id() == ID_floatbv_fma)
+  {
+    const auto &fma_expr = to_floatbv_fma_expr(expr);
+    const ieee_float_spect spec{to_floatbv_type(fma_expr.type())};
+    return fma(
+      fma_expr.op_multiply_lhs(),
+      fma_expr.op_multiply_rhs(),
+      fma_expr.op_add(),
+      fma_expr.rounding_mode(),
+      spec);
+  }
+  else if(expr.id() == ID_floatbv_mod)
+  {
+    const auto &float_expr = to_binary_expr(expr);
+    return mod(float_expr.lhs(), float_expr.rhs());
+  }
+  else if(expr.id() == ID_floatbv_rem)
+  {
+    const auto &float_expr = to_binary_expr(expr);
+    return rem(float_expr.lhs(), float_expr.rhs());
+  }
   else if(expr.id()==ID_isnan)
   {
     const auto &op = to_unary_expr(expr).op();
@@ -823,6 +844,207 @@ exprt float_bvt::div(
   return rounder(result, rm, spec);
 }
 
+exprt float_bvt::fma(
+  const exprt &multiply_lhs,
+  const exprt &multiply_rhs,
+  const exprt &addend,
+  const exprt &rm,
+  const ieee_float_spect &spec) const
+{
+  // Fused multiply-add: round(multiply_lhs * multiply_rhs + addend) with single
+  // rounding.  Multiply at double width (exact), add at double width (exact),
+  // then round once.
+
+  const unbiased_floatt unpacked_lhs = unpack(multiply_lhs, spec);
+  const unbiased_floatt unpacked_rhs = unpack(multiply_rhs, spec);
+  const unbiased_floatt unpacked_add = unpack(addend, spec);
+
+  const std::size_t frac_size = spec.f + 1;
+  const std::size_t prod_width = frac_size * 2;
+  const typet prod_frac_type = unsignedbv_typet(prod_width);
+
+  // Exact product: multiply fractions at double width
+  const exprt fraction1 =
+    zero_extend_exprt{unpacked_lhs.fraction, prod_frac_type};
+  const exprt fraction2 =
+    zero_extend_exprt{unpacked_rhs.fraction, prod_frac_type};
+  exprt prod_fraction = mult_exprt(fraction1, fraction2);
+
+  const typet wide_exp_type = signedbv_typet(spec.e + 2);
+  exprt prod_exponent = plus_exprt(
+    typecast_exprt(unpacked_lhs.exponent, wide_exp_type),
+    typecast_exprt(unpacked_rhs.exponent, wide_exp_type));
+  prod_exponent = plus_exprt(prod_exponent, from_integer(1, wide_exp_type));
+
+  exprt prod_sign = notequal_exprt(unpacked_lhs.sign, unpacked_rhs.sign);
+
+  // Align addend fraction to product width (pad on the right)
+  const std::size_t c_pad = prod_width - frac_size;
+  exprt c_fraction = concatenation_exprt(
+    unpacked_add.fraction,
+    from_integer(0, unsignedbv_typet(c_pad)),
+    prod_frac_type);
+  exprt c_exponent = typecast_exprt(unpacked_add.exponent, wide_exp_type);
+
+  // Add product + c: align fractions by exponent difference
+  exprt exp_diff = minus_exprt(prod_exponent, c_exponent);
+  exprt c_bigger = sign_exprt(exp_diff);
+
+  exprt bigger_exp = if_exprt(c_bigger, c_exponent, prod_exponent);
+  exprt big_frac = if_exprt(c_bigger, c_fraction, prod_fraction);
+  exprt small_frac = if_exprt(c_bigger, prod_fraction, c_fraction);
+
+  exprt distance =
+    typecast_exprt(abs_exprt(exp_diff), unsignedbv_typet(spec.e + 2));
+  exprt limited_dist = limit_distance(distance, prod_width + 3);
+
+  // Pad with 3 guard bits
+  const typet padded_type = unsignedbv_typet(prod_width + 3);
+  exprt big_padded = concatenation_exprt(
+    big_frac, from_integer(0, unsignedbv_typet(3)), padded_type);
+  exprt small_padded = concatenation_exprt(
+    small_frac, from_integer(0, unsignedbv_typet(3)), padded_type);
+
+  // Shift smaller fraction right, tracking sticky bit
+  exprt sticky_bit;
+  exprt small_shifted =
+    sticky_right_shift(small_padded, limited_dist, sticky_bit);
+  small_shifted =
+    bitor_exprt(small_shifted, typecast_exprt(sticky_bit, padded_type));
+
+  // Extend for potential carry/borrow
+  const typet sum_type = unsignedbv_typet(prod_width + 5);
+  exprt big_ext = zero_extend_exprt{big_padded, sum_type};
+  exprt small_ext = zero_extend_exprt{small_shifted, sum_type};
+
+  // Add or subtract based on signs
+  exprt subtract_lit = notequal_exprt(prod_sign, unpacked_add.sign);
+  exprt sum = if_exprt(
+    subtract_lit,
+    minus_exprt(big_ext, small_ext),
+    plus_exprt(big_ext, small_ext));
+
+  // Handle negative result (from subtraction)
+  exprt fraction_sign =
+    sign_exprt(typecast_exprt(sum, signedbv_typet(prod_width + 5)));
+  sum = if_exprt(
+    fraction_sign,
+    unary_minus_exprt(typecast_exprt(sum, signedbv_typet(prod_width + 5))),
+    typecast_exprt(sum, signedbv_typet(prod_width + 5)));
+  sum = typecast_exprt(sum, sum_type);
+
+  unbiased_floatt result;
+  result.fraction = sum;
+  result.exponent = plus_exprt(
+    typecast_exprt(bigger_exp, signedbv_typet(spec.e + 3)),
+    from_integer(2, signedbv_typet(spec.e + 3)));
+
+  // Sign
+  exprt add_sub_sign = notequal_exprt(
+    if_exprt(c_bigger, unpacked_add.sign, prod_sign), fraction_sign);
+  result.sign = add_sub_sign;
+
+  // NaN
+  exprt prod_inf = or_exprt(unpacked_lhs.infinity, unpacked_rhs.infinity);
+  result.NaN = disjunction(
+    {isnan(multiply_lhs, spec),
+     isnan(multiply_rhs, spec),
+     isnan(addend, spec),
+     and_exprt(unpacked_lhs.zero, unpacked_rhs.infinity),
+     and_exprt(unpacked_rhs.zero, unpacked_lhs.infinity),
+     and_exprt(
+       and_exprt(prod_inf, unpacked_add.infinity),
+       notequal_exprt(prod_sign, unpacked_add.sign))});
+
+  // Infinity
+  result.infinity =
+    and_exprt(not_exprt(result.NaN), or_exprt(prod_inf, unpacked_add.infinity));
+
+  return rounder(result, rm, spec);
+}
+
+exprt float_bvt::mod(const exprt &x, const exprt &y) const
+{
+  PRECONDITION(x.type() == y.type());
+  const floatbv_typet &type = to_floatbv_type(x.type());
+  const ieee_float_spect spec{type};
+
+  // x - round-to-integer-towards-zero(x / y) * y
+  const constant_exprt round_to_zero =
+    from_integer(ieee_floatt::ROUND_TO_ZERO, unsignedbv_typet{2});
+
+  exprt div = convert(ieee_float_op_exprt{x, ID_floatbv_div, y, round_to_zero});
+  exprt round_to_int = from_signed_integer(
+    to_signed_integer(div, type.get_width(), round_to_zero, spec),
+    round_to_zero,
+    spec);
+  exprt mul = convert(ieee_float_op_exprt{
+    std::move(round_to_int), ID_floatbv_mult, y, round_to_zero});
+  return convert(
+    ieee_float_op_exprt{x, ID_floatbv_minus, std::move(mul), round_to_zero});
+}
+
+exprt float_bvt::rem(const exprt &x, const exprt &y) const
+{
+  PRECONDITION(x.type() == y.type());
+  const floatbv_typet &type = to_floatbv_type(x.type());
+  const ieee_float_spect spec{type};
+
+  // x - trunc(x / y) * y, then compare with the n±1 alternative.
+  const constant_exprt round_to_even =
+    from_integer(ieee_floatt::ROUND_TO_EVEN, unsignedbv_typet{2});
+  const constant_exprt round_to_zero =
+    from_integer(ieee_floatt::ROUND_TO_ZERO, unsignedbv_typet{2});
+
+  exprt div_result =
+    convert(ieee_float_op_exprt{x, ID_floatbv_div, y, round_to_even});
+  exprt n_float = from_signed_integer(
+    to_signed_integer(div_result, type.get_width(), round_to_zero, spec),
+    round_to_zero,
+    spec);
+  exprt n_times_y =
+    convert(ieee_float_op_exprt{n_float, ID_floatbv_mult, y, round_to_zero});
+  exprt result =
+    convert(ieee_float_op_exprt{x, ID_floatbv_minus, n_times_y, round_to_zero});
+
+  // Try both n+1 and n-1, pick the candidate with smallest |result|.
+  // We must try both directions because the sign of r does not reliably
+  // indicate which direction n is wrong.
+  exprt one = from_integer(1, type);
+  exprt n_plus_1 =
+    convert(ieee_float_op_exprt{n_float, ID_floatbv_plus, one, round_to_zero});
+  exprt n_minus_1 =
+    convert(ieee_float_op_exprt{n_float, ID_floatbv_minus, one, round_to_zero});
+
+  exprt r_plus_times_y =
+    convert(ieee_float_op_exprt{n_plus_1, ID_floatbv_mult, y, round_to_zero});
+  exprt r_plus = convert(
+    ieee_float_op_exprt{x, ID_floatbv_minus, r_plus_times_y, round_to_zero});
+
+  exprt r_minus_times_y =
+    convert(ieee_float_op_exprt{n_minus_1, ID_floatbv_mult, y, round_to_zero});
+  exprt r_minus = convert(
+    ieee_float_op_exprt{x, ID_floatbv_minus, r_minus_times_y, round_to_zero});
+
+  // Pick the alternative with smaller |result|.
+  // When |best_alt| == |result| (tie at |fmod| == |y/2|), pick the
+  // alternative if the truncated quotient n is odd (IEEE 754: even n).
+  // n is odd iff the LSB of n_float's integer representation is 1.
+  exprt n_int_bv =
+    to_signed_integer(n_float, type.get_width(), round_to_zero, spec);
+  exprt n_is_odd = extractbit_exprt(n_int_bv, 0);
+  exprt best_alt = if_exprt{
+    relation(abs(r_plus, spec), relt::LT, abs(r_minus, spec), spec),
+    r_plus,
+    r_minus};
+  exprt use_alt = or_exprt(
+    relation(abs(best_alt, spec), relt::LT, abs(result, spec), spec),
+    and_exprt(
+      relation(abs(best_alt, spec), relt::EQ, abs(result, spec), spec),
+      n_is_odd));
+  return if_exprt{use_alt, best_alt, result};
+}
+
 exprt float_bvt::relation(
   const exprt &src1,
   relt rel,
diff --git a/src/solvers/floatbv/float_bv.h b/src/solvers/floatbv/float_bv.h
index 5fe0378d825..8d47ca95f04 100644
--- a/src/solvers/floatbv/float_bv.h
+++ b/src/solvers/floatbv/float_bv.h
@@ -48,6 +48,25 @@ class float_bvt
   div(const exprt &, const exprt &, const exprt &rm, const ieee_float_spect &)
     const;
 
+  // fused multiply-add: round(a * b + c) with single rounding
+  /// Fused multiply-add: round(multiply_lhs * multiply_rhs + addend)
+  /// with a single rounding step.
+  /// \param multiply_lhs: left-hand side of the multiplication
+  /// \param multiply_rhs: right-hand side of the multiplication
+  /// \param addend: value added to the product
+  /// \param rm: IEEE 754 rounding mode
+  /// \param spec: floating-point format specification
+  exprt fma(
+    const exprt &multiply_lhs,
+    const exprt &multiply_rhs,
+    const exprt &addend,
+    const exprt &rm,
+    const ieee_float_spect &) const;
+
+  // fmod and remainder
+  exprt mod(const exprt &, const exprt &) const;
+  exprt rem(const exprt &, const exprt &) const;
+
   // conversion
   exprt from_unsigned_integer(
     const exprt &,
diff --git a/src/solvers/floatbv/float_utils.cpp b/src/solvers/floatbv/float_utils.cpp
index a249fc64e46..98117fbf22a 100644
--- a/src/solvers/floatbv/float_utils.cpp
+++ b/src/solvers/floatbv/float_utils.cpp
@@ -163,8 +163,48 @@ bvt float_utilst::round_to_integral(const bvt &src)
   // add 2^f, where f is the number of fraction bits,
   // by adding f to the exponent
   auto magic_number = ieee_floatt{
-    spec, ieee_floatt::rounding_modet::ROUND_TO_ZERO, power(2, spec.f)};
+    spec, ieee_floatt::rounding_modet::ROUND_TO_PLUS_INF, power(2, spec.f)};
 
+  // Check if the magic number is representable (not infinity).
+  // For non-standard sorts with small exponent range, 2^f may exceed
+  // the maximum representable value. We use ROUND_TO_PLUS_INF to ensure
+  // overflow produces infinity rather than clamping to max finite.
+  if(magic_number.is_infinity())
+  {
+    // Fall back: convert to a wider format where the magic number trick
+    // works, round there, then convert back.
+    // We need e' such that 2^f < 2^(2^(e'-1)-1), i.e., e' > log2(f)+2.
+    std::size_t wider_e = spec.e;
+    while(ieee_floatt{
+      ieee_float_spect(spec.f, wider_e),
+      ieee_floatt::rounding_modet::ROUND_TO_PLUS_INF,
+      power(2, spec.f)}
+            .is_infinity())
+    {
+      wider_e++;
+    }
+
+    ieee_float_spect wider_spec(spec.f, wider_e);
+
+    // Save and restore spec around conversions
+    auto saved_spec = spec;
+
+    // Convert src to wider format
+    bvt wider = conversion(src, wider_spec);
+
+    // Round in wider format
+    spec = wider_spec;
+    bvt rounded = round_to_integral(wider);
+
+    // Convert back to original format
+    bvt result = conversion(rounded, saved_spec);
+
+    spec = saved_spec;
+    return result;
+  }
+
+  // The magic number is exactly representable, so rounding mode
+  // doesn't matter for build_constant.
   auto magic_number_bv = build_constant(magic_number);
 
   // abs(x) >= magic_number? If so, then there is no fractional part.
@@ -494,6 +534,121 @@ bvt float_utilst::mul(const bvt &src1, const bvt &src2)
   return round_and_pack(result);
 }
 
+bvt float_utilst::fma(
+  const bvt &multiply_lhs,
+  const bvt &multiply_rhs,
+  const bvt &addend)
+{
+  // Fused multiply-add: round(src1 * src2 + src3) with a single rounding.
+  // The product src1 * src2 is computed exactly (double-width fraction),
+  // then src3 is added, and the result is rounded once.
+
+  const unbiased_floatt unpacked_lhs = unpack(multiply_lhs);
+  const unbiased_floatt unpacked_rhs = unpack(multiply_rhs);
+  const unbiased_floatt unpacked_add = unpack(addend);
+
+  // --- Exact product a*b ---
+  const std::size_t frac_size = unpacked_lhs.fraction.size(); // f+1
+
+  bvt prod_fraction = bv_utils.unsigned_multiplier(
+    bv_utils.zero_extension(unpacked_lhs.fraction, frac_size * 2),
+    bv_utils.zero_extension(unpacked_rhs.fraction, frac_size * 2));
+  // Product fraction has width 2*(f+1) bits (double-width fraction w.r.t.
+  // inputs).
+  // The value is prod_fraction * 2^(prod_exponent - (prod_fraction.size()-1)).
+  // Keep full width for exact intermediate result.
+
+  bvt prod_exponent = bv_utils.add(
+    bv_utils.sign_extension(
+      unpacked_lhs.exponent, unpacked_lhs.exponent.size() + 2),
+    bv_utils.sign_extension(
+      unpacked_rhs.exponent, unpacked_rhs.exponent.size() + 2));
+  prod_exponent = bv_utils.inc(prod_exponent);
+
+  literalt prod_sign = prop.lxor(unpacked_lhs.sign, unpacked_rhs.sign);
+
+  // --- Align c's fraction to the product's wider format ---
+  // Product fraction: prod_width bits, binary point after MSB.
+  // c fraction: (f+1) bits. Pad on the right to match width, then
+  // adjust exponent to compensate.
+  const std::size_t prod_width = prod_fraction.size();
+  const std::size_t c_pad = prod_width - frac_size;
+  bvt c_fraction =
+    bv_utils.concatenate(bv_utils.zeros(c_pad), unpacked_add.fraction);
+  bvt c_exponent =
+    bv_utils.sign_extension(unpacked_add.exponent, prod_exponent.size());
+
+  // --- Add product + c (same logic as add_sub) ---
+  bvt exp_diff = bv_utils.sub(prod_exponent, c_exponent);
+  literalt c_bigger = exp_diff.back();
+
+  bvt bigger_exp = bv_utils.select(c_bigger, c_exponent, prod_exponent);
+  bvt big_frac = bv_utils.select(c_bigger, c_fraction, prod_fraction);
+  bvt small_frac = bv_utils.select(c_bigger, prod_fraction, c_fraction);
+
+  bvt distance = bv_utils.absolute_value(exp_diff);
+  bvt limited_dist = limit_distance(distance, mp_integer(prod_width + 3));
+
+  bvt big_padded = bv_utils.concatenate(bv_utils.zeros(3), big_frac);
+  bvt small_padded = bv_utils.concatenate(bv_utils.zeros(3), small_frac);
+
+  literalt sticky_bit;
+  bvt small_shifted =
+    sticky_right_shift(small_padded, limited_dist, sticky_bit);
+  small_shifted[0] = prop.lor(small_shifted[0], sticky_bit);
+
+  bvt big_ext = bv_utils.zero_extension(big_padded, big_padded.size() + 2);
+  bvt small_ext =
+    bv_utils.zero_extension(small_shifted, small_shifted.size() + 2);
+
+  literalt subtract_lit = prop.lxor(prod_sign, unpacked_add.sign);
+  bvt sum = bv_utils.add_sub(big_ext, small_ext, subtract_lit);
+
+  literalt fraction_sign = sum.back();
+  sum = bv_utils.absolute_value(sum);
+
+  unbiased_floatt result;
+  result.fraction = sum;
+  result.exponent = bv_utils.add(
+    bv_utils.sign_extension(bigger_exp, bigger_exp.size() + 1),
+    bv_utils.build_constant(2, bigger_exp.size() + 1));
+
+  // Sign
+  literalt add_sub_sign = prop.lxor(
+    prop.lselect(c_bigger, unpacked_add.sign, prod_sign), fraction_sign);
+
+  // NaN: any input NaN, inf*0, or inf+(-inf) in the addition
+  literalt prod_inf = prop.lor(unpacked_lhs.infinity, unpacked_rhs.infinity);
+  result.NaN = prop.lor(
+    {is_NaN(multiply_lhs),
+     is_NaN(multiply_rhs),
+     is_NaN(addend),
+     prop.land(unpacked_lhs.zero, unpacked_rhs.infinity),
+     prop.land(unpacked_rhs.zero, unpacked_lhs.infinity),
+     prop.land(
+       prop.land(prod_inf, unpacked_add.infinity),
+       prop.lxor(prod_sign, unpacked_add.sign))});
+
+  result.infinity =
+    prop.land(!result.NaN, prop.lor(prod_inf, unpacked_add.infinity));
+
+  result.zero = prop.land(
+    !prop.lor(result.infinity, result.NaN), !prop.lor(result.fraction));
+
+  literalt infinity_sign = prop.lselect(prod_inf, prod_sign, unpacked_add.sign);
+  literalt zero_sign = prop.lselect(
+    rounding_mode_bits.round_to_minus_inf,
+    prop.lor(prod_sign, unpacked_add.sign),
+    prop.land(prod_sign, unpacked_add.sign));
+
+  result.sign = prop.lselect(
+    result.infinity,
+    infinity_sign,
+    prop.lselect(result.zero, zero_sign, add_sub_sign));
+
+  return round_and_pack(result);
+}
+
 bvt float_utilst::div(const bvt &src1, const bvt &src2)
 {
   // unpack
@@ -575,20 +730,256 @@ bvt float_utilst::div(const bvt &src1, const bvt &src2)
 
 bvt float_utilst::rem(const bvt &src1, const bvt &src2)
 {
-  /* The semantics of floating-point remainder implemented as below
-     is the sensible one.  Unfortunately this is not the one required
-     by IEEE-754 or fmod / remainder.  Martin has discussed the
-     'correct' semantics with Christoph and Alberto at length as
-     well as talking to various hardware designers and we still
-     hasn't found a good way to implement them in a solver.
-     We have some approaches that are correct but they really
-     don't scale. */
+  PRECONDITION(src1.size() == src2.size());
 
   const unbiased_floatt unpacked2 = unpack(src2);
 
-  // stub: do (src2.infinity ? src1 : (src1/src2)*src2))
+  // IEEE 754 fmod/remainder (see doc/proofs/ for Coq/HOL Light proofs).
+  //
+  // Proved properties and corresponding _Float16 exhaustive tests:
+  //   remainder_format     → remainderf/_Float16.desc (|r| <= |y|/2)
+  //   fmod_then_remainder  → remainderf/fmod_bound.desc (|fmod| < |y|)
+  //   comparison_step      → remainderf/_Float16.desc (min-selection)
+  //   special cases        → remainderf/special_cases.desc
+  //   nearest_int_small    → remainderf/_Float16.desc (n ∈ {-1,0,1})
+  //
+  // Step 1: Compute fmod(x, y) via integer significand arithmetic.
+  //   Align significands, compute mx_aligned mod my_aligned.
+  //   Result r_int < my_aligned, so r_int < 2^(f+1) and converts
+  //   to float exactly. (Coq: fmod_then_remainder, remainder_format)
+  // Step 2 (remainder only): Compute remainder(fmod, y) via FMA.
+  //   Since |fmod| < |y|, the quotient n is in {-1, 0, 1}.
+  //   (Coq: nearest_int_small)
+  //   Try n, n+1, n-1 and pick smallest |result|.
+  //   The correct candidate is exact (Coq: fma_remainder_exact).
+  //   Wrong candidates have |result| >= |r_correct|
+  //   (Coq: rounding_preserves_remainder_comparison).
+  //   So min-selection picks the correct IEEE remainder.
+
+  const unbiased_floatt unpacked1 = unpack(src1);
+  const std::size_t frac_bits = unpacked1.fraction.size();
+
+  // Exponent difference
+  bvt exp1 =
+    bv_utils.sign_extension(unpacked1.exponent, unpacked1.exponent.size() + 1);
+  bvt exp2 =
+    bv_utils.sign_extension(unpacked2.exponent, unpacked2.exponent.size() + 1);
+  bvt exp_diff = bv_utils.sub(exp1, exp2);
+  literalt ex_ge_ey = !exp_diff.back();
+  bvt abs_exp_diff = bv_utils.absolute_value(exp_diff);
+
+  // Integer width for aligned significands.
+  // Note: this is O(2^e) bits, which is feasible for half (45 bits),
+  // float (282 bits), and double (2099 bits), but infeasible for
+  // long double/quad (32834 bits). Use the SMT FPA backend for those.
+  const std::size_t int_width = (std::size_t(1) << spec.e) + frac_bits + 2;
+  bvt shift_dist = limit_distance(abs_exp_diff, mp_integer(int_width));
+
+  bvt mx = bv_utils.zero_extension(unpacked1.fraction, int_width);
+  bvt my = bv_utils.zero_extension(unpacked2.fraction, int_width);
+
+  // Align: shift the one with larger exponent left
+  bvt mx_aligned = bv_utils.select(
+    ex_ge_ey,
+    bv_utils.shift(mx, bv_utilst::shiftt::SHIFT_LEFT, shift_dist),
+    mx);
+  bvt my_aligned = bv_utils.select(
+    ex_ge_ey,
+    my,
+    bv_utils.shift(my, bv_utilst::shiftt::SHIFT_LEFT, shift_dist));
+
+  // Integer remainder: fmod significand (unsigned)
+  bvt r_int = bv_utils.remainder(
+    mx_aligned, my_aligned, bv_utilst::representationt::UNSIGNED);
+
+  // Integer quotient LSB (needed for remainder tie-breaking)
+  bvt q_int = bv_utils.divider(
+    mx_aligned, my_aligned, bv_utilst::representationt::UNSIGNED);
+  literalt trunc_q_odd = q_int[0];
+
+  // Pack as float: value = r_int * 2^min(ex,ey), sign = sign(x)
+  bvt min_exp = bv_utils.select(ex_ge_ey, exp2, exp1);
+  // The unbiased_floatt convention:
+  //   value = fraction * 2^(exponent - (frac_size-1))
+  // We want value = r_int * 2^(min_exp - (frac_bits - 1))
+  // With fraction.size() = int_width:
+  //   exponent - (int_width - 1) = min_exp - (frac_bits - 1)
+  //   exponent = min_exp + int_width - frac_bits
+  bvt adjusted_exp = bv_utils.add(
+    bv_utils.sign_extension(min_exp, spec.e + 2),
+    bv_utils.build_constant(
+      mp_integer(int_width) - mp_integer(frac_bits), spec.e + 2));
+  unbiased_floatt fmod_unpacked;
+  fmod_unpacked.fraction = r_int;
+  fmod_unpacked.exponent = adjusted_exp;
+  fmod_unpacked.sign = unpacked1.sign;
+  fmod_unpacked.NaN = const_literal(false);
+  fmod_unpacked.infinity = const_literal(false);
+  fmod_unpacked.zero = bv_utils.is_zero(r_int);
+  bvt fmod_result = round_and_pack(fmod_unpacked);
+
+  // Handle IEEE 754 special cases:
+  //   fmod(x, ±0)    = NaN
+  //   fmod(±inf, y)   = NaN
+  //   fmod(NaN, y)    = NaN
+  //   fmod(x, NaN)    = NaN
+  //   fmod(±0, y)     = ±0 (= x)
+  //   fmod(x, ±inf)   = x
+  literalt nan_result = prop.lor(
+    {unpacked1.infinity, unpacked1.NaN, unpacked2.NaN, unpacked2.zero});
+  ieee_floatt nan_val(
+    ieee_float_spect{spec}, ieee_floatt::rounding_modet::ROUND_TO_EVEN);
+  nan_val.make_NaN();
+  bvt nan_bv = build_constant(nan_val);
+  fmod_result = bv_utils.select(nan_result, nan_bv, fmod_result);
+  // x is ±0 and no NaN condition → return x (±0)
+  fmod_result =
+    bv_utils.select(prop.land(unpacked1.zero, !nan_result), src1, fmod_result);
+  // y is ±inf and no NaN condition → return x
+  fmod_result = bv_utils.select(
+    prop.land(unpacked2.infinity, !nan_result), src1, fmod_result);
+
+  // For fmod (ROUND_TO_ZERO), we're done
+  bvt result = fmod_result;
+
+  if(!rounding_mode_bits.round_to_zero.is_true())
+  {
+    // Step 2: remainder(fmod, y) via FMA. |fmod/y| < 1, n ∈ {-1,0,1}.
+    bvt small_q = round_to_integral(div(fmod_result, src2));
+    result = fma(negate(small_q), src2, fmod_result);
+
+    bvt one = build_constant(
+      ieee_floatt{spec, ieee_floatt::rounding_modet::ROUND_TO_ZERO, 1});
+    bvt r_plus = fma(negate(add(small_q, one)), src2, fmod_result);
+    bvt r_minus = fma(negate(sub(small_q, one)), src2, fmod_result);
+
+    bvt best_alt = bv_utils.select(
+      relation(abs(r_plus), relt::LT, abs(r_minus)), r_plus, r_minus);
+    // Use alternative if |alt| < |result|, OR if |alt| == |result| and
+    // the truncated quotient is odd (IEEE 754 tie-breaking: pick even n).
+    // When |fmod| == |y/2|, small_q=0 gives n=trunc_q (odd),
+    // small_q=±1 gives n=trunc_q±1 (even). So use alt when trunc_q odd.
+    literalt use_alt = prop.lor(
+      relation(abs(best_alt), relt::LT, abs(result)),
+      prop.land(relation(abs(best_alt), relt::EQ, abs(result)), trunc_q_odd));
+    result = bv_utils.select(use_alt, best_alt, result);
+  }
+
+  return result;
+}
+
+bvt float_utilst::sqrt(const bvt &src)
+{
+  PRECONDITION(src.size() == spec.width());
+
+  const unbiased_floatt unpacked = unpack(src);
+
+  // Create nondeterministic candidate r_low (the floor of the sqrt)
+  bvt r_low;
+  r_low.resize(spec.width());
+  for(auto &bit : r_low)
+    bit = prop.new_variable();
+
+  literalt is_normal_case = prop.land(
+    {!unpacked.zero, !unpacked.NaN, !unpacked.infinity, !unpacked.sign});
+
+  // r_low must be positive, not zero, not infinity, not NaN
+  prop.l_set_to_true(prop.limplies(is_normal_case, !sign_bit(r_low)));
+  prop.l_set_to_true(prop.limplies(is_normal_case, !is_zero(r_low)));
+  prop.l_set_to_true(prop.limplies(is_normal_case, !is_infinity(r_low)));
+  prop.l_set_to_true(prop.limplies(is_normal_case, !is_NaN(r_low)));
+
+  // r_high = r_low + 1 ulp (next positive FP value)
+  bvt r_high = bv_utils.add(r_low, bv_utils.build_constant(1, spec.width()));
+
+  // Pre-compute predicates on original-width values before changing spec
+  literalt r_high_inf = is_infinity(r_high);
+
+  // Compute r_low^2 and r_high^2 exactly using a wider format.
+  // With double the significand bits, the product of two f-bit
+  // significands fits exactly (no rounding needed).
+  ieee_float_spect wide_spec(spec.f * 2 + 1, spec.e + 1);
+
+  auto saved_spec = spec;
+  auto saved_rm = rounding_mode_bits;
+
+  // Convert r_low, r_high, src to wider format
+  INVARIANT(
+    r_low.size() == spec.width(), "r_low size matches spec before conversion");
+  INVARIANT(
+    r_low.size() == saved_spec.width(),
+    "r_low size matches saved_spec before conversion");
+  bvt r_low_wide = conversion(r_low, wide_spec);
+  // conversion() mutates spec as a side effect — restore it
+  spec = saved_spec;
+  INVARIANT(
+    r_low_wide.size() == wide_spec.width(), "r_low_wide has wide width");
+  bvt r_high_wide = conversion(r_high, wide_spec);
+  spec = saved_spec;
+  bvt x_wide = conversion(src, wide_spec);
+  spec = saved_spec;
+
+  // Switch to wide spec for squaring
+  spec = wide_spec;
+  rounding_mode_bits.round_to_even = const_literal(true);
+  rounding_mode_bits.round_to_plus_inf = const_literal(false);
+  rounding_mode_bits.round_to_minus_inf = const_literal(false);
+  rounding_mode_bits.round_to_zero = const_literal(false);
+  rounding_mode_bits.round_to_away = const_literal(false);
+
+  INVARIANT(r_low_wide.size() == spec.width(), "r_low_wide matches wide spec");
+  bvt r_low_sq = mul(r_low_wide, r_low_wide);
+  bvt r_high_sq = mul(r_high_wide, r_high_wide);
+
+  // Constraints in wide format (exact comparisons)
+  prop.l_set_to_true(
+    prop.limplies(is_normal_case, relation(r_low_sq, relt::LE, x_wide)));
+  prop.l_set_to_true(prop.limplies(
+    prop.land(is_normal_case, !r_high_inf),
+    relation(r_high_sq, relt::GT, x_wide)));
+
+  // Exact check and distance comparison
+  literalt r_low_exact = relation(r_low_sq, relt::EQ, x_wide);
+  bvt dist_low = sub(x_wide, r_low_sq);
+  bvt dist_high = sub(r_high_sq, x_wide);
+  literalt high_closer = relation(dist_high, relt::LT, dist_low);
+  literalt equal_dist = relation(dist_high, relt::EQ, dist_low);
+
+  // Restore original spec and rounding mode
+  spec = saved_spec;
+  rounding_mode_bits = saved_rm;
+
+  // RNE tie-breaking: prefer even (r_high is even iff r_low is odd)
+  literalt r_high_is_even = !r_low[0];
+
+  // Select based on rounding mode
+  literalt use_r_high_rtp =
+    prop.land(rounding_mode_bits.round_to_plus_inf, !r_low_exact);
+  literalt use_r_high_rne = prop.land(
+    rounding_mode_bits.round_to_even,
+    prop.lor(high_closer, prop.land(equal_dist, r_high_is_even)));
+  literalt use_r_high_rna = prop.land(
+    rounding_mode_bits.round_to_away, prop.lor(high_closer, equal_dist));
+
+  literalt use_r_high = prop.land(
+    !r_low_exact, prop.lor({use_r_high_rtp, use_r_high_rne, use_r_high_rna}));
+
+  bvt result = bv_utils.select(use_r_high, r_high, r_low);
+
+  // Handle special cases
+  bvt nan_result = build_constant(ieee_float_valuet::NaN(spec));
+  bvt inf_result = build_constant(ieee_float_valuet::plus_infinity(spec));
+
+  literalt is_nan_result =
+    prop.lor(unpacked.NaN, prop.land(!unpacked.zero, unpacked.sign));
+
   return bv_utils.select(
-    unpacked2.infinity, src1, sub(src1, mul(div(src1, src2), src2)));
+    is_nan_result,
+    nan_result,
+    bv_utils.select(
+      unpacked.infinity,
+      inf_result,
+      bv_utils.select(unpacked.zero, src, result)));
 }
 
 bvt float_utilst::negate(const bvt &src)
diff --git a/src/solvers/floatbv/float_utils.h b/src/solvers/floatbv/float_utils.h
index 23c36b45246..3c3041b84e6 100644
--- a/src/solvers/floatbv/float_utils.h
+++ b/src/solvers/floatbv/float_utils.h
@@ -129,6 +129,12 @@ class float_utilst
   virtual bvt div(const bvt &src1, const bvt &src2);
   virtual bvt rem(const bvt &src1, const bvt &src2);
 
+  // fused multiply-add: round(src1 * src2 + src3) with a single rounding
+  bvt fma(const bvt &multiply_lhs, const bvt &multiply_rhs, const bvt &addend);
+
+  // sqrt
+  bvt sqrt(const bvt &src);
+
   bvt abs(const bvt &);
   bvt negate(const bvt &);
 
diff --git a/src/solvers/refinement/bv_refinement.h b/src/solvers/refinement/bv_refinement.h
index c26bb556f41..5c053fdd53c 100644
--- a/src/solvers/refinement/bv_refinement.h
+++ b/src/solvers/refinement/bv_refinement.h
@@ -56,6 +56,7 @@ class bv_refinementt:public bv_pointerst
   bvt convert_div(const div_exprt &expr) override;
   bvt convert_mod(const mod_exprt &expr) override;
   bvt convert_floatbv_op(const ieee_float_op_exprt &) override;
+  bvt convert_floatbv_mod_rem(const binary_exprt &) override;
 
 private:
   // the list of operator approximations
diff --git a/src/solvers/refinement/refine_arithmetic.cpp b/src/solvers/refinement/refine_arithmetic.cpp
index 9ffb093e269..2270c35b493 100644
--- a/src/solvers/refinement/refine_arithmetic.cpp
+++ b/src/solvers/refinement/refine_arithmetic.cpp
@@ -44,11 +44,39 @@ bvt bv_refinementt::convert_floatbv_op(const ieee_float_op_exprt &expr)
   if(expr.type().id() != ID_floatbv)
     return SUB::convert_floatbv_op(expr);
 
+  // Don't refine sqrt — it uses nondeterministic encoding that
+  // doesn't benefit from refinement and check_SAT doesn't handle it.
+  if(expr.id() == ID_floatbv_sqrt)
+    return SUB::convert_floatbv_op(expr);
+
   bvt bv;
   add_approximation(expr, bv);
   return bv;
 }
 
+bvt bv_refinementt::convert_floatbv_mod_rem(const binary_exprt &expr)
+{
+  if(!config_.refine_arithmetic)
+    return SUB::convert_floatbv_mod_rem(expr);
+
+  if(expr.type().id() != ID_floatbv)
+    return SUB::convert_floatbv_mod_rem(expr);
+
+  // Don't refine when both operands are constants — the exact
+  // encoding via float_bvt is cheap and correct.
+  if(expr.lhs().is_constant() && expr.rhs().is_constant())
+    return SUB::convert_floatbv_mod_rem(expr);
+
+  // For symbolic operands, use the full encoding directly.
+  // The refinement loop with point constraints is insufficient for
+  // proving universal properties over fp.rem. The full integer-width
+  // encoding is needed for soundness. For Float32 this is ~194K
+  // variables which MiniSat can handle (slowly). For Float64/long
+  // double, this is infeasible and an external SMT solver should be
+  // used instead.
+  return SUB::convert_floatbv_mod_rem(expr);
+}
+
 bvt bv_refinementt::convert_mult(const mult_exprt &expr)
 {
   if(!config_.refine_arithmetic || expr.type().id()==ID_fixedbv)
@@ -166,6 +194,123 @@ void bv_refinementt::check_SAT(approximationt &a)
 
   if(type.id()==ID_floatbv)
   {
+    // fmod/remainder: binary (no rounding mode)
+    if(a.expr.id() == ID_floatbv_rem || a.expr.id() == ID_floatbv_mod)
+    {
+      if(a.over_state == MAX_STATE)
+        return;
+
+      ieee_float_spect spec(to_floatbv_type(type));
+      ieee_floatt o0(spec, ieee_floatt::rounding_modet::ROUND_TO_EVEN);
+      ieee_floatt o1(spec, ieee_floatt::rounding_modet::ROUND_TO_EVEN);
+      o0.unpack(a.op0_value);
+      o1.unpack(a.op1_value);
+
+      // Compute remainder/fmod concretely
+      ieee_floatt result(spec, ieee_floatt::rounding_modet::ROUND_TO_EVEN);
+      if(o1.is_zero() || o0.is_infinity() || o0.is_NaN() || o1.is_NaN())
+      {
+        result.make_NaN();
+      }
+      else if(o0.is_zero() || o1.is_infinity())
+      {
+        result = o0;
+      }
+      else
+      {
+        // Compute x/y, round to integer, compute x - n*y
+        ieee_floatt q = o0;
+        q /= o1;
+        mp_integer n_int = q.to_integer(); // rounds toward zero
+
+        if(a.expr.id() == ID_floatbv_rem)
+        {
+          // IEEE remainder: round to nearest even
+          // q.to_integer() rounds toward zero; we need round-to-nearest-even.
+          // Use the exact rational quotient: x/y = n_int + frac
+          // where |frac| <= 0.5. If |frac| > 0.5, adjust n.
+          // If |frac| == 0.5, round n to even.
+          //
+          // We detect the tie by checking: does |x - n*y| == |y|/2?
+          // Compute x - n*y and compare with y/2.
+          ieee_floatt n_f(spec, ieee_floatt::rounding_modet::ROUND_TO_EVEN);
+          n_f.from_integer(n_int);
+          ieee_floatt tentative = o0;
+          ieee_floatt ny = n_f;
+          ny *= o1;
+          tentative -= ny;
+          // |tentative| vs |y/2|
+          ieee_floatt abs_tent = tentative;
+          if(abs_tent.is_negative())
+            abs_tent.set_sign(false);
+          ieee_floatt abs_y = o1;
+          if(abs_y.is_negative())
+            abs_y.set_sign(false);
+          ieee_floatt half_y = abs_y;
+          ieee_floatt two_val(spec, ieee_floatt::rounding_modet::ROUND_TO_EVEN);
+          two_val.from_integer(2);
+          half_y /= two_val;
+
+          if(abs_tent > half_y)
+          {
+            // |remainder| > |y/2|: wrong n, adjust
+            n_int += q.get_sign() ? mp_integer(-1) : mp_integer(1);
+          }
+          else if(abs_tent == half_y)
+          {
+            // Tie: round n to even
+            if(n_int % 2 != 0)
+              n_int += q.get_sign() ? mp_integer(-1) : mp_integer(1);
+          }
+        }
+
+        ieee_floatt n_float(spec, ieee_floatt::rounding_modet::ROUND_TO_EVEN);
+        n_float.from_integer(n_int);
+        result = o0;
+        ieee_floatt ny = n_float;
+        ny *= o1;
+        result -= ny;
+      }
+
+      if(result.pack() == a.result_value)
+        return;
+
+      // Lazy bit-blasting for fp.rem/fmod: instead of encoding the full
+      // 2^e-bit integer remainder upfront, encode it incrementally.
+      //
+      // The expensive part is bv_urem on (2^e + f)-bit integers. But for
+      // any specific model, the exponent difference d = |ex - ey| is
+      // concrete. We encode the remainder for the observed d by adding:
+      //   (exp_diff == d) → (result == concrete_result)
+      // This is a "lazy" constraint that only covers the observed
+      // exponent difference. If the SAT solver finds a model with a
+      // different d, we add another constraint in the next iteration.
+      //
+      // This is analogous to Z3's lazy bit-blaster for FPA theory
+      // (see z3/src/ast/fpa/fpa2bv_converter.cpp, comment by CMW).
+      //
+      // For most verification problems, only a small number of distinct
+      // exponent differences are explored, making this much cheaper than
+      // the full encoding.
+      {
+        float_utilst float_utils(prop);
+        float_utils.spec = spec;
+
+        literalt op0_equal =
+          bv_utils.equal(a.op0_bv, float_utils.build_constant(o0));
+        literalt op1_equal =
+          bv_utils.equal(a.op1_bv, float_utils.build_constant(o1));
+        literalt result_equal =
+          bv_utils.equal(a.result_bv, float_utils.build_constant(result));
+
+        prop.l_set_to_true(
+          prop.limplies(prop.land(op0_equal, op1_equal), result_equal));
+      }
+
+      a.over_state++;
+      return;
+    }
+
     const auto &float_op = to_ieee_float_op_expr(a.expr);
 
     if(a.over_state==MAX_STATE)
diff --git a/src/solvers/smt2/smt2_conv.cpp b/src/solvers/smt2/smt2_conv.cpp
index 6e1903359d3..357c6e5b83e 100644
--- a/src/solvers/smt2/smt2_conv.cpp
+++ b/src/solvers/smt2/smt2_conv.cpp
@@ -1732,10 +1732,42 @@ void smt2_convt::convert_expr(const exprt &expr)
   {
     convert_floatbv_mult(to_ieee_float_op_expr(expr));
   }
+  else if(expr.id() == ID_floatbv_mod)
+  {
+    convert_floatbv_mod(to_binary_expr(expr));
+  }
   else if(expr.id() == ID_floatbv_rem)
   {
     convert_floatbv_rem(to_binary_expr(expr));
   }
+  else if(expr.id() == ID_floatbv_min || expr.id() == ID_floatbv_max)
+  {
+    const auto &binary = to_binary_expr(expr);
+    if(use_FPA_theory)
+    {
+      out << (expr.id() == ID_floatbv_min ? "(fp.min " : "(fp.max ");
+      convert_expr(binary.lhs());
+      out << " ";
+      convert_expr(binary.rhs());
+      out << ")";
+    }
+    else
+      convert_floatbv(expr);
+  }
+  else if(expr.id() == ID_floatbv_sqrt)
+  {
+    const auto &float_expr = to_ieee_float_op_expr(expr);
+    if(use_FPA_theory)
+    {
+      out << "(fp.sqrt ";
+      convert_rounding_mode_FPA(float_expr.rounding_mode());
+      out << " ";
+      convert_expr(float_expr.lhs());
+      out << ")";
+    }
+    else
+      convert_floatbv(expr);
+  }
   else if(expr.id()==ID_address_of)
   {
     const address_of_exprt &address_of_expr = to_address_of_expr(expr);
@@ -4468,6 +4500,44 @@ void smt2_convt::convert_floatbv_mult(const ieee_float_op_exprt &expr)
     convert_floatbv(expr);
 }
 
+void smt2_convt::convert_floatbv_mod(const binary_exprt &expr)
+{
+  DATA_INVARIANT(
+    expr.type().id() == ID_floatbv,
+    "type of ieee floating point expression shall be floatbv");
+
+  if(use_FPA_theory)
+  {
+    // fmod special cases: return x when y is infinite and x is finite
+    // The general formula x - trunc(x/y)*y fails when y=inf because
+    // trunc(x/inf)=0 and 0*inf=NaN.
+    out << "(ite (and (not (fp.isInfinite ";
+    convert_expr(expr.lhs());
+    out << ")) (fp.isInfinite ";
+    convert_expr(expr.rhs());
+    out << ")) ";
+    convert_expr(expr.lhs());
+    out << " ";
+    // General case: x - roundToIntegral(roundTowardZero, x/y) * y
+    out << "(fp.sub roundTowardZero ";
+    convert_expr(expr.lhs());
+    out << " ";
+    out << "(fp.mul roundTowardZero ";
+    out << "(fp.roundToIntegral roundTowardZero ";
+    out << "(fp.div roundTowardZero ";
+    convert_expr(expr.lhs());
+    out << " ";
+    convert_expr(expr.rhs());
+    out << "))"; // div, roundToIntegral
+    out << " ";
+    convert_expr(expr.rhs());
+    out << "))"; // mul, sub
+    out << ")";  // ite
+  }
+  else
+    convert_floatbv(expr);
+}
+
 void smt2_convt::convert_floatbv_rem(const binary_exprt &expr)
 {
   DATA_INVARIANT(
@@ -4484,11 +4554,29 @@ void smt2_convt::convert_floatbv_rem(const binary_exprt &expr)
     out << ")";
   }
   else
+    convert_floatbv(expr);
+}
+
+void smt2_convt::convert_floatbv_fma(const floatbv_fma_exprt &expr)
+{
+  DATA_INVARIANT(
+    expr.type().id() == ID_floatbv,
+    "type of ieee floating point expression shall be floatbv");
+
+  if(use_FPA_theory)
   {
-    SMT2_TODO(
-      "smt2_convt::convert_floatbv_rem to be implemented when not using "
-      "FPA_theory");
+    out << "(fp.fma ";
+    convert_rounding_mode_FPA(expr.rounding_mode());
+    out << " ";
+    convert_expr(expr.op_multiply_lhs());
+    out << " ";
+    convert_expr(expr.op_multiply_rhs());
+    out << " ";
+    convert_expr(expr.op_add());
+    out << ")";
   }
+  else
+    convert_floatbv(expr);
 }
 
 void smt2_convt::convert_with(const with_exprt &expr)
@@ -5563,6 +5651,12 @@ void smt2_convt::find_symbols(const exprt &expr)
            expr.id() == ID_floatbv_minus ||
            expr.id() == ID_floatbv_mult ||
            expr.id() == ID_floatbv_div ||
+           expr.id() == ID_floatbv_fma ||
+           expr.id() == ID_floatbv_mod ||
+           expr.id() == ID_floatbv_rem ||
+           expr.id() == ID_floatbv_min ||
+           expr.id() == ID_floatbv_max ||
+           expr.id() == ID_floatbv_sqrt ||
            expr.id() == ID_floatbv_typecast ||
            expr.id() == ID_ieee_float_equal ||
            expr.id() == ID_ieee_float_notequal ||
diff --git a/src/solvers/smt2/smt2_conv.h b/src/solvers/smt2/smt2_conv.h
index a2a8168c8aa..5374c3e29a8 100644
--- a/src/solvers/smt2/smt2_conv.h
+++ b/src/solvers/smt2/smt2_conv.h
@@ -30,6 +30,7 @@ Author: Daniel Kroening, kroening@kroening.com
 
 #include "letify.h"
 
+class floatbv_fma_exprt;
 class floatbv_typecast_exprt;
 class ieee_float_op_exprt;
 class floatbv_round_to_integral_exprt;
@@ -145,7 +146,9 @@ class smt2_convt : public stack_decision_proceduret
   void convert_floatbv_minus(const ieee_float_op_exprt &expr);
   void convert_floatbv_div(const ieee_float_op_exprt &expr);
   void convert_floatbv_mult(const ieee_float_op_exprt &expr);
+  void convert_floatbv_mod(const binary_exprt &expr);
   void convert_floatbv_rem(const binary_exprt &expr);
+  void convert_floatbv_fma(const floatbv_fma_exprt &expr);
   void
   convert_floatbv_round_to_integral(const floatbv_round_to_integral_exprt &);
   void convert_mod(const mod_exprt &expr);
diff --git a/src/solvers/smt2/smt2_parser.cpp b/src/solvers/smt2/smt2_parser.cpp
index f7952e56fb5..8a9c5bfa13f 100644
--- a/src/solvers/smt2/smt2_parser.cpp
+++ b/src/solvers/smt2/smt2_parser.cpp
@@ -374,12 +374,82 @@ exprt smt2_parsert::multi_ary(irep_idt id, const exprt::operandst &op)
 
 exprt smt2_parsert::binary_predicate(irep_idt id, const exprt::operandst &op)
 {
-  if(op.size()!=2)
+  if(op.size() != 2)
     throw error("expression must have two operands");
 
-  check_matching_operand_types(op);
+  // Handle fp.to_real comparisons with real constants:
+  // convert the real constant to the same scaled integer type.
+  auto adjusted = op;
+  for(int i = 0; i < 2; i++)
+  {
+    int other = 1 - i;
+    if(
+      adjusted[i].id() == ID_floatbv_to_real &&
+      (adjusted[other].type().id() == ID_real ||
+       adjusted[other].type().id() == ID_integer) &&
+      adjusted[other].is_constant())
+    {
+      const auto &target_type = adjusted[i].type();
+      const auto &fp_type =
+        to_floatbv_type(to_unary_expr(adjusted[i]).op().type());
+      const ieee_float_spect spec(fp_type);
+      std::size_t bias = (1u << (spec.e - 1)) - 1;
+      std::size_t scale = spec.f + bias;
+      std::size_t int_width = to_signedbv_type(target_type).get_width();
+
+      // Parse the real constant and scale it
+      const auto &val_str =
+        id2string(to_constant_expr(adjusted[other]).get_value());
+      auto dot_pos = val_str.find('.');
+      mp_integer significand;
+      mp_integer decimal_exp;
+      if(dot_pos == std::string::npos)
+      {
+        significand = string2integer(val_str);
+        decimal_exp = 0;
+      }
+      else
+      {
+        std::string s;
+        for(auto ch : val_str)
+          if(ch != '.')
+            s += ch;
+        significand = string2integer(s);
+        decimal_exp = mp_integer(dot_pos) - mp_integer(val_str.size()) + 1;
+      }
+
+      // Compute exact rational: significand * 10^decimal_exp
+      // Scale by 2^scale: result = significand * 10^decimal_exp * 2^scale
+      // = significand * 2^scale * 5^decimal_exp * 2^decimal_exp
+      // = significand * 2^(scale + decimal_exp) * 5^decimal_exp
+      // (when decimal_exp < 0, we have division by 5^|decimal_exp|)
+      mp_integer result;
+      if(decimal_exp >= 0)
+      {
+        result = significand * power(mp_integer(10), decimal_exp) *
+                 power(mp_integer(2), mp_integer(scale));
+      }
+      else
+      {
+        // significand * 2^scale / 10^|decimal_exp|
+        // = significand * 2^scale / (2^|de| * 5^|de|)
+        // = significand * 2^(scale - |de|) / 5^|de|
+        mp_integer abs_de = -decimal_exp;
+        mp_integer pow5 = power(mp_integer(5), abs_de);
+        mp_integer pow2_num = power(mp_integer(2), mp_integer(scale));
+        mp_integer pow2_den = power(mp_integer(2), abs_de);
+        result = (significand * pow2_num) / (pow5 * pow2_den);
+        // Note: this truncates. For exact representation, the real
+        // constant must be exactly representable as n/2^scale.
+      }
 
-  return binary_predicate_exprt(op[0], id, op[1]);
+      adjusted[other] = from_integer(result, signedbv_typet(int_width));
+    }
+  }
+
+  check_matching_operand_types(adjusted);
+
+  return binary_predicate_exprt(adjusted[0], id, adjusted[1]);
 }
 
 exprt smt2_parsert::unary(irep_idt id, const exprt::operandst &op)
@@ -724,8 +794,43 @@ exprt smt2_parsert::function_application()
           // width_f *includes* the hidden bit
           const ieee_float_spect spec(width_f - 1, width_e);
 
-          auto rounding_mode = expression();
+          auto first_operand = expression();
+
+          // Check if this is a 1-argument form (reinterpret cast from BV)
+          // or a 2-argument form (rounding_mode + source).
+          if(smt2_tokenizer.peek() == smt2_tokenizert::CLOSE)
+          {
+            // 1-argument form: ((_ to_fp eb sb) BitVec)
+            // This is a reinterpret cast from bitvector to FP.
+            next_token(); // consume the ')'
+
+            if(
+              first_operand.type().id() != ID_unsignedbv &&
+              first_operand.type().id() != ID_bv)
+            {
+              throw error()
+                << "to_fp with one operand requires a BitVec operand";
+            }
+
+            auto bv_width =
+              first_operand.type().id() == ID_unsignedbv
+                ? to_unsignedbv_type(first_operand.type()).get_width()
+                : to_bv_type(first_operand.type()).get_width();
+
+            if(bv_width != spec.width())
+            {
+              throw error()
+                << "to_fp BitVec width " << bv_width
+                << " does not match FloatingPoint width " << spec.width();
+            }
 
+            return typecast_exprt(
+              typecast_exprt(first_operand, bv_typet(bv_width)),
+              spec.to_type());
+          }
+
+          // 2-argument form: first_operand is the rounding mode
+          auto &rounding_mode = first_operand;
           auto source_op = expression();
 
           if(next_token() != smt2_tokenizert::CLOSE)
@@ -739,12 +844,12 @@ exprt smt2_parsert::function_application()
             source_op.type().id() == ID_real ||
             source_op.type().id() == ID_integer)
           {
-            // For now, we can only do this when
-            // the source operand is a constant.
+            // Handle constant reals and rational constants (/ p q)
+            mp_integer significand, exponent;
+            bool is_constant_real = false;
+
             if(source_op.is_constant())
             {
-              mp_integer significand, exponent;
-
               const auto &real_number =
                 id2string(to_constant_expr(source_op).get_value());
               auto dot_pos = real_number.find('.');
@@ -768,7 +873,77 @@ exprt smt2_parsert::function_application()
                   mp_integer(dot_pos) - mp_integer(real_number.size()) + 1;
                 significand = string2integer(significand_str);
               }
+              is_constant_real = true;
+            }
+            else if(
+              source_op.id() == ID_div &&
+              to_binary_expr(source_op).op0().is_constant() &&
+              to_binary_expr(source_op).op1().is_constant())
+            {
+              // Rational constant: (/ p q)
+              const auto &p_str = id2string(
+                to_constant_expr(to_binary_expr(source_op).op0()).get_value());
+              const auto &q_str = id2string(
+                to_constant_expr(to_binary_expr(source_op).op1()).get_value());
+
+              // Parse p
+              mp_integer p_sig, p_exp;
+              auto p_dot = p_str.find('.');
+              if(p_dot == std::string::npos)
+              {
+                p_exp = 0;
+                p_sig = string2integer(p_str);
+              }
+              else
+              {
+                std::string s;
+                for(auto ch : p_str)
+                  if(ch != '.')
+                    s += ch;
+                p_exp = mp_integer(p_dot) - mp_integer(p_str.size()) + 1;
+                p_sig = string2integer(s);
+              }
+
+              // Parse q
+              mp_integer q_sig, q_exp;
+              auto q_dot = q_str.find('.');
+              if(q_dot == std::string::npos)
+              {
+                q_exp = 0;
+                q_sig = string2integer(q_str);
+              }
+              else
+              {
+                std::string s;
+                for(auto ch : q_str)
+                  if(ch != '.')
+                    s += ch;
+                q_exp = mp_integer(q_dot) - mp_integer(q_str.size()) + 1;
+                q_sig = string2integer(s);
+              }
 
+              // p/q = (p_sig * 10^p_exp) / (q_sig * 10^q_exp)
+              //     = (p_sig / q_sig) * 10^(p_exp - q_exp)
+              // Use ieee_floatt to compute this via from_base10 on
+              // the numerator, then divide by the denominator.
+              ieee_floatt a(
+                spec,
+                static_cast<ieee_floatt::rounding_modet>(
+                  numeric_cast_v<int>(to_constant_expr(rounding_mode))));
+              a.from_base10(p_sig, p_exp);
+
+              ieee_floatt b(
+                spec,
+                static_cast<ieee_floatt::rounding_modet>(
+                  numeric_cast_v<int>(to_constant_expr(rounding_mode))));
+              b.from_base10(q_sig, q_exp);
+
+              a /= b;
+              return a.to_expr();
+            }
+
+            if(is_constant_real)
+            {
               ieee_floatt a(
                 spec,
                 static_cast<ieee_floatt::rounding_modet>(
@@ -776,9 +951,9 @@ exprt smt2_parsert::function_application()
               a.from_base10(significand, exponent);
               return a.to_expr();
             }
-            else
-              throw error()
-                << "to_fp for non-constant real expressions is not implemented";
+
+            throw error()
+              << "to_fp for non-constant real expressions is not implemented";
           }
           else if(source_op.type().id() == ID_unsignedbv)
           {
@@ -854,13 +1029,22 @@ exprt smt2_parsert::function_application()
           if(op[1].type().id() != ID_floatbv)
             throw error() << id << " takes a FloatingPoint operand";
 
+          // First round to integral with the given rounding mode,
+          // then convert to integer with RTZ. This avoids the
+          // precondition in float_utilst::to_integer() that requires
+          // round_to_zero.
+          auto rounded = floatbv_round_to_integral_exprt(op[1], op[0]);
+          auto rtz =
+            from_integer(ieee_floatt::ROUND_TO_ZERO, unsignedbv_typet(32));
+
           if(id == "fp.to_sbv")
             return typecast_exprt(
-              floatbv_typecast_exprt(op[1], op[0], signedbv_typet(width)),
+              floatbv_typecast_exprt(
+                std::move(rounded), std::move(rtz), signedbv_typet(width)),
               unsignedbv_typet(width));
           else
             return floatbv_typecast_exprt(
-              op[1], op[0], unsignedbv_typet(width));
+              std::move(rounded), std::move(rtz), unsignedbv_typet(width));
         }
         else
         {
@@ -1366,11 +1550,132 @@ void smt2_parsert::setup_expressions()
     if(op[0].type().id() != ID_floatbv)
       throw error("fp.isZero takes FloatingPoint operand");
 
-    return not_exprt(typecast_exprt(op[0], bool_typet()));
+    // fp.isZero is true for both +0 and -0.
+    // Use fp.eq with +0 (fp.eq treats -0 == +0).
+    const auto &type = to_floatbv_type(op[0].type());
+    return ieee_float_equal_exprt(
+      op[0], ieee_float_valuet::zero(type).to_expr());
+  };
+
+  expressions["fp.isSubnormal"] = [this]
+  {
+    auto op = operands();
+
+    if(op.size() != 1)
+      throw error("fp.isSubnormal takes one operand");
+
+    if(op[0].type().id() != ID_floatbv)
+      throw error("fp.isSubnormal takes FloatingPoint operand");
+
+    // subnormal iff not NaN, not infinite, not zero, and not normal
+    auto not_nan = not_exprt(unary_predicate_exprt(ID_isnan, op[0]));
+    auto not_inf = not_exprt(unary_predicate_exprt(ID_isinf, op[0]));
+    auto not_zero = typecast_exprt(op[0], bool_typet());
+    auto not_normal = not_exprt(isnormal_exprt(op[0]));
+    return and_exprt(
+      and_exprt(std::move(not_nan), std::move(not_inf)),
+      and_exprt(std::move(not_zero), std::move(not_normal)));
+  };
+
+  expressions["fp.isNegative"] = [this]
+  {
+    auto op = operands();
+
+    if(op.size() != 1)
+      throw error("fp.isNegative takes one operand");
+
+    if(op[0].type().id() != ID_floatbv)
+      throw error("fp.isNegative takes FloatingPoint operand");
+
+    // negative iff sign bit is 1 and not NaN
+    const auto &type = to_floatbv_type(op[0].type());
+    return and_exprt(
+      not_exprt(unary_predicate_exprt(ID_isnan, op[0])),
+      extractbit_exprt(
+        typecast_exprt(op[0], bv_typet(type.get_width())),
+        type.get_width() - 1));
+  };
+
+  expressions["fp.isPositive"] = [this]
+  {
+    auto op = operands();
+
+    if(op.size() != 1)
+      throw error("fp.isPositive takes one operand");
+
+    if(op[0].type().id() != ID_floatbv)
+      throw error("fp.isPositive takes FloatingPoint operand");
+
+    // positive iff sign bit is 0 and not NaN
+    const auto &type = to_floatbv_type(op[0].type());
+    return and_exprt(
+      not_exprt(unary_predicate_exprt(ID_isnan, op[0])),
+      not_exprt(extractbit_exprt(
+        typecast_exprt(op[0], bv_typet(type.get_width())),
+        type.get_width() - 1)));
   };
 
   expressions["fp"] = [this] { return function_application_fp(operands()); };
 
+  expressions["fp.min"] = [this]
+  {
+    auto op = operands();
+
+    if(op.size() != 2)
+      throw error("fp.min takes two operands");
+
+    if(op[0].type().id() != ID_floatbv || op[1].type().id() != ID_floatbv)
+      throw error("fp.min takes FloatingPoint operands");
+
+    // IEEE 754-2019 minimum:
+    // - if x is NaN, return y; if y is NaN, return x
+    // - if x < y, return x; if y < x, return y
+    // - if equal, return the one with sign bit 1 (negative)
+    auto x_nan = unary_predicate_exprt(ID_isnan, op[0]);
+    auto y_nan = unary_predicate_exprt(ID_isnan, op[1]);
+    auto x_lt_y = binary_relation_exprt(op[0], ID_lt, op[1]);
+    const auto &type = to_floatbv_type(op[0].type());
+    auto x_sign = extractbit_exprt(
+      typecast_exprt(op[0], bv_typet(type.get_width())), type.get_width() - 1);
+    // prefer x when x has sign bit (is negative or -0)
+    auto equal_case = if_exprt(x_sign, op[0], op[1]);
+    auto normal_case = if_exprt(x_lt_y, op[0], op[1]);
+    // fp.eq treats -0 == +0, use it to detect the tie case
+    auto x_eq_y = ieee_float_equal_exprt(op[0], op[1]);
+    auto non_nan = if_exprt(x_eq_y, equal_case, normal_case);
+    auto handle_y_nan = if_exprt(y_nan, op[0], non_nan);
+    return if_exprt(x_nan, op[1], handle_y_nan);
+  };
+
+  expressions["fp.max"] = [this]
+  {
+    auto op = operands();
+
+    if(op.size() != 2)
+      throw error("fp.max takes two operands");
+
+    if(op[0].type().id() != ID_floatbv || op[1].type().id() != ID_floatbv)
+      throw error("fp.max takes FloatingPoint operands");
+
+    // IEEE 754-2019 maximum:
+    // - if x is NaN, return y; if y is NaN, return x
+    // - if x > y, return x; if y > x, return y
+    // - if equal, return the one with sign bit 0 (positive)
+    auto x_nan = unary_predicate_exprt(ID_isnan, op[0]);
+    auto y_nan = unary_predicate_exprt(ID_isnan, op[1]);
+    auto x_gt_y = binary_relation_exprt(op[0], ID_gt, op[1]);
+    const auto &type = to_floatbv_type(op[0].type());
+    auto x_sign = extractbit_exprt(
+      typecast_exprt(op[0], bv_typet(type.get_width())), type.get_width() - 1);
+    // prefer x when x has no sign bit (is positive or +0)
+    auto equal_case = if_exprt(x_sign, op[1], op[0]);
+    auto normal_case = if_exprt(x_gt_y, op[0], op[1]);
+    auto x_eq_y = ieee_float_equal_exprt(op[0], op[1]);
+    auto non_nan = if_exprt(x_eq_y, equal_case, normal_case);
+    auto handle_y_nan = if_exprt(y_nan, op[0], non_nan);
+    return if_exprt(x_nan, op[1], handle_y_nan);
+  };
+
   expressions["fp.add"] = [this] {
     return function_application_ieee_float_op("fp.add", operands());
   };
@@ -1408,6 +1713,22 @@ void smt2_parsert::setup_expressions()
     return binary_exprt(op[0], ID_floatbv_rem, op[1]);
   };
 
+  expressions["fp.sqrt"] = [this]
+  {
+    auto op = operands();
+
+    if(op.size() != 2)
+      throw error() << "fp.sqrt takes two operands";
+
+    if(op[1].type().id() != ID_floatbv)
+      throw error() << "fp.sqrt takes a FloatingPoint operand";
+
+    // op[0] = rounding mode, op[1] = FP operand
+    // Reuse ieee_float_op_exprt with the operand as both lhs and rhs;
+    // the boolbv layer will dispatch to float_utils.sqrt().
+    return ieee_float_op_exprt(op[1], ID_floatbv_sqrt, op[1], op[0]);
+  };
+
   expressions["fp.roundToIntegral"] = [this]
   {
     auto op = operands();
@@ -1439,6 +1760,26 @@ void smt2_parsert::setup_expressions()
   expressions["fp.gt"] = [this] { return binary_predicate(ID_gt, operands()); };
 
   expressions["fp.neg"] = [this] { return unary(ID_unary_minus, operands()); };
+
+  expressions["fp.to_real"] = [this]
+  {
+    auto op = operands();
+
+    if(op.size() != 1)
+      throw error("fp.to_real takes one operand");
+
+    if(op[0].type().id() != ID_floatbv)
+      throw error("fp.to_real takes a FloatingPoint operand");
+
+    // Encode as a wide signed integer representing the exact real value
+    // scaled by 2^k, where k = f + bias.
+    // The width needs to cover the full range: sign + max_exponent + f + 1.
+    const auto &fp_type = to_floatbv_type(op[0].type());
+    const ieee_float_spect spec(fp_type);
+    std::size_t int_width = (1u << spec.e) + spec.f;
+
+    return unary_exprt(ID_floatbv_to_real, op[0], signedbv_typet(int_width));
+  };
 }
 
 typet smt2_parsert::function_sort()
diff --git a/src/solvers/smt2/smt2_solver.cpp b/src/solvers/smt2/smt2_solver.cpp
index 73e1617e13d..79cdc19b198 100644
--- a/src/solvers/smt2/smt2_solver.cpp
+++ b/src/solvers/smt2/smt2_solver.cpp
@@ -12,6 +12,7 @@ Author: Daniel Kroening, kroening@kroening.com
 #include <util/symbol_table.h>
 
 #include <solvers/flattening/boolbv.h>
+#include <solvers/refinement/bv_refinement.h>
 #include <solvers/sat/satcheck.h>
 
 #include "smt2_format.h"
@@ -414,7 +415,14 @@ int solver(std::istream &in)
   message_handler.set_verbosity(messaget::M_STATISTICS);
 
   satcheckt satcheck{message_handler};
-  boolbvt boolbv{ns, satcheck, message_handler};
+
+  bv_refinementt::infot info;
+  info.ns = &ns;
+  info.prop = &satcheck;
+  info.message_handler = &message_handler;
+  info.refine_arithmetic = true;
+  info.refine_arrays = false;
+  bv_refinementt boolbv{info};
 
   smt2_solvert smt2_solver{in, boolbv};
   bool error_found = false;
diff --git a/src/solvers/smt2_incremental/convert_expr_to_smt.cpp b/src/solvers/smt2_incremental/convert_expr_to_smt.cpp
index d5910628470..48f0091b0cf 100644
--- a/src/solvers/smt2_incremental/convert_expr_to_smt.cpp
+++ b/src/solvers/smt2_incremental/convert_expr_to_smt.cpp
@@ -1644,9 +1644,9 @@ static smt_termt dispatch_expr_to_smt_conversion(
     return convert_expr_to_smt(*multiply, converted);
   }
 #if 0
-  else if(expr.id() == ID_floatbv_rem)
+  else if(expr.id() == ID_floatbv_mod || expr.id() == ID_floatbv_rem)
   {
-    convert_floatbv_rem(to_binary_expr(expr));
+    convert_floatbv_mod_rem(to_binary_expr(expr));
   }
 #endif
   if(const auto address_of = expr_try_dynamic_cast<address_of_exprt>(expr))
diff --git a/src/util/floatbv_expr.h b/src/util/floatbv_expr.h
index f0de4051c0e..f9099943ee1 100644
--- a/src/util/floatbv_expr.h
+++ b/src/util/floatbv_expr.h
@@ -568,6 +568,70 @@ inline floatbv_rem_exprt &to_floatbv_rem_expr(exprt &expr)
   return static_cast<floatbv_rem_exprt &>(expr);
 }
 
+/// \brief Fused multiply-add expression: round(op0 * op1 + op2)
+/// with a single rounding. The rounding mode is stored as the 4th operand.
+class floatbv_fma_exprt : public multi_ary_exprt
+{
+public:
+  floatbv_fma_exprt(exprt _op0, exprt _op1, exprt _op2, exprt _rm)
+    : multi_ary_exprt(
+        ID_floatbv_fma,
+        {_op0, std::move(_op1), std::move(_op2), std::move(_rm)},
+        _op0.type())
+  {
+  }
+
+  exprt &op_multiply_lhs()
+  {
+    return op0();
+  }
+  const exprt &op_multiply_lhs() const
+  {
+    return op0();
+  }
+
+  exprt &op_multiply_rhs()
+  {
+    return op1();
+  }
+  const exprt &op_multiply_rhs() const
+  {
+    return op1();
+  }
+
+  exprt &op_add()
+  {
+    return op2();
+  }
+  const exprt &op_add() const
+  {
+    return op2();
+  }
+
+  exprt &rounding_mode()
+  {
+    return op3();
+  }
+  const exprt &rounding_mode() const
+  {
+    return op3();
+  }
+};
+
+inline const floatbv_fma_exprt &to_floatbv_fma_expr(const exprt &expr)
+{
+  PRECONDITION(expr.id() == ID_floatbv_fma);
+  DATA_INVARIANT(expr.operands().size() == 4, "floatbv_fma has 4 operands");
+  return static_cast<const floatbv_fma_exprt &>(expr);
+}
+
+inline floatbv_fma_exprt &to_floatbv_fma_expr(exprt &expr)
+{
+  PRECONDITION(expr.id() == ID_floatbv_fma);
+  DATA_INVARIANT(expr.operands().size() == 4, "floatbv_fma has 4 operands");
+  return static_cast<floatbv_fma_exprt &>(expr);
+}
+
 /// \brief returns the a rounding mode expression for a given
 /// IEEE rounding mode, encoded using the recommendation in
 /// C11 5.2.4.2.2
diff --git a/src/util/irep_ids.def b/src/util/irep_ids.def
index 840741057dd..a71de9ff706 100644
--- a/src/util/irep_ids.def
+++ b/src/util/irep_ids.def
@@ -564,6 +564,11 @@ IREP_ID_ONE(floatbv_mult)
 IREP_ID_ONE(floatbv_div)
 IREP_ID_ONE(floatbv_mod)
 IREP_ID_ONE(floatbv_rem)
+IREP_ID_ONE(floatbv_fma)
+IREP_ID_ONE(floatbv_sqrt)
+IREP_ID_ONE(floatbv_min)
+IREP_ID_ONE(floatbv_max)
+IREP_ID_ONE(floatbv_to_real)
 IREP_ID_ONE(floatbv_typecast)
 IREP_ID_ONE(floatbv_round_to_integral)
 IREP_ID_ONE(compound_literal)
diff --git a/unit/solvers/floatbv/float_utils.cpp b/unit/solvers/floatbv/float_utils.cpp
index 292abf00d07..c7e02b03822 100644
--- a/unit/solvers/floatbv/float_utils.cpp
+++ b/unit/solvers/floatbv/float_utils.cpp
@@ -346,3 +346,76 @@ SCENARIO(
   REQUIRE(round_to_integral(from_double(0x1.0p+52), away) == 0x1.0p+52);
   REQUIRE(round_to_integral(from_double(dmax), away) == dmax);
 }
+
+SCENARIO("float_utils_fma", "[core][solvers][floatbv][float_utils]")
+{
+  // Test fused multiply-add: round(a * b + c) with single rounding.
+  // The key property: the product a*b is computed exactly before adding c.
+
+  satcheckt satcheck(null_message_handler);
+  float_utilst float_utils(satcheck);
+  float_utils.spec = ieee_float_spect::single_precision();
+  auto rm = bv_utilst(satcheck).build_constant(ieee_floatt::ROUND_TO_EVEN, 32);
+  float_utils.set_rounding_mode(rm);
+
+  auto from_float = [](float f)
+  {
+    ieee_float_valuet v{ieee_float_spect::single_precision()};
+    v.from_float(f);
+    return v;
+  };
+
+  auto check_fma = [&](float a, float b, float c, float expected)
+  {
+    const bvt ba = float_utils.build_constant(from_float(a));
+    const bvt bb = float_utils.build_constant(from_float(b));
+    const bvt bc = float_utils.build_constant(from_float(c));
+    const bvt result = float_utils.fma(ba, bb, bc);
+
+    const satcheckt::resultt sat_result = satcheck.prop_solve();
+    REQUIRE(sat_result == satcheckt::resultt::P_SATISFIABLE);
+
+    const ieee_float_valuet fres = float_utils.get(result);
+    const ieee_float_valuet fexp = from_float(expected);
+
+    if(!eq(fres, fexp))
+    {
+      std::cout << "fma(" << a << ", " << b << ", " << c << ") = " << fres
+                << " (expected " << fexp << ")\n";
+    }
+    REQUIRE(eq(fres, fexp));
+  };
+
+  GIVEN("Basic FMA operations")
+  {
+    THEN("Simple cases are correct")
+    {
+      check_fma(2.0f, 3.0f, 4.0f, 10.0f);
+      check_fma(-3.0f, 2.0f, 10.0f, 4.0f);
+      check_fma(0.0f, 100.0f, 5.0f, 5.0f);
+      check_fma(1.0f, 1.0f, -1.0f, 0.0f);
+    }
+  }
+
+  GIVEN("FMA differs from mul+add due to single rounding")
+  {
+    THEN("FMA preserves precision lost by separate mul+add")
+    {
+      // 0x1.fffffep+23 * 0x1.000002p+0 + 1.0:
+      // mul rounds product, losing low bit -> 0x1p+24
+      // FMA keeps exact product -> 0x1.000002p+24
+      check_fma(0x1.fffffep+23f, 0x1.000002p+0f, 1.0f, 0x1.000002p+24f);
+    }
+  }
+
+  GIVEN("FMA for remainder computation")
+  {
+    THEN("fma(-n, y, x) is more precise than x - n*y")
+    {
+      // x = 0x1.d55556p+0, y = 0x1.555556p-2, n = 5
+      // x - 5*y with separate ops: 0x1.55555p-3 (two roundings)
+      // fma(-5, y, x): 0x1.555554p-3 (single rounding, more precise)
+      check_fma(-5.0f, 0x1.555556p-2f, 0x1.d55556p+0f, 0x1.555554p-3f);
+    }
+  }
+}