[API Coherence] Report for 2026-03-12 - BitVector, Array, and Floating-Point APIs

[github-actions[bot]]

Summary

Metric	Value
API families analyzed this run	3 (BitVector, Array, Floating-Point)
Total API families analyzed (cumulative)	5
Total C API functions checked	~70
Languages covered	Java, .NET, C++, Python, TypeScript, OCaml, Go, Rust
Previously cached issues resolved	8
New inconsistencies found	9
Ongoing issues from prior runs	2

---

✅ Resolution Updates — 8 Cached Issues Now Resolved

Since the last run (2026-02-24), the following gaps have been closed:

Issue	Resolution
TypeScript Optimize missing getLower()/getUpper()	✅ Implemented in src/api/js/src/high-level/high-level.ts
TypeScript Optimize missing fromFile(), unsatCore(), objectives(), reasonUnknown()	✅ All four now present in high-level.ts
Z3_solver_to_dimacs_string missing in Java, TypeScript, Go	✅ All three now have it (Solver.java, high-level.ts, solver.go)
Z3_solver_translate missing in TypeScript, Go, Rust	✅ TypeScript has solver.translate(), Go has it, Rust implements the Translate trait
Z3_solver_get_proof missing in TypeScript, Go	✅ Both now exposed
Z3_solver_add_simplifier missing in Java	✅ Solver.addSimplifier() now in Solver.java
Z3_solver_register_on_clause missing in TypeScript, Java, OCaml, Go	✅ All now implemented
Z3_optimize_translate missing in OCaml, Go	✅ OCaml z3.ml and Go optimize.go both expose it

---

📊 Progress

• APIs analyzed so far: ~5 of ~20 API families (~25%)
• This run: BitVector operations, Array theory APIs, Floating-Point (FPA) APIs
• Next run: Quantifier APIs, Fixedpoint APIs, Tactic/Goal APIs, Arithmetic APIs, Sequence/String APIs

---

🔴 High Priority Issues

1. Java (and Go) Missing BV Reduction Operations: bvredand / bvredor

What: Z3_mk_bvredand and Z3_mk_bvredor reduce a bit-vector to a single-bit result by AND-ing or OR-ing all bits. These are useful for checking if all/any bits are set.

Available in: Python (z3.py), C++ (z3++.h — bvredand()/bvredor()), .NET (Context.cs), OCaml (z3.ml — mk_redand/mk_redor), TypeScript (high-level.ts — redAnd()/redOr()), Rust (bv.rs macro — bvredand/bvredor)

Missing in: Java, Go

Suggested fix:

• Java: Add mkBVREDAND(BitVecExpr t) and mkBVREDOR(BitVecExpr t) to src/api/java/Context.java calling Native.mkBvredand/Native.mkBvredor
• Go: Add MkBVRedAnd(t *Expr) *Expr and MkBVRedOr(t *Expr) *Expr to src/api/go/bitvec.go calling C.Z3_mk_bvredand/C.Z3_mk_bvredor

---

2. Go FPA Missing Rounding Mode Constants

What: To use any FP arithmetic in Go with explicit rounding (e.g., MkFPAdd(rm, lhs, rhs)), callers must pass a rounding mode expression. However, Go provides no way to create rounding mode values — Z3_mk_fpa_rne, Z3_mk_fpa_rna, Z3_mk_fpa_rtp, Z3_mk_fpa_rtn, Z3_mk_fpa_rtz (and their verbose aliases) are all absent. This makes the FP operations that require rounding mode (MkFPAdd, MkFPSub, MkFPMul, MkFPDiv, MkFPSqrt) effectively unusable unless users build the expression themselves via the C API.

Available in: All other languages — Python (fpRNE(), fpRTZ(), etc.), Java (mkFPRoundNearestTiesToEven()), .NET (MkFPRNE()), C++ (fpa_rne() in z3++.h), OCaml, TypeScript, Rust

Missing in: Go (src/api/go/fp.go)

Suggested fix: Add rounding mode constructor functions to src/api/go/fp.go:

func (c *Context) MkFPRNE() *Expr { return newExpr(c, C.Z3_mk_fpa_rne(c.ptr)) }
func (c *Context) MkFPRNA() *Expr { return newExpr(c, C.Z3_mk_fpa_rna(c.ptr)) }
func (c *Context) MkFPRTP() *Expr { return newExpr(c, C.Z3_mk_fpa_rtp(c.ptr)) }
func (c *Context) MkFPRTN() *Expr { return newExpr(c, C.Z3_mk_fpa_rtn(c.ptr)) }
func (c *Context) MkFPRTZ() *Expr { return newExpr(c, C.Z3_mk_fpa_rtz(c.ptr)) }

---

3. Go FPA Missing Type Conversion Functions

What: Go's fp.go has no way to convert between floating-point representations or to/from BV types. The following C API functions are entirely absent:

C API Function	Purpose
Z3_mk_fpa_to_fp_bv	BV (IEEE bits) → FP
Z3_mk_fpa_to_fp_float	FP → FP (different precision, with rounding)
Z3_mk_fpa_to_fp_real	Real → FP (with rounding)
Z3_mk_fpa_to_fp_signed	Signed BV → FP (with rounding)
Z3_mk_fpa_to_fp_unsigned	Unsigned BV → FP (with rounding)
Z3_mk_fpa_to_sbv	FP → Signed BV (with rounding)
Z3_mk_fpa_to_ubv	FP → Unsigned BV (with rounding)
Z3_mk_fpa_fp	Construct FP from sign + exponent + mantissa BVs

Available in: Python, Java, .NET, C++, OCaml, TypeScript, Rust

Missing in: Go

Suggested fix: Add the above wrappers to src/api/go/fp.go. Example:

func (c *Context) MkFPToFPBV(bv *Expr, sort *Sort) *Expr {
    return newExpr(c, C.Z3_mk_fpa_to_fp_bv(c.ptr, bv.ptr, sort.ptr))
}
func (c *Context) MkFPToSBV(rm, fp *Expr, size uint) *Expr {
    return newExpr(c, C.Z3_mk_fpa_to_sbv(c.ptr, rm.ptr, fp.ptr, C.uint(size)))
}

---

🟡 Medium Priority Issues

4. C++ and Go Missing Variable-Width BV Rotation (ext_rotate_left/ext_rotate_right)

What: Z3_mk_ext_rotate_left(ctx, t, i) and Z3_mk_ext_rotate_right(ctx, t, i) rotate a bit-vector by an amount given as a bit-vector expression (symbolic amount), as opposed to the fixed-integer versions Z3_mk_rotate_left/right. The fixed versions are available everywhere; the variable-width versions are missing in C++ and Go.

Available in: Java (mkExtRotateLeft), .NET (MkBVRotateLeft with two BV args), Python (RotateLeft(a, b) — dispatches to ext_rotate when b is symbolic), OCaml (mk_ext_rotate_left), TypeScript (rotateLeft(count: BitVec)), Rust (bvrotl/bvrotr via Z3_mk_ext_rotate_left)

Missing in: C++ (z3++.h only has rotate_left(unsigned i)), Go (bitvec.go only has MkBVRotateLeft(i uint, t))

Suggested fix:

• C++: Add to z3++.h inside expr:
  expr ext_rotate_left(expr const& i) const { ... Z3_mk_ext_rotate_left(ctx(), *this, i) ... }
• Go: Add to src/api/go/bitvec.go:
  func (c *Context) MkBVExtRotateLeft(t, i *Expr) *Expr { ... C.Z3_mk_ext_rotate_left(...) }

---

5. Go Missing Array Map Function (Z3_mk_map)

What: Z3_mk_map(ctx, f, args...) applies a function to the element-wise values of one or more arrays, producing a new array. This is a core higher-order array operation.

Available in: Python (ArrayMap(f, a, b)), Java (Context.mkMap()), .NET (Context.MkArrayMap()), C++ (array_map()), OCaml (mk_map)

Missing in: Go (src/api/go/array.go)

Suggested fix: Add to src/api/go/array.go:

func (c *Context) MkMap(f *FuncDecl, args ...*Expr) *Expr {
    ptrs := make([]C.Z3_ast, len(args))
    for i, a := range args { ptrs[i] = a.ptr }
    return newExpr(c, C.Z3_mk_map(c.ptr, f.ptr, C.uint(len(args)), &ptrs[0]))
}

---

6. Go FPA Missing FMA, Rem, Min, Max, RoundToIntegral

What: Five standard floating-point operations are absent from Go's fp.go:

• Z3_mk_fpa_fma — Fused multiply-add: (a * b) + c with single rounding
• Z3_mk_fpa_rem — IEEE 754 remainder
• Z3_mk_fpa_min / Z3_mk_fpa_max — IEEE 754 min/max
• Z3_mk_fpa_round_to_integral — Round to integer value in FP representation

Available in: Python, Java, .NET, C++, OCaml, TypeScript, Rust

Missing in: Go

---

7. Go FPA Missing Numeral Constructors from Native Values

What: Go can only construct FP numerals from a string (MkFPNumeral(value string, sort *Sort)). The C API offers constructors from native float/double/int values which are more convenient:

• Z3_mk_fpa_numeral_float — from C float
• Z3_mk_fpa_numeral_double — from C double
• Z3_mk_fpa_numeral_int — from integer
• Z3_mk_fpa_numeral_int64_uint64 — from (sign, exponent, mantissa) triple

Available in: Python, Java, .NET, C++, TypeScript, Rust

Missing in: Go

---

🔵 Low Priority Issues

8. Rust BV Missing repeat Operation

What: Z3_mk_repeat(ctx, i, t) repeats a bit-vector t exactly i times, producing a wider BV. All other bindings expose this. Rust's BV type has sign_ext, zero_ext, and extract but not repeat.

Available in: Python, Java, .NET, C++, OCaml, TypeScript, Go

Missing in: Rust (/z3/src/ast/bv.rs)

Suggested fix: Add to bv.rs:

pub fn repeat(&self, i: u32) -> Self {
    BV::new(unsafe { Z3_mk_repeat(self.ctx.z3_ctx.0, i, self.z3_ast) }.unwrap())
}

---

9. Rust Solver/Optimize Missing Many Newer C API Functions (Ongoing)

Status: Still open from previous run. Rust's z3 crate lacks wrappers for:

• Z3_solver_to_dimacs_string (no to_dimacs())
• Z3_solver_add_simplifier (no add_simplifier())
• Z3_solver_get_trail (no get_trail())
• Z3_solver_register_on_clause (no clause learning callbacks)
• Z3_solver_interrupt (no interrupt())
• Z3_solver_get_cube (no get_cube())
• Z3_solver_solve_for (no solve_for())
• Z3_optimize_translate (no translate() for Optimize)
• Z3_optimize_get_lower / Z3_optimize_get_upper (no objective bounds)

Additionally, z3-sys is missing the low-level FFI bindings for most of these, which must be added first.

File: /tmp/z3.rs/z3/src/solver.rs, /tmp/z3.rs/z3/src/optimize.rs, /tmp/z3.rs/z3-sys/src/generated.rs

---

Next Run — APIs to Analyze

1. Quantifier APIs (Z3_mk_forall, Z3_mk_exists, Z3_mk_lambda, Z3_mk_pattern, Z3_mk_bound, Z3_mk_quantifier_const_ex)
2. Arithmetic APIs (Z3_mk_add, Z3_mk_mul, Z3_mk_div, Z3_mk_power, Z3_mk_mod, Z3_mk_is_int, Z3_mk_int2real, Z3_mk_real2int, Arith overflow predicates)
3. Fixedpoint APIs (Z3_fixedpoint_*)
4. Tactic/Goal APIs (Z3_mk_goal, Z3_goal_*, Z3_tactic_*)
5. Sequence/String APIs (Z3_mk_seq_*, Z3_mk_re_*, Z3_mk_string)

AI generated by API Coherence Checker · history

• expires on Mar 19, 2026, 11:24 PM UTC

[github-actions[bot]]

This discussion has been marked as outdated by API Coherence Checker.

A newer discussion is available at Discussion #9021.