[API Coherence] Report for 2026-03-18 – RCF APIs (Final Pass, 100% Coverage)

[github-actions[bot]]

Summary

Run 7 of 7 – This is the final pass completing full coverage of Z3's API surface.

Metric	Value
APIs analyzed this run	RCF (Real Closed Field) APIs — 37 functions
Cumulative API families	20 / ~20 (100% coverage)
Languages covered	C, C++, Python, Java, .NET, TypeScript, OCaml, Go, Rust
Previously cached issues re-verified	13 (all still open)
New issues found this run	4 (including 1 code bug)
Total open issues	17

---

🐛 Bug Found This Run

OCaml RCF.inv Calls Wrong Native Function

File: src/api/ml/z3.ml, line 2228
Severity: HIGH — wrong result silently returned

(* BUG: line 2228 *)
let inv (ctx:context) (a:rcf_num) = Z3native.rcf_neg ctx a
(*                                             ^^^ should be rcf_inv *)

RCF.inv is supposed to compute the multiplicative inverse (1/a) but instead computes the negation (-a). This is a copy-paste error from line 2227:

let neg (ctx:context) (a:rcf_num) = Z3native.rcf_neg ctx a   (* correct *)
let inv (ctx:context) (a:rcf_num) = Z3native.rcf_neg ctx a   (* BUG: should be rcf_inv *)
```

**Fix**: Change `Z3native.rcf_neg` to `Z3native.rcf_inv` on line 2228.

---

## High Priority Issues

### 1. User Propagator API Missing in TypeScript, OCaml, and Rust (Confirmed Again)

The User Propagator API (`Z3_solver_propagate_*`) enables custom theory plugins to interact with the DPLL(T) engine in real time. It's one of Z3's most powerful features for advanced use cases.

| Language | Status |
|---|---|
| Python | ✅ Full (`UserPropagator` class) |
| Java | ✅ Full (`UserPropagator` class) |
| .NET (C#) | ✅ Full (`UserPropagator` class) |
| Go | ✅ Full (`propagator.go`) |
| TypeScript/JS | ❌ **Missing entirely** |
| OCaml | ❌ **Missing entirely** |
| Rust (z3-sys) | ❌ **Missing entirely** — no FFI bindings |
| Rust (z3 crate) | ❌ **Missing entirely** — no high-level wrapper |

**C API functions affected** (12 total): `Z3_solver_propagate_init`, `Z3_solver_propagate_fixed`, `Z3_solver_propagate_final`, `Z3_solver_propagate_eq`, `Z3_solver_propagate_diseq`, `Z3_solver_propagate_created`, `Z3_solver_propagate_decide`, `Z3_solver_propagate_on_binding`, `Z3_solver_propagate_declare`, `Z3_solver_propagate_register`, `Z3_solver_propagate_register_cb`, `Z3_solver_propagate_consequence`

**Priority**: HIGH — This is a core advanced feature with no workaround.

---

## Medium Priority Issues

### 2. Go Missing Entire RCF API (37 Functions)

The `src/api/go/` directory has no support for Real Closed Field numerals at all. The RCF API is available in all other language bindings.

**Available in**: C, C++, Java, .NET, OCaml, TypeScript, Rust (z3-sys partial)
**Missing in**: Go (all 37 functions), Python (uses `AlgebraicNumRef` instead — different approach but similar capability)
**Suggested fix**: Add a `rcf.go` file implementing a `RCFNum` type wrapping `C.Z3_rcf_num` with the full set of operations.

### 3. Rust `z3-sys` Missing 14 RCF Functions

`z3-sys` has 23 of 37 `Z3_rcf_*` FFI bindings. The **missing 14** are:

```
Z3_rcf_is_rational         Z3_rcf_is_algebraic
Z3_rcf_is_infinitesimal    Z3_rcf_is_transcendental
Z3_rcf_extension_index     Z3_rcf_transcendental_name
Z3_rcf_infinitesimal_name  Z3_rcf_num_coefficients
Z3_rcf_coefficient         Z3_rcf_interval
Z3_rcf_num_sign_conditions Z3_rcf_sign_condition_sign
Z3_rcf_num_sign_condition_coefficients
Z3_rcf_sign_condition_coefficient

Additionally, the high-level z3 crate has zero RCF wrappers — all 37 functions are unexposed.

File to update: /tmp/z3.rs/z3-sys/src/lib.rs (around line 6306), then add a rcf.rs module to the z3 crate.

4. Rust Missing Many Solver APIs (Confirmed)

The z3 Rust crate is still missing these Solver methods available in all other bindings:

• cube / get_cube_variables (Z3_solver_cube)
• get_trail (Z3_solver_get_trail)
• solve_for (Z3_solver_solve_for)
• congruence_root / congruence_next (Z3_solver_congruence_root/next)
• set_initial_value (Z3_solver_set_initial_value)
• add_simplifier (Z3_solver_add_simplifier)
• register_on_clause (Z3_solver_register_on_clause)
• to_dimacs_string (Z3_solver_to_dimacs_string)

5. Go Missing Global Parameter Functions (Confirmed)

// Missing in src/api/go/z3.go:
func SetGlobalParam(id, value string)   // Z3_global_param_set
func GetGlobalParam(id string) string   // Z3_global_param_get
func ResetAllGlobalParams()             // Z3_global_param_reset_all
```

Available in Python, Java, .NET, OCaml, TypeScript, Rust.

### 6. Rust Missing Seq/String Operations (Confirmed)

The Rust `z3` crate's `Seq`/`String` types are missing wrappers for: `extract` (subsequence), `replace`, `replace_all`, `replace_re`, `replace_re_all`, `is_prefix`, `is_suffix`, `index`, `last_index`, `map`, `mapi`, `foldl`, `foldli`. The `z3-sys` FFI bindings for these exist; only the high-level wrappers are missing.

### 7. Rust Fixedpoint Missing Key Methods (Confirmed)

`z3::Fixedpoint` is missing: `get_rules` (`Z3_fixedpoint_get_rules`), `get_param_descrs` (`Z3_fixedpoint_get_param_descrs`), `set_predicate_representation`.

### 8. ParserContext API Only in Python (Confirmed)

`Z3_parser_context_add_sort`, `Z3_parser_context_add_decl`, and `Z3_parser_context_from_string` allow parsing SMT-LIB2 with user-defined sorts and functions. Only Python exposes this API.

**Missing in**: Java, .NET, Go, TypeScript, Rust, OCaml

### 9. Go Missing Standalone SMT-LIB2 Parser (Confirmed)

Go has `Solver.FromString` (which asserts formulas directly via `Z3_solver_from_string`) but lacks the distinct `Z3_parse_smtlib2_string`/`Z3_parse_smtlib2_file` functions that return an `ASTVector` without asserting. Rust high-level is also missing this.

---

## Low Priority Issues

### 10. Advanced RCF Introspection Missing in Java, .NET, C++, TypeScript

The following RCF inspection functions are only exposed in **OCaml**; they're missing from all other language bindings:

| Function | Purpose |
|---|---|
| `Z3_rcf_extension_index` | Index of the algebraic/transcendental extension |
| `Z3_rcf_transcendental_name` | Name of the transcendental element |
| `Z3_rcf_infinitesimal_name` | Name of the infinitesimal element |
| `Z3_rcf_num_coefficients` | Number of polynomial coefficients |
| `Z3_rcf_coefficient` | Get i-th polynomial coefficient |
| `Z3_rcf_interval` | Root isolation interval (lower/upper bounds) |
| `Z3_rcf_num_sign_conditions` | Number of sign conditions |
| `Z3_rcf_sign_condition_sign` | Sign of the i-th sign condition |
| `Z3_rcf_num_sign_condition_coefficients` | Coefficient count in i-th sign condition |
| `Z3_rcf_sign_condition_coefficient` | Get (i,j)-th sign condition coefficient |

These are specialized APIs used in CAD (Cylindrical Algebraic Decomposition) and related algorithms.

### 11. Rust BV Missing `repeat` Operation (Confirmed)

`Z3_mk_repeat` is bound in `z3-sys` but the high-level `z3` BV type doesn't expose it. All other bindings have `repeat`.

### 12. Rust Tactic Missing Parallel Combinators (Confirmed)

`par_or`, `par_and_then` (`Z3_tactic_par_or`, `Z3_tactic_par_and_then`) are missing from the Rust tactic API.

### 13. Rust Algebraic API Incomplete (Confirmed)

Rust `z3-sys` has `Z3_algebraic_le`, `Z3_algebraic_ge`, `Z3_algebraic_neq`, `Z3_algebraic_roots`, `Z3_algebraic_eval` but the high-level `z3` crate doesn't expose them. `Z3_algebraic_get_poly` and `Z3_algebraic_get_i` are not even in `z3-sys`.

### 14. OCaml Algebraic API Limited (Confirmed)

OCaml's `Arithmetic.AlgebraicNumber` only exposes `to_upper`/`to_lower`. Missing: all arithmetic operations (add/sub/mul/div/root/power) and comparisons (lt/gt/le/ge/eq/neq/roots/eval). The C API has these; Python and Rust expose them via `AlgebraicNumRef`.

---

## Progress Tracker

```
APIs analyzed: 20 / ~20 (100% — all major API families covered!)

Run history:
  Run 1: Solver, Optimize, BitVector
  Run 2: Array, Floating-Point, Quantifier
  Run 3: Arithmetic, Sequence/String/RegExp
  Run 4: Datatype, Model, Tactic/Goal/Probe
  Run 5: Fixedpoint, Context/Config/Global Param, Parser
  Run 6: Statistics, AST Vector/Map, Algebraic Numbers, User Propagator, Symbol/Sort/FuncDecl
  Run 7: RCF (Real Closed Field)

Recommended Next Steps

1. Fix the OCaml RCF.inv bug — one-line fix in src/api/ml/z3.ml:2228
2. Add User Propagator to TypeScript/OCaml/Rust — highest-impact missing feature
3. Add RCF support to Go — straightforward CGO wrapper
4. Complete Rust z3-sys RCF bindings — add 14 missing FFI functions
5. Add Rust high-level RCF wrapper — wrap the z3-sys bindings
6. Add ParserContext API to Java/.NET/Go — useful for incremental SMT-LIB2 parsing
7. Consider a second-pass analysis focused on recently-added C API functions not yet in language bindings

AI generated by API Coherence Checker · history

• expires on Mar 25, 2026, 3:51 PM UTC

[github-actions[bot]]

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

A newer discussion is available at Discussion #9043.