@nudojs/core 0.2.0 → 0.3.0

package/package.json

@@ -1,21 +1,37 @@
 {
   "name": "@nudojs/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
+  "description": "Nudo type system: type-as-computation (Abs) with TypeValue evaluation IR",
   "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "nudo",
+    "type-inference",
+    "javascript",
+    "abstract-interpretation",
+    "type-system"
+  ],
   "main": "src/index.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./exec": "./src/algebra/exec/index.ts"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nudojs/nudo.git",
     "directory": "packages/core"
   },
+  "homepage": "https://github.com/nudojs/nudo/tree/main/packages/core",
+  "bugs": "https://github.com/nudojs/nudo/issues",
   "publishConfig": {
     "access": "public",
     "provenance": true,
     "registry": "https://registry.npmjs.org"
   },
+  "dependencies": {
+    "@babel/parser": "^7.29.0",
+    "@babel/types": "^7.29.0"
+  },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts"
   }

package/src/__tests__/fn-sig-impl.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { T, getFnSig, isFnSig, typeValueEquals, typeValueToString } from "../index.ts";
+
+describe("T.fnSig with impl", () => {
+  it("creates fnSig without impl (backward compatible)", () => {
+    const fn = T.fnSig([T.number], T.string);
+    expect(isFnSig(fn)).toBe(true);
+    const sig = getFnSig(fn)!;
+    expect(sig.impl).toBeUndefined();
+    expect(typeValueEquals(sig.returnType, T.string)).toBe(true);
+  });
+
+  it("creates fnSig with impl", () => {
+    const fn = T.fnSig([T.number], T.number, T.never, (args) => {
+      if (args[0].kind === "literal" && typeof args[0].value === "number") {
+        return T.literal(args[0].value * 2);
+      }
+      return undefined;
+    });
+    expect(isFnSig(fn)).toBe(true);
+    const sig = getFnSig(fn)!;
+    expect(sig.impl).toBeDefined();
+  });
+
+  it("impl returns concrete value for literal args", () => {
+    const fn = T.fnSig([T.number], T.number, T.never, (args) => {
+      if (args[0].kind === "literal" && typeof args[0].value === "number") {
+        return T.literal(args[0].value * 2);
+      }
+      return undefined;
+    });
+    const sig = getFnSig(fn)!;
+    const result = sig.impl!([T.literal(5)]);
+    expect(result).toBeDefined();
+    expect(typeValueEquals(result!, T.literal(10))).toBe(true);
+  });
+
+  it("impl returns undefined for symbolic args (fallback to returnType)", () => {
+    const fn = T.fnSig([T.number], T.number, T.never, (args) => {
+      if (args[0].kind === "literal" && typeof args[0].value === "number") {
+        return T.literal(args[0].value * 2);
+      }
+      return undefined;
+    });
+    const sig = getFnSig(fn)!;
+    const result = sig.impl!([T.number]);
+    expect(result).toBeUndefined();
+  });
+
+  it("typeValueToString still works for fnSig with impl", () => {
+    const fn = T.fnSig([T.number, T.string], T.boolean, T.never, () => T.literal(true));
+    const str = typeValueToString(fn);
+    expect(str).toContain("number");
+    expect(str).toContain("string");
+    expect(str).toContain("boolean");
+  });
+});

package/src/__tests__/ops-refined.test.ts

@@ -38,8 +38,10 @@ describe("dispatchBinaryOp", () => {
           },
         },
       });
+      // Ops.mod 已删：dispatchBinaryOp 的 % 最终落到 unknown；
+      // evaluator 侧由 evalBinaryValue 的 numberish 兜底补 number。
       const result = dispatchBinaryOp("%", odd, T.literal(3));
-      expect(result.kind).toBe("primitive");
+      expect(result.kind).toBe("unknown");
     });
   });
 

package/src/__tests__/ops.test.ts

@@ -21,19 +21,7 @@ describe("Ops.add", () => {
   });
 });
 
-describe("Ops.sub / mul / div / mod", () => {
-  it("computes literal arithmetic", () => {
-    expect(typeValueEquals(Ops.sub(T.literal(5), T.literal(3)), T.literal(2))).toBe(true);
-    expect(typeValueEquals(Ops.mul(T.literal(3), T.literal(4)), T.literal(12))).toBe(true);
-    expect(typeValueEquals(Ops.div(T.literal(10), T.literal(2)), T.literal(5))).toBe(true);
-    expect(typeValueEquals(Ops.mod(T.literal(7), T.literal(3)), T.literal(1))).toBe(true);
-  });
-
-  it("returns number for abstract operands", () => {
-    expect(typeValueEquals(Ops.sub(T.number, T.number), T.number)).toBe(true);
-    expect(typeValueEquals(Ops.mul(T.number, T.literal(2)), T.number)).toBe(true);
-  });
-});
+// sub/mul/div/mod 已删除：数值路径唯一真理在 algebra；非数应得 unknown。
 
 describe("Ops.strictEq / strictNeq", () => {
   it("compares literals", () => {
@@ -60,16 +48,6 @@ describe("Ops.gt / lt / gte / lte", () => {
   });
 });
 
-describe("Ops.typeof_", () => {
-  it("returns literal typeof for known types", () => {
-    expect(typeValueEquals(Ops.typeof_(T.literal(1)), T.literal("number"))).toBe(true);
-    expect(typeValueEquals(Ops.typeof_(T.literal("hi")), T.literal("string"))).toBe(true);
-    expect(typeValueEquals(Ops.typeof_(T.literal(null)), T.literal("object"))).toBe(true);
-    expect(typeValueEquals(Ops.typeof_(T.number), T.literal("number"))).toBe(true);
-    expect(typeValueEquals(Ops.typeof_(T.object({})), T.literal("object"))).toBe(true);
-  });
-});
-
 describe("Ops.not", () => {
   it("negates literal booleans", () => {
     expect(typeValueEquals(Ops.not(T.literal(true)), T.literal(false))).toBe(true);
@@ -87,15 +65,7 @@ describe("Ops.not", () => {
   });
 });
 
-describe("Ops.neg", () => {
-  it("negates literal number", () => {
-    expect(typeValueEquals(Ops.neg(T.literal(5)), T.literal(-5))).toBe(true);
-  });
-
-  it("returns number for abstract", () => {
-    expect(typeValueEquals(Ops.neg(T.number), T.number)).toBe(true);
-  });
-});
+// typeof_ / neg 已迁入 algebra surface（tryAbsUnary）
 
 describe("applyBinaryOp", () => {
   it("dispatches to correct op", () => {
@@ -103,7 +73,12 @@ describe("applyBinaryOp", () => {
     expect(typeValueEquals(applyBinaryOp("===", T.literal(1), T.literal(1)), T.literal(true))).toBe(true);
   });
 
-  it("returns unknown for unsupported op", () => {
+  it("returns unknown for deleted / unsupported ops", () => {
     expect(applyBinaryOp("**", T.number, T.number)).toEqual(T.unknown);
+    // sub/mul/div/mod 已从 Ops 删除，代数是唯一路径
+    expect(applyBinaryOp("-", T.literal(5), T.literal(3))).toEqual(T.unknown);
+    expect(applyBinaryOp("*", T.number, T.number)).toEqual(T.unknown);
+    expect(applyBinaryOp("/", T.literal(10), T.literal(2))).toEqual(T.unknown);
+    expect(applyBinaryOp("%", T.literal(7), T.literal(3))).toEqual(T.unknown);
   });
 });

package/src/__tests__/type-value.test.ts

@@ -1,15 +1,19 @@
 import { describe, it, expect } from "vitest";
 import {
   T,
+  type LiteralValue,
+  type TypeValue,
   typeValueEquals,
   simplifyUnion,
   widenLiteral,
+  collapseLiteralUnion,
   isSubtypeOf,
   typeValueToString,
   narrowType,
   subtractType,
   getPrimitiveTypeOf,
 } from "../type-value.ts";
+import { createTemplate } from "../refinements/template.ts";
 
 describe("T factory", () => {
   it("creates literal type values", () => {
@@ -118,6 +122,46 @@ describe("widenLiteral", () => {
   it("returns non-literal unchanged", () => {
     expect(widenLiteral(T.number)).toBe(T.number);
   });
+
+  it("collapses 20 number literals beyond maxLiterals to number", () => {
+    const members = Array.from({ length: 20 }, (_, i) => T.literal((i + 1) ** 2));
+    const u = { kind: "union", members } as const;
+    const result = collapseLiteralUnion(u, 4);
+    expect(result).toEqual(T.number);
+  });
+
+  it("collapses 5 string literals to string", () => {
+    const u = {
+      kind: "union",
+      members: ["a", "b", "c", "d", "e"].map((s) => T.literal(s)),
+    } as const;
+    const result = collapseLiteralUnion(u, 4);
+    expect(result).toEqual(T.string);
+  });
+
+  it("returns union unchanged when member count equals maxLiterals", () => {
+    const u: TypeValue = {
+      kind: "union",
+      members: [T.literal(1), T.literal(2), T.literal(3), T.literal(4)],
+    };
+    expect(collapseLiteralUnion(u, 4)).toBe(u);
+  });
+
+  it("mixed union: number literals absorbed by T.number, string literal kept (行为已修复：吸收律)", () => {
+    const u: TypeValue = {
+      kind: "union",
+      members: [T.literal(1), T.number, T.literal("x"), T.literal(2), T.literal(3)],
+    };
+    // 原断言期望原样返回 u；现 collapseLiteralUnion 复用 simplifyUnion 的吸收律，
+    // 数字字面量 1/2/3 被共存的 T.number 吸收，仅剩 ["x", number]（数量 ≤ 阈值不再坍缩）
+    expect(collapseLiteralUnion(u, 4)).toEqual(T.union(T.number, T.literal("x")));
+  });
+
+  it("returns non-union unchanged (single literal / T.number)", () => {
+    const lit = T.literal(1);
+    expect(collapseLiteralUnion(lit, 0)).toBe(lit);
+    expect(collapseLiteralUnion(T.number, 0)).toBe(T.number);
+  });
 });
 
 describe("isSubtypeOf", () => {
@@ -211,3 +255,65 @@ describe("getPrimitiveTypeOf", () => {
     expect(getPrimitiveTypeOf(T.array(T.number))).toBe("object");
   });
 });
+
+describe("union absorption law (3 | number → number)", () => {
+  it("absorbs number literal into number", () => {
+    expect(T.union(T.literal(3), T.number)).toBe(T.number);
+    expect(T.union(T.number, T.literal(3))).toBe(T.number);
+  });
+
+  it("absorbs string literal into string", () => {
+    expect(T.union(T.literal("a"), T.string)).toBe(T.string);
+    expect(T.union(T.string, T.literal("a"))).toBe(T.string);
+  });
+
+  it("absorbs boolean literal into boolean", () => {
+    expect(T.union(T.literal(true), T.boolean)).toBe(T.boolean);
+    expect(T.union(T.boolean, T.literal(false))).toBe(T.boolean);
+  });
+
+  it("absorbs bigint literal into bigint", () => {
+    // LiteralValue 类型暂不含 bigint，运行时以 cast 构造
+    expect(T.union(T.literal(10n as unknown as LiteralValue), T.bigint)).toBe(T.bigint);
+  });
+
+  it("absorbs template literal into string", () => {
+    const tmpl = createTemplate([T.literal("x"), T.string]);
+    expect(T.union(tmpl, T.string)).toBe(T.string);
+  });
+
+  it("absorbs only matching base across mixed members (order-stable)", () => {
+    // 1 被 number 吸收，"a" 无 string 在场而保留
+    const u = T.union(T.literal(1), T.number, T.literal("a"));
+    expect(u.kind).toBe("union");
+    if (u.kind === "union") {
+      expect(u.members).toHaveLength(2);
+      expect(typeValueEquals(u.members[0], T.number)).toBe(true);
+      expect(typeValueEquals(u.members[1], T.literal("a"))).toBe(true);
+    }
+  });
+
+  it("keeps different-base literal union (1 | \"a\")", () => {
+    const u = T.union(T.literal(1), T.literal("a"));
+    expect(u.kind).toBe("union");
+    if (u.kind === "union") {
+      expect(u.members).toHaveLength(2);
+    }
+  });
+
+  it("keeps pure literal unions (\"a\" | \"b\", 2 | -9)", () => {
+    expect(typeValueToString(T.union(T.literal("a"), T.literal("b")))).toBe('"a" | "b"');
+    expect(typeValueToString(T.union(T.literal(2), T.literal(-9)))).toBe("2 | -9");
+  });
+
+  it("keeps undefined/null literal unions untouched", () => {
+    expect(typeValueToString(T.union(T.undefined, T.string))).toBe("undefined | string");
+    expect(typeValueToString(T.union(T.null, T.literal(1)))).toBe("null | 1");
+  });
+
+  it("keeps pure primitive unions untouched (number | string | boolean)", () => {
+    expect(typeValueToString(T.union(T.number, T.string, T.boolean))).toBe(
+      "number | string | boolean",
+    );
+  });
+});

package/src/algebra/__tests__/abs-native.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect } from "vitest";
+import { analyzeFn, evalSource } from "../ast-eval.ts";
+import { abs, num, numLit, unknown } from "../abs.ts";
+import { v, lit } from "../term.ts";
+import { gt, pTrue } from "../pred.ts";
+import { typeValueToString } from "../../type-value.ts";
+import { absToTypeValue } from "../bridge.ts";
+import { formatAbs } from "../format.ts";
+
+function show(a: ReturnType<typeof analyzeFn>): string {
+  return typeValueToString(absToTypeValue(a));
+}
+
+describe("abs-native ast-eval", () => {
+  it("literal arith", () => {
+    const r = analyzeFn(`function f(){ return 1+2*3; }`, "f", []);
+    expect(show(r)).toBe("7");
+  });
+
+  it("param + 1 with constraint via phi in source", () => {
+    const src = `
+      function f(x) {
+        if (x > 0) return x + 1;
+        return 0;
+      }
+    `;
+    const r = analyzeFn(src, "f", [abs(num().shape, v("x"), gt(v("x"), lit(0)), "path")]);
+    // x>0 时 x+1 应带约束
+    expect(r.shape.k === "prim" || r.shape.k === "sum").toBe(true);
+  });
+
+  it("logical && short-circuit", () => {
+    const r = analyzeFn(`function f(){ return false && 1; }`, "f", []);
+    expect(show(r)).toBe("false");
+  });
+
+  it("typeof", () => {
+    const r = analyzeFn(`function f(){ return typeof 1; }`, "f", []);
+    expect(show(r)).toBe('"number"');
+  });
+
+  it("template literal", () => {
+    const r = analyzeFn(`function f(x){ return \`n=\${x}\`; }`, "f", [numLit(3)]);
+    expect(show(r)).toBe('"n=3"');
+  });
+
+  it("first-class arrow", () => {
+    const src = `
+      function f() {
+        const add = (a, b) => a + b;
+        return add(2, 3);
+      }
+    `;
+    const r = analyzeFn(src, "f", []);
+    expect(show(r)).toBe("5");
+  });
+
+  it("div and mod", () => {
+    expect(show(analyzeFn(`function f(){ return 10/2; }`, "f", []))).toBe("5");
+    expect(show(analyzeFn(`function f(){ return 10%3; }`, "f", []))).toBe("1");
+  });
+
+  it("nullish === decided", () => {
+    const r = analyzeFn(`function f(x){ return x === null; }`, "f", [numLit(1)]);
+    expect(show(r)).toBe("false");
+  });
+
+  it("for loop runs with update", () => {
+    const src = `
+      function f() {
+        let s = 0;
+        for (let i = 0; i < 3; i++) s = s + i;
+        return s;
+      }
+    `;
+    const r = analyzeFn(src, "f", []);
+    expect(r.shape.k === "prim" || r.shape.k === "unknown").toBe(true);
+  });
+
+  it("for-of over tuple", () => {
+    const src = `
+      function f(xs) {
+        let s = 0;
+        for (const x of xs) s = s + x;
+        return s;
+      }
+    `;
+    const tup = abs({ k: "tuple", elements: [numLit(1), numLit(2)] }, undefined, undefined, "exact");
+    const r = analyzeFn(src, "f", [tup]);
+    expect(r.shape.k === "prim" || r.shape.k === "unknown").toBe(true);
+  });
+
+  it("while with break", () => {
+    const src = `
+      function f() {
+        let i = 0;
+        while (true) {
+          i = i + 1;
+          if (i > 2) break;
+        }
+        return i;
+      }
+    `;
+    const r = analyzeFn(src, "f", []);
+    expect(r.shape.k === "prim" || r.shape.k === "unknown").toBe(true);
+  });
+
+  it("try/catch binds thrown value", () => {
+    const src = `
+      function f() {
+        try {
+          throw 1;
+        } catch (e) {
+          return e;
+        }
+      }
+    `;
+    const r = analyzeFn(src, "f", []);
+    expect(show(r)).toBe("1");
+  });
+
+  it("string methods fold", () => {
+    expect(show(analyzeFn(`function f(){ return "abc".startsWith("a"); }`, "f", []))).toBe("true");
+    expect(show(analyzeFn(`function f(){ return "abc".toUpperCase(); }`, "f", []))).toBe('"ABC"');
+    expect(show(analyzeFn(`function f(){ return "hello".length; }`, "f", []))).toBe("5");
+  });
+
+  it("array join returns string", () => {
+    const r = analyzeFn(`function f(xs){ return xs.join(","); }`, "f", [
+      abs({ k: "arr", element: abs({ k: "prim", type: "string" }, undefined, undefined, "exact") }, undefined, undefined, "exact"),
+    ]);
+    expect(r.shape).toEqual({ k: "prim", type: "string" });
+  });
+
+  it("Math and global builtins on Abs", () => {
+    expect(show(analyzeFn(`function f(){ return Math.floor(3.7); }`, "f", []))).toBe("3");
+    expect(show(analyzeFn(`function f(){ return Math.max(1, 5); }`, "f", []))).toBe("5");
+    expect(show(analyzeFn(`function f(){ return Array.isArray([]); }`, "f", []))).toBe("true");
+    expect(show(analyzeFn(`function f(){ return parseInt("42"); }`, "f", []))).toBe("42");
+    expect(show(analyzeFn(`function f(){ return Number.isInteger(3); }`, "f", []))).toBe("true");
+  });
+
+  it("Object.keys of object shape", () => {
+    const src = `function f(){ return Object.keys({ a: 1, b: "x" }); }`;
+    const r = analyzeFn(src, "f", []);
+    expect(r.shape.k === "tuple" || r.shape.k === "arr").toBe(true);
+  });
+
+  it("Promise.resolve and then", () => {
+    const src = `
+      function f() {
+        return Promise.resolve(1).then((x) => x + 1);
+      }
+    `;
+    const r = analyzeFn(src, "f", []);
+    expect(r.shape.k).toBe("eff");
+  });
+
+  it("Date.now and RegExp.test", () => {
+    const n = analyzeFn(`function f(){ return Date.now(); }`, "f", []);
+    expect(n.shape.k === "prim" && (n.shape as { type: string }).type === "number").toBe(true);
+    const t = analyzeFn(`function f(){ return /a/.test("a"); }`, "f", []);
+    // 字面正则：.test 可能走 member 路径；至少 boolean 或 unknown
+    expect(t.shape.k === "prim" || t.shape.k === "unknown").toBe(true);
+  });
+
+  it("evalProgramAbs executes top-level", async () => {
+    const { evalProgramAbs } = await import("../ast-eval.ts");
+    const { env, last } = evalProgramAbs(`
+      const x = 1 + 2;
+      function inc(n) { return n + 1; }
+    `);
+    expect(env.vars.get("x")).toBeDefined();
+    expect(env.fns.has("inc")).toBe(true);
+  });
+});

package/src/algebra/__tests__/arithmetic.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect } from "vitest";
+import {
+  add,
+  sub,
+  mul,
+  div,
+  mod,
+  cmp,
+  numLit,
+  numVar,
+  strLit,
+  gtNum,
+  geNum,
+  ltNum,
+  lit,
+  v,
+  termToString,
+  predToString,
+  litValue,
+  implies,
+  simplifyTerm,
+  app,
+} from "../index.ts";
+
+describe("term simplify", () => {
+  it("folds 1+3", () => {
+    expect(simplifyTerm(app("+", [lit(1), lit(3)]))).toEqual(lit(4));
+  });
+  it("x+0 = x", () => {
+    expect(simplifyTerm(app("+", [v("x"), lit(0)]))).toEqual(v("x"));
+  });
+  it("0+x = x", () => {
+    expect(simplifyTerm(app("+", [lit(0), v("x")]))).toEqual(v("x"));
+  });
+  it("x*0 = 0", () => {
+    expect(simplifyTerm(app("*", [v("x"), lit(0)]))).toEqual(lit(0));
+  });
+});
+
+describe("add monotonicity", () => {
+  it("unconstrained any + 1: number|string 并集，term kept（real JS）", () => {
+    // 无契约时 x 是 any；score('x') 合法，+ 可能是拼接也可能是加法
+    const anyA = {
+      shape: { k: "any" as const },
+      term: v("A1"),
+      conf: "path" as const,
+    };
+    const r = add(anyA, numLit(1));
+    expect(r.shape.k).toBe("sum");
+    if (r.shape.k === "sum") {
+      const kinds = r.shape.members.map((m) =>
+        m.shape.k === "prim" ? (m.shape as { type: string }).type : m.shape.k,
+      );
+      expect(kinds.sort()).toEqual(["number", "string"]);
+    }
+    expect(termToString(r.term!)).toBe("(A1 + 1)");
+  });
+
+  it("unconstrained any - * / % → number (JS ToNumber)", () => {
+    const anyA = {
+      shape: { k: "any" as const },
+      term: v("A1"),
+      conf: "path" as const,
+    };
+    const one = numLit(1);
+    for (const [name, r] of [
+      ["sub", sub(anyA, one)],
+      ["mul", mul(anyA, one)],
+      ["div", div(anyA, one)],
+      ["mod", mod(anyA, one)],
+    ] as const) {
+      expect(r.shape, name).toEqual({ k: "prim", type: "number" });
+      expect(r.term, name).toBeDefined();
+    }
+    expect(termToString(sub(anyA, one).term!)).toBe("(A1 - 1)");
+  });
+
+  it("x>0 + 1 ⇒ term>1", () => {
+    const phi = gtNum(v("x"), 0);
+    const r = add(numVar("x", gtNum(v("x"), 0)), numLit(1), phi);
+    expect(termToString(r.term!)).toBe("(x + 1)");
+    expect(r.pred!.op).toBe("gt");
+  });
+
+  it("x>2 + y>3 ⇒ (x+y)>5", () => {
+    const phi = { op: "and" as const, args: [gtNum(v("x"), 2), gtNum(v("y"), 3)] };
+    const r = add(
+      numVar("x", gtNum(v("x"), 2)),
+      numVar("y", gtNum(v("y"), 3)),
+      phi,
+    );
+    expect(r.pred!.op).toBe("gt");
+    if (r.pred!.op === "gt") {
+      expect(r.pred!.b).toEqual(lit(5));
+    }
+  });
+
+  it("x≥1 + 0 literal keeps ≥ via simplify to x", () => {
+    const phi = geNum(v("x"), 1);
+    const r = add(numVar("x", geNum(v("x"), 1)), numLit(0), phi);
+    // x+0 simplifies to x
+    expect(termToString(r.term!)).toBe("x");
+  });
+
+  it("literal 2+3 = 5 exact", () => {
+    const r = add(numLit(2), numLit(3));
+    expect(litValue(r)).toBe(5);
+    expect(r.conf).toBe("exact");
+  });
+});
+
+describe("sub / mul", () => {
+  it("5-2 = 3", () => {
+    expect(litValue(sub(numLit(5), numLit(2)))).toBe(3);
+  });
+  it("x>0 - 1 ⇒ (x-1)>-1? x>0 ⇒ x-1 > -1", () => {
+    const phi = gtNum(v("x"), 0);
+    const r = sub(numVar("x", gtNum(v("x"), 0)), numLit(1), phi);
+    expect(r.term).toBeDefined();
+    expect(r.pred!.op).toBe("gt");
+    if (r.pred!.op === "gt") {
+      expect(r.pred!.b).toEqual(lit(-1));
+    }
+  });
+  it("3*4 = 12", () => {
+    expect(litValue(mul(numLit(3), numLit(4)))).toBe(12);
+  });
+  it("x>0 * 2 ⇒ (x*2)>0", () => {
+    const phi = gtNum(v("x"), 0);
+    const r = mul(numVar("x", gtNum(v("x"), 0)), numLit(2), phi);
+    expect(r.pred!.op).toBe("gt");
+    if (r.pred!.op === "gt") {
+      expect(r.pred!.b).toEqual(lit(0));
+    }
+  });
+});
+
+describe("implies", () => {
+  it("x>0 ⊢ x>0", () => {
+    expect(implies(gtNum(v("x"), 0), gtNum(v("x"), 0))).toBe(true);
+  });
+  it("x>0 ⊢ x≥0", () => {
+    expect(implies(gtNum(v("x"), 0), geNum(v("x"), 0))).toBe(true);
+  });
+  it("x>0 ⊬ x>5", () => {
+    expect(implies(gtNum(v("x"), 0), gtNum(v("x"), 5))).toBe(false);
+  });
+  it("x>5 ⊢ x>0", () => {
+    expect(implies(gtNum(v("x"), 5), gtNum(v("x"), 0))).toBe(true);
+  });
+  it("x>0 ⊢ x+1>1", () => {
+    const phi = gtNum(v("x"), 0);
+    expect(implies(phi, gtNum(app("+", [v("x"), lit(1)]), 1))).toBe(true);
+  });
+  it("x>0 ⊬ x+1>2", () => {
+    const phi = gtNum(v("x"), 0);
+    expect(implies(phi, gtNum(app("+", [v("x"), lit(1)]), 2))).toBe(false);
+  });
+});
+
+describe("cmp under phi", () => {
+  it("x>0, cmp(x, 0, >) → true", () => {
+    const phi = gtNum(v("x"), 0);
+    const r = cmp("gt", numVar("x"), numLit(0), phi);
+    expect(litValue(r)).toBe(true);
+  });
+  it("1<3 → true", () => {
+    expect(litValue(cmp("lt", numLit(1), numLit(3)))).toBe(true);
+  });
+});