fix: Zig 0.16 compile and f32-exact museum tests

src/algebraic/categorical.zig

@@ -172,5 +172,6 @@ test "topos witness gate" {
         .has_exponentials = true,
     };
     try std.testing.expect(w.isElementaryTopos());
-    try std.testing.expect(!ToposWitness{}.isElementaryTopos());
+    const empty = ToposWitness{};
+    try std.testing.expect(!empty.isElementaryTopos());
 }

src/deductive/natded.zig

@@ -283,7 +283,6 @@ test "natded modus ponens" {
     const a1 = try pr.assume(imp);
     const a2 = try pr.assume(p);
     const q_line = try pr.impliesElim(a1, a2);
-    _ = q_line;
     // Discharge p: derive (P→Q) → ((P→Q) wait — discharge innermost first
     // Innermost is P, last formula Q → get P→Q (identity-ish under outer)
     // Actually last is Q, discharge P → (P → Q) under outer (P→Q) assumption.

src/deductive/sequent.zig

@@ -229,7 +229,7 @@ test "sequent implies-right shape" {
     const node = ProofNode{
         .sequent = conc,
         .rule = .implies_r,
-        .premises = &[_]*const ProofNode{&prem},
+        .premises = &[_]*ProofNode{&prem},
     };
     try std.testing.expect(check(&node));
 }

src/deductive/sequent_search.zig

@@ -21,7 +21,6 @@ pub const SearchResult = enum { proved, failed, depth_exceeded };
 /// signed atoms (positive = right-side atom or left-side negation, etc.).
 /// For the spine we reduce formulas to NNF-ish signed literals via a simple
 /// recursive inversion.
-
 pub const Signed = struct {
     atom: []const u8,
     /// true = positive occurrence on the side it sits
@@ -56,7 +55,6 @@ pub fn search(
 }
 
 fn searchDepth(allocator: std.mem.Allocator, goal: sequent.Sequent, depth: u32) !SearchResult {
-    _ = allocator;
     if (goal.isInitial()) return .proved;
     if (depth == 0) return .depth_exceeded;
 

src/fuzzy/fuzzy.zig

@@ -128,7 +128,7 @@ pub fn kleeneOr(a: Kleene, b: Kleene) Kleene {
 }
 
 test "lukasiewicz t-norm bounds" {
-    try std.testing.expect(tnorm(.lukasiewicz, 0.7, 0.6) == @as(Degree, 0.3));
+    try std.testing.expectApproxEqAbs(@as(Degree, 0.3), tnorm(.lukasiewicz, 0.7, 0.6), 1e-6);
     try std.testing.expect(tnorm(.lukasiewicz, 0.2, 0.3) == @as(Degree, 0));
     try std.testing.expect(implies(.lukasiewicz, 0.3, 0.8) == @as(Degree, 1));
 }

src/modal/cert.zig

@@ -80,7 +80,6 @@ fn fingerprint(phi: *const normal.Formula) u64 {
 }
 
 fn forces(n: u32, rel: u32, val: u32, w: u32, phi: *const normal.Formula, n_atoms: u32) bool {
-    _ = n_atoms;
     return switch (phi.*) {
         .atom => |a| (val & (@as(u32, 1) << @intCast(a * n + w))) != 0,
         .not => |x| !forces(n, rel, val, w, x, n_atoms),

src/probabilistic/prob.zig

@@ -85,8 +85,8 @@ test "independence product" {
 
 test "frechet and bounds" {
     const iv = frechetAnd(0.7, 0.6);
-    try std.testing.expect(iv.lo == 0.3);
-    try std.testing.expect(iv.hi == 0.6);
+    try std.testing.expectApproxEqAbs(0.3, iv.lo, 1e-12);
+    try std.testing.expectApproxEqAbs(0.6, iv.hi, 1e-12);
 }
 
 test "negation complement" {

src/probabilistic/wpll.zig

@@ -13,8 +13,8 @@ const markov = @import("markov.zig");
 
 /// Softplus-stable log(σ(z)) helpers.
 fn logSigmoid(z: f64) f64 {
-    if (z >= 0) return -@log1p(@exp(-z));
-    return z - @log1p(@exp(z));
+    if (z >= 0) return -std.math.log1p(@exp(-z));
+    return z - std.math.log1p(@exp(z));
 }
 
 /// Weight difference for atom j: score(x[j]=1) - score(x[j]=0) with others fixed.