[API Coherence] API Coherence Report - March 11, 2026 (Run #2) - Solver/Optimize/Tactic/Simplifier/Probe APIs

[github-actions[bot]]

API Coherence Report - March 11, 2026

Summary

Analyzed: Solver APIs (extended verification), Optimize APIs (extended verification), Tactic APIs, Simplifier APIs, Probe APIs
Total APIs checked: ~45 functions across 9 languages
Languages covered: Java, .NET (C#), C++, Python, TypeScript/JavaScript, OCaml, Go, Rust
Previously cached issues resolved: 10 ✅
New inconsistencies found: 4

🎉 Resolution Updates

The following 10 cached issues have been resolved since the February 24 run:

High Priority (2 resolved)

• ✅ TypeScript Optimize API completeness - getLower(), getUpper(), fromFile(), unsatCore(), objectives(), reasonUnknown() all now implemented
• ✅ Java Solver.addSimplifier - Now implemented

Medium Priority (8 resolved)

• ✅ Java Solver.toDimacs - Now implemented (was missing in Feb)
• ✅ .NET Solver.ToDimacsString - Now implemented
• ✅ Go Solver.ToDimacsString - Now implemented
• ✅ TypeScript Solver.toDimacsString - Now implemented
• ✅ OCaml Solver.to_dimacs - Now implemented
• ✅ Rust Solver.translate - Now implemented
• ✅ Go Solver.get_proof - Now implemented
• ✅ TypeScript Solver.getProof - Now implemented

Excellent progress! The Z3 team has significantly improved API consistency across language bindings.

Progress

• APIs analyzed so far: 6/~20 API families (30%)
• This run: Extended verification of Solver/Optimize APIs, analyzed Tactic/Simplifier/Probe APIs
• Next run: BitVector operations, Array theory, Quantifier APIs, Floating-point APIs

High Priority Issues

1. Rust Missing Parallel Tactic Combinators ⚠️

What: Tactic parallel combinators par_or() and par_and_then() are not exposed in Rust's high-level z3 crate
Available in: C, C++, Python, .NET, Java, TypeScript, Go, OCaml
Missing in: Rust (high-level z3 crate only)
Details:

• The low-level z3-sys FFI bindings do expose Z3_tactic_par_or and Z3_tactic_par_and_then
• The high-level z3 crate (z3/src/tactic.rs) only implements and_then(), or_else(), when(), cond(), repeat(), but not the parallel variants
• Rust has: and_then(), or_else(), when(), cond(), repeat(), try_for(), probe_or_else(), create_skip(), create_fail(), fail_if(), with()
• Missing: par_or(), par_and_then()

Suggested fix: Add to z3/src/tactic.rs:

pub fn par_or(tactics: &[&Tactic]) -> Tactic {
    let ctx = &tactics[0].ctx;
    let tactic_ptrs: Vec<_> = tactics.iter().map(|t| t.z3_tactic).collect();
    unsafe {
        Self::wrap(ctx, 
            Z3_tactic_par_or(ctx.z3_ctx.0, tactic_ptrs.len() as u32, tactic_ptrs.as_ptr()).unwrap()
        )
    }
}

pub fn par_and_then(&self, then_tactic: &Tactic) -> Tactic {
    unsafe {
        Self::wrap(&self.ctx,
            Z3_tactic_par_and_then(self.ctx.z3_ctx.0, self.z3_tactic, then_tactic.z3_tactic).unwrap()
        )
    }
}

Priority: High - Parallel tactics are important for performance-critical applications
External repo: This issue affects the external prove-rs/z3.rs repository
Verified: Checked current codebase on March 11, 2026 - still missing

Medium Priority Issues

2. Rust Solver Missing toDimacs

What: Solver.to_dimacs() / Solver.to_dimacs_string() is not exposed in Rust
Available in: C, C++, Python, .NET, Java, TypeScript, Go, OCaml
Missing in: Rust
Details:

• The C API function Z3_solver_to_dimacs_string exists
• All other language bindings now expose this (Java was recently added)
• Rust's z3 crate does not expose it in z3/src/solver.rs

Suggested fix: Add to Solver impl in z3/src/solver.rs:

pub fn to_dimacs(&self, include_names: bool) -> String {
    let result = unsafe {
        Z3_solver_to_dimacs_string(self.ctx.z3_ctx.0, self.z3_slv, include_names)
    };
    unsafe { CStr::from_ptr(result) }
        .to_str()
        .unwrap()
        .to_string()
}

Priority: Medium - Useful for debugging and exporting to other SAT solvers
External repo: Affects prove-rs/z3.rs
Verified: March 11, 2026 - still missing

3. Rust Optimize Missing translate()

What: Optimize.translate() is not exposed in Rust
Available in: C, C++, Python, .NET, Java
Missing in: TypeScript, OCaml, Go, Rust
Details:

• The C API function Z3_optimize_translate exists
• Core bindings (Python, .NET, Java, C++) have this
• Rust's Optimize in z3/src/optimize.rs doesn't implement it
• Also missing in TypeScript, OCaml, Go

Suggested fix: Add to Optimize impl in z3/src/optimize.rs:

fn translate(&self, dest: &Context) -> Optimize {
    unsafe {
        Self::wrap(dest,
            Z3_optimize_translate(self.ctx.z3_ctx.0, self.z3_opt, dest.z3_ctx.0).unwrap()
        )
    }
}

Priority: Medium - Needed for moving optimization problems between contexts
External repo: Affects prove-rs/z3.rs and internal bindings (TypeScript, OCaml, Go)
Verified: March 11, 2026 - still missing in Rust

4. Rust Missing Simplifier API

What: Rust completely lacks Simplifier API support
Available in: C, C++, Python, .NET, Java, TypeScript, Go, OCaml
Missing in: Rust
Details:

• The C API has Z3_mk_simplifier, Z3_simplifier_and_then, etc.
• All other language bindings expose Simplifier
• Rust's z3 crate has no simplifier.rs file
• No Simplifier struct or implementation exists

Priority: Medium - Simplifiers are used for preprocessing and optimization
External repo: Affects prove-rs/z3.rs
Verified: March 11, 2026 - completely missing

API Coverage Summary by Language

API Family	C	C++	Python	Java	.NET	TypeScript	Go	OCaml	Rust
Solver Core	✅	✅	✅	✅	✅	✅	✅	✅	✅
Solver.to_dimacs	✅	✅	✅	✅	✅	✅	✅	✅	❌
Solver.translate	✅	✅	✅	✅	✅	✅	✅	✅	✅
Solver.get_proof	✅	✅	✅	✅	✅	✅	✅	✅	✅
Optimize Core	✅	✅	✅	✅	✅	✅	✅	✅	✅
Optimize.translate	✅	✅	✅	✅	✅	❌	❌	❌	❌
Tactic Core	✅	✅	✅	✅	✅	✅	✅	✅	✅
Tactic.par_or	✅	✅	✅	✅	✅	✅	✅	✅	❌
Tactic.par_and_then	✅	✅	✅	✅	✅	✅	✅	✅	❌
Simplifier	✅	✅	✅	✅	✅	✅	✅	✅	❌
Probe	✅	✅	✅	✅	✅	✅	✅	✅	✅

Legend: ✅ = Fully supported, ❌ = Missing

Notes

• Rust external repository: The Rust bindings are maintained in the external prove-rs/z3.rs repository, not in the main Z3 repository. Issues should be reported there.
• Excellent progress: 10 out of 13 previously identified issues have been resolved since February!
• Overall API maturity: Most languages now have excellent API coverage. Rust is the primary exception with a few missing features.
• Simplifier support: Rust completely lacks Simplifier support (no z3/src/simplifier.rs file exists)

Recommendations for Z3 Maintainers

1. Consider upstreaming Rust improvements - While Rust bindings are external, the Z3 team could coordinate with the prove-rs/z3.rs maintainers to ensure feature parity
2. Document API coverage - Consider adding a matrix like the one above to the Z3 documentation to help users choose language bindings
3. API stability guarantees - Consider documenting which APIs are stable across all bindings vs. experimental/language-specific

Next Run Plan

The next run will focus on:

1. BitVector operations - Comprehensive check of all 40+ BitVector functions
2. Array theory APIs - Select, store, map operations
3. Quantifier APIs - ForAll, Exists, Lambda across languages
4. Floating-point APIs - FPA operations and rounding modes
5. Datatype APIs - Constructor, recognizer, accessor functions

---

Report generated: March 11, 2026
Analyzer version: API Coherence Checker v2.0
Repository: Z3Prover/z3
Cache updated: Yes

AI generated by API Coherence Checker · history

• expires on Mar 18, 2026, 11:22 PM UTC

[github-actions[bot]]

This discussion was automatically closed because it expired on 2026-03-18T23:22:12.745Z.

Closed by Workflow