@stevenvo780/st-lang 4.0.1 → 4.2.0

package/dist/curry-howard/types.d.ts

@@ -0,0 +1,91 @@
+export type PropType = {
+    kind: 'atom';
+    name: string;
+} | {
+    kind: 'arrow';
+    from: PropType;
+    to: PropType;
+} | {
+    kind: 'product';
+    left: PropType;
+    right: PropType;
+} | {
+    kind: 'sum';
+    left: PropType;
+    right: PropType;
+} | {
+    kind: 'bottom';
+};
+export type LambdaTerm = {
+    kind: 'var';
+    name: string;
+} | {
+    kind: 'app';
+    fn: LambdaTerm;
+    arg: LambdaTerm;
+} | {
+    kind: 'abs';
+    param: string;
+    paramType: PropType;
+    body: LambdaTerm;
+} | {
+    kind: 'pair';
+    fst: LambdaTerm;
+    snd: LambdaTerm;
+} | {
+    kind: 'fst';
+    pair: LambdaTerm;
+} | {
+    kind: 'snd';
+    pair: LambdaTerm;
+} | {
+    kind: 'inl';
+    left: LambdaTerm;
+    rightType: PropType;
+} | {
+    kind: 'inr';
+    right: LambdaTerm;
+    leftType: PropType;
+} | {
+    kind: 'case';
+    scrutinee: LambdaTerm;
+    leftBind: string;
+    leftBody: LambdaTerm;
+    rightBind: string;
+    rightBody: LambdaTerm;
+} | {
+    kind: 'absurd';
+    proofOfFalse: LambdaTerm;
+    resultType: PropType;
+};
+export type ProofRule = 'axiom' | '→I' | '→E' | '∧I' | '∧E-L' | '∧E-R' | '∨I-L' | '∨I-R' | '∨E' | '⊥E';
+export interface ProofTree {
+    rule: ProofRule;
+    conclusion: PropType;
+    premises: ProofTree[];
+    discharged?: {
+        name: string;
+        type: PropType;
+    }[];
+    assumption?: string;
+}
+export type Context = Record<string, PropType>;
+export declare const atom: (name: string) => PropType;
+export declare const arrow: (from: PropType, to: PropType) => PropType;
+export declare const product: (left: PropType, right: PropType) => PropType;
+export declare const sum: (left: PropType, right: PropType) => PropType;
+export declare const bottom: () => PropType;
+export declare const vr: (name: string) => LambdaTerm;
+export declare const app: (fn: LambdaTerm, arg: LambdaTerm) => LambdaTerm;
+export declare const abs: (param: string, paramType: PropType, body: LambdaTerm) => LambdaTerm;
+export declare const pair: (f: LambdaTerm, s: LambdaTerm) => LambdaTerm;
+export declare const fst: (p: LambdaTerm) => LambdaTerm;
+export declare const snd: (p: LambdaTerm) => LambdaTerm;
+export declare const inl: (left: LambdaTerm, rightType: PropType) => LambdaTerm;
+export declare const inr: (right: LambdaTerm, leftType: PropType) => LambdaTerm;
+export declare const cse: (scrutinee: LambdaTerm, leftBind: string, leftBody: LambdaTerm, rightBind: string, rightBody: LambdaTerm) => LambdaTerm;
+export declare const absurd: (proofOfFalse: LambdaTerm, resultType: PropType) => LambdaTerm;
+export declare function eqType(a: PropType, b: PropType): boolean;
+export declare function typeToString(t: PropType): string;
+export declare function termToString(t: LambdaTerm): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/curry-howard/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/curry-howard/types.ts"],"names":[],"mappings":"AAgBA,MAAM,MAAM,QAAQ,GAChB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,QAAQ,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,GACpD;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEvB,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,UAAU,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACrE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,UAAU,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,QAAQ,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,GACtD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,UAAU,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,UAAU,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,UAAU,CAAC;CACvB,GACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,YAAY,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,QAAQ,CAAA;CAAE,CAAC;AAMvE,MAAM,MAAM,SAAS,GACjB,OAAO,GACP,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,MAAM,GACN,MAAM,GACN,MAAM,GACN,MAAM,GACN,IAAI,GACJ,IAAI,CAAC;AAET,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,QAAQ,CAAC;IACrB,QAAQ,EAAE,SAAS,EAAE,CAAC;IAGtB,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,QAAQ,CAAA;KAAE,EAAE,CAAC;IAEhD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AAG/C,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,KAAG,QAAoC,CAAC;AACzE,eAAO,MAAM,KAAK,GAAI,MAAM,QAAQ,EAAE,IAAI,QAAQ,KAAG,QAAyC,CAAC;AAC/F,eAAO,MAAM,OAAO,GAAI,MAAM,QAAQ,EAAE,OAAO,QAAQ,KAAG,QAIxD,CAAC;AACH,eAAO,MAAM,GAAG,GAAI,MAAM,QAAQ,EAAE,OAAO,QAAQ,KAAG,QAA0C,CAAC;AACjG,eAAO,MAAM,MAAM,QAAO,QAAgC,CAAC;AAE3D,eAAO,MAAM,EAAE,GAAI,MAAM,MAAM,KAAG,UAAqC,CAAC;AACxE,eAAO,MAAM,GAAG,GAAI,IAAI,UAAU,EAAE,KAAK,UAAU,KAAG,UAAwC,CAAC;AAC/F,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,EAAE,WAAW,QAAQ,EAAE,MAAM,UAAU,KAAG,UAKzE,CAAC;AACH,eAAO,MAAM,IAAI,GAAI,GAAG,UAAU,EAAE,GAAG,UAAU,KAAG,UAIlD,CAAC;AACH,eAAO,MAAM,GAAG,GAAI,GAAG,UAAU,KAAG,UAAwC,CAAC;AAC7E,eAAO,MAAM,GAAG,GAAI,GAAG,UAAU,KAAG,UAAwC,CAAC;AAC7E,eAAO,MAAM,GAAG,GAAI,MAAM,UAAU,EAAE,WAAW,QAAQ,KAAG,UAI1D,CAAC;AACH,eAAO,MAAM,GAAG,GAAI,OAAO,UAAU,EAAE,UAAU,QAAQ,KAAG,UAI1D,CAAC;AACH,eAAO,MAAM,GAAG,GACd,WAAW,UAAU,EACrB,UAAU,MAAM,EAChB,UAAU,UAAU,EACpB,WAAW,MAAM,EACjB,WAAW,UAAU,KACpB,UAOD,CAAC;AACH,eAAO,MAAM,MAAM,GAAI,cAAc,UAAU,EAAE,YAAY,QAAQ,KAAG,UAItE,CAAC;AAGH,wBAAgB,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAoBxD;AAGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,GAAG,MAAM,CAehD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,CAyBlD"}

package/dist/curry-howard/types.js

@@ -0,0 +1,149 @@
+"use strict";
+// ============================================================
+// Curry-Howard — Tipos y términos
+// ============================================================
+//
+// Correspondencia Curry-Howard:
+//   tipo            ↔  proposición
+//   programa        ↔  prueba
+//   β-reducción     ↔  normalización de pruebas
+//
+// Constructores soportados:
+//   →   (arrow)    →  implicación
+//   ∧   (product)  →  conjunción
+//   ∨   (sum)      →  disyunción
+//   ⊥   (bottom)   →  falso
+//   atom           →  variable proposicional
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.absurd = exports.cse = exports.inr = exports.inl = exports.snd = exports.fst = exports.pair = exports.abs = exports.app = exports.vr = exports.bottom = exports.sum = exports.product = exports.arrow = exports.atom = void 0;
+exports.eqType = eqType;
+exports.typeToString = typeToString;
+exports.termToString = termToString;
+// ---------- Constructores convenientes ----------
+const atom = (name) => ({ kind: 'atom', name });
+exports.atom = atom;
+const arrow = (from, to) => ({ kind: 'arrow', from, to });
+exports.arrow = arrow;
+const product = (left, right) => ({
+    kind: 'product',
+    left,
+    right,
+});
+exports.product = product;
+const sum = (left, right) => ({ kind: 'sum', left, right });
+exports.sum = sum;
+const bottom = () => ({ kind: 'bottom' });
+exports.bottom = bottom;
+const vr = (name) => ({ kind: 'var', name });
+exports.vr = vr;
+const app = (fn, arg) => ({ kind: 'app', fn, arg });
+exports.app = app;
+const abs = (param, paramType, body) => ({
+    kind: 'abs',
+    param,
+    paramType,
+    body,
+});
+exports.abs = abs;
+const pair = (f, s) => ({
+    kind: 'pair',
+    fst: f,
+    snd: s,
+});
+exports.pair = pair;
+const fst = (p) => ({ kind: 'fst', pair: p });
+exports.fst = fst;
+const snd = (p) => ({ kind: 'snd', pair: p });
+exports.snd = snd;
+const inl = (left, rightType) => ({
+    kind: 'inl',
+    left,
+    rightType,
+});
+exports.inl = inl;
+const inr = (right, leftType) => ({
+    kind: 'inr',
+    right,
+    leftType,
+});
+exports.inr = inr;
+const cse = (scrutinee, leftBind, leftBody, rightBind, rightBody) => ({
+    kind: 'case',
+    scrutinee,
+    leftBind,
+    leftBody,
+    rightBind,
+    rightBody,
+});
+exports.cse = cse;
+const absurd = (proofOfFalse, resultType) => ({
+    kind: 'absurd',
+    proofOfFalse,
+    resultType,
+});
+exports.absurd = absurd;
+// ---------- Igualdad estructural de tipos ----------
+function eqType(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case 'atom':
+            return a.name === b.name;
+        case 'arrow': {
+            const bb = b;
+            return eqType(a.from, bb.from) && eqType(a.to, bb.to);
+        }
+        case 'product': {
+            const bb = b;
+            return eqType(a.left, bb.left) && eqType(a.right, bb.right);
+        }
+        case 'sum': {
+            const bb = b;
+            return eqType(a.left, bb.left) && eqType(a.right, bb.right);
+        }
+        case 'bottom':
+            return true;
+    }
+}
+// ---------- Serialización legible ----------
+function typeToString(t) {
+    switch (t.kind) {
+        case 'atom':
+            return t.name;
+        case 'bottom':
+            return '⊥';
+        case 'arrow': {
+            const lhs = t.from.kind === 'arrow' ? `(${typeToString(t.from)})` : typeToString(t.from);
+            return `${lhs} → ${typeToString(t.to)}`;
+        }
+        case 'product':
+            return `(${typeToString(t.left)} ∧ ${typeToString(t.right)})`;
+        case 'sum':
+            return `(${typeToString(t.left)} ∨ ${typeToString(t.right)})`;
+    }
+}
+function termToString(t) {
+    switch (t.kind) {
+        case 'var':
+            return t.name;
+        case 'app':
+            return `(${termToString(t.fn)} ${termToString(t.arg)})`;
+        case 'abs':
+            return `(λ${t.param}:${typeToString(t.paramType)}. ${termToString(t.body)})`;
+        case 'pair':
+            return `⟨${termToString(t.fst)}, ${termToString(t.snd)}⟩`;
+        case 'fst':
+            return `fst(${termToString(t.pair)})`;
+        case 'snd':
+            return `snd(${termToString(t.pair)})`;
+        case 'inl':
+            return `inl(${termToString(t.left)})`;
+        case 'inr':
+            return `inr(${termToString(t.right)})`;
+        case 'case':
+            return `case ${termToString(t.scrutinee)} of inl(${t.leftBind})→${termToString(t.leftBody)} | inr(${t.rightBind})→${termToString(t.rightBody)}`;
+        case 'absurd':
+            return `absurd(${termToString(t.proofOfFalse)} : ${typeToString(t.resultType)})`;
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/curry-howard/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/curry-howard/types.ts"],"names":[],"mappings":"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"}

package/dist/fol-prover-equality/demodulate.d.ts

@@ -0,0 +1,29 @@
+import type { FOLClause, FOLTerm } from '../fol-prover/types';
+import { cloneLiteral } from './term-utils';
+export interface DemodulationRule {
+    from: FOLTerm;
+    to: FOLTerm;
+}
+/**
+ * Apply a list of oriented rewrite rules `from → to` to every position of every literal
+ * in `clause`, repeatedly, until no more rewrites apply (fixed point) or we exceed a
+ * safety bound. Each rule is treated as "matching by unification of the variables in
+ * `from` against the subterm" — i.e. one-way matching, not two-way unification.
+ *
+ * The orientation guarantees termination because every successful rewrite replaces a
+ * larger term (by `compareTerms`) with a smaller one; we additionally cap the total
+ * number of rewrites per call.
+ */
+export declare function demodulate(clause: FOLClause, rewrites: DemodulationRule[]): FOLClause;
+/**
+ * Equality factoring: given a clause containing two positive equality literals
+ *   x = y    and    x = z
+ * with shared lhs, produce the factor   x = y ∨ y ≠ z   (which is logically valid
+ * given the original and helps the saturation process). Returns every distinct factor.
+ *
+ * More generally, for two positive equalities (a=b) and (c=d) where a unifies with c
+ * via σ, emits (a=b ∨ b≠d)·σ.
+ */
+export declare function equalityFactor(clause: FOLClause): FOLClause[];
+export { cloneLiteral };
+//# sourceMappingURL=demodulate.d.ts.map

package/dist/fol-prover-equality/demodulate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demodulate.d.ts","sourceRoot":"","sources":["../../src/fol-prover-equality/demodulate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAc,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE1E,OAAO,EAGL,YAAY,EAQb,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,EAAE,OAAO,CAAC;CACb;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,gBAAgB,EAAE,GAAG,SAAS,CAkCrF;AA0DD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,EAAE,CA0C7D;AAsBD,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/fol-prover-equality/demodulate.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneLiteral = void 0;
+exports.demodulate = demodulate;
+exports.equalityFactor = equalityFactor;
+const unify_1 = require("../fol-prover/unify");
+const term_utils_1 = require("./term-utils");
+Object.defineProperty(exports, "cloneLiteral", { enumerable: true, get: function () { return term_utils_1.cloneLiteral; } });
+/**
+ * Apply a list of oriented rewrite rules `from → to` to every position of every literal
+ * in `clause`, repeatedly, until no more rewrites apply (fixed point) or we exceed a
+ * safety bound. Each rule is treated as "matching by unification of the variables in
+ * `from` against the subterm" — i.e. one-way matching, not two-way unification.
+ *
+ * The orientation guarantees termination because every successful rewrite replaces a
+ * larger term (by `compareTerms`) with a smaller one; we additionally cap the total
+ * number of rewrites per call.
+ */
+function demodulate(clause, rewrites) {
+    if (rewrites.length === 0)
+        return (0, term_utils_1.cloneClause)(clause);
+    // Always orient each rule larger → smaller.
+    const oriented = rewrites
+        .map(({ from, to }) => {
+        if ((0, term_utils_1.compareTerms)(from, to) >= 0)
+            return { from: (0, term_utils_1.cloneTerm)(from), to: (0, term_utils_1.cloneTerm)(to) };
+        return { from: (0, term_utils_1.cloneTerm)(to), to: (0, term_utils_1.cloneTerm)(from) };
+    })
+        .filter(({ from, to }) => !(0, term_utils_1.termsEqual)(from, to));
+    if (oriented.length === 0)
+        return (0, term_utils_1.cloneClause)(clause);
+    const MAX_REWRITES = 256;
+    const cur = (0, term_utils_1.cloneClause)(clause);
+    let rewrites_done = 0;
+    // outer fixed point
+    let changed = true;
+    while (changed && rewrites_done < MAX_REWRITES) {
+        changed = false;
+        for (let li = 0; li < cur.length; li++) {
+            const lit = cur[li];
+            if (lit === undefined)
+                continue;
+            const rewritten = rewriteLiteralOnce(lit, oriented);
+            if (rewritten === null)
+                continue;
+            cur[li] = rewritten;
+            rewrites_done++;
+            changed = true;
+            if (rewrites_done >= MAX_REWRITES)
+                break;
+        }
+    }
+    return cur;
+}
+function rewriteLiteralOnce(lit, rules) {
+    // Try every position; first match wins.
+    for (const pos of (0, term_utils_1.allLiteralPositions)(lit)) {
+        const sub = (0, term_utils_1.getLiteralSubterm)(lit, pos);
+        if (sub === null)
+            continue;
+        for (const rule of rules) {
+            const sigma = matchSubterm(rule.from, sub);
+            if (sigma === null)
+                continue;
+            const replacement = (0, unify_1.applyTerm)(rule.to, sigma);
+            // Must strictly reduce (orientation guarantees this for closed substitutions but
+            // matching may leave variables; double-check).
+            const subSigma = (0, unify_1.applyTerm)(rule.from, sigma);
+            if ((0, term_utils_1.compareTerms)(replacement, subSigma) >= 0)
+                continue;
+            return (0, term_utils_1.replaceLiteralSubterm)(lit, pos, replacement);
+        }
+    }
+    return null;
+}
+/**
+ * One-way matching: try to find σ such that `pattern·σ = subject`. Variables in `subject`
+ * are treated as constants (cannot be bound). Returns the substitution or null.
+ */
+function matchSubterm(pattern, subject) {
+    // We reuse `unify` but enforce one-way matching by walking manually: bind variables
+    // from pattern only.
+    const sigma = new Map();
+    if (!matchInto(pattern, subject, sigma))
+        return null;
+    return sigma;
+}
+function matchInto(p, s, sigma) {
+    if (p.kind === 'var') {
+        const existing = sigma.get(p.name);
+        if (existing !== undefined)
+            return (0, term_utils_1.termsEqual)(existing, s);
+        sigma.set(p.name, (0, term_utils_1.cloneTerm)(s));
+        return true;
+    }
+    if (p.kind === 'const') {
+        return s.kind === 'const' && p.name === s.name;
+    }
+    // p is func
+    if (s.kind !== 'func')
+        return false;
+    if (p.name !== s.name)
+        return false;
+    const pa = p.args ?? [];
+    const sa = s.args ?? [];
+    if (pa.length !== sa.length)
+        return false;
+    for (let i = 0; i < pa.length; i++) {
+        const pi = pa[i];
+        const si = sa[i];
+        if (pi === undefined || si === undefined)
+            return false;
+        if (!matchInto(pi, si, sigma))
+            return false;
+    }
+    return true;
+}
+/**
+ * Equality factoring: given a clause containing two positive equality literals
+ *   x = y    and    x = z
+ * with shared lhs, produce the factor   x = y ∨ y ≠ z   (which is logically valid
+ * given the original and helps the saturation process). Returns every distinct factor.
+ *
+ * More generally, for two positive equalities (a=b) and (c=d) where a unifies with c
+ * via σ, emits (a=b ∨ b≠d)·σ.
+ */
+function equalityFactor(clause) {
+    const out = [];
+    for (let i = 0; i < clause.length; i++) {
+        const li = clause[i];
+        if (li === undefined || li.negated || !(0, term_utils_1.isEqualityLiteral)(li))
+            continue;
+        const a = li.args[0];
+        const b = li.args[1];
+        if (a === undefined || b === undefined)
+            continue;
+        for (let j = i + 1; j < clause.length; j++) {
+            const lj = clause[j];
+            if (lj === undefined || lj.negated || !(0, term_utils_1.isEqualityLiteral)(lj))
+                continue;
+            const c = lj.args[0];
+            const d = lj.args[1];
+            if (c === undefined || d === undefined)
+                continue;
+            // Try both alignments (a~c) and (a~d) to cover the "shared lhs" case symmetrically.
+            for (const [u, v] of [
+                [c, d],
+                [d, c],
+            ]) {
+                const sigma = new Map();
+                const r = (0, unify_1.unify)(a, u, sigma);
+                if (r === null)
+                    continue;
+                // Produce  (a = b ∨ b ≠ v)·σ along with the rest of the clause.
+                const aSigma = (0, unify_1.applyTerm)(a, sigma);
+                const bSigma = (0, unify_1.applyTerm)(b, sigma);
+                const vSigma = (0, unify_1.applyTerm)(v, sigma);
+                // Skip degenerate factors where b ≡ v under σ (would yield a tautology after refl).
+                if ((0, term_utils_1.termsEqual)(bSigma, vSigma))
+                    continue;
+                const newClause = [];
+                newClause.push({ negated: false, predicate: li.predicate, args: [aSigma, bSigma] });
+                newClause.push({ negated: true, predicate: li.predicate, args: [bSigma, vSigma] });
+                for (let k = 0; k < clause.length; k++) {
+                    if (k === i || k === j)
+                        continue;
+                    const lk = clause[k];
+                    if (lk === undefined)
+                        continue;
+                    newClause.push(applyLitLocal(lk, sigma));
+                }
+                out.push(dedup(newClause));
+            }
+        }
+    }
+    return out;
+}
+function applyLitLocal(lit, sigma) {
+    return {
+        negated: lit.negated,
+        predicate: lit.predicate,
+        args: lit.args.map((a) => (0, unify_1.applyTerm)(a, sigma)),
+    };
+}
+function dedup(c) {
+    const seen = new Set();
+    const out = [];
+    for (const lit of c) {
+        const k = `${lit.negated ? '!' : ''}${lit.predicate}(${lit.args.map(term_utils_1.termKey).join(',')})`;
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(lit);
+    }
+    return out;
+}
+//# sourceMappingURL=demodulate.js.map

package/dist/fol-prover-equality/demodulate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"demodulate.js","sourceRoot":"","sources":["../../src/fol-prover-equality/demodulate.ts"],"names":[],"mappings":"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"}

package/dist/fol-prover-equality/index.d.ts

@@ -0,0 +1,8 @@
+export type { EqualityProveResult, EqualityProveStep, EqualityProveOptions, EqualityRule, } from './types';
+export { EQ_PREDICATE } from './types';
+export { paramodulate, paramodulateAll, paramodulateWithSubst, reflexivityResolve, } from './paramodulate';
+export { demodulate, equalityFactor } from './demodulate';
+export type { DemodulationRule } from './demodulate';
+export { proveWithEquality } from './prove';
+export { allLiteralPositions, allPositions, compareTerms, isEqualityLiteral, replaceAt, replaceLiteralSubterm, termAt, } from './term-utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/fol-prover-equality/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fol-prover-equality/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,YAAY,GACb,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,EACL,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC1D,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EACL,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,SAAS,EACT,qBAAqB,EACrB,MAAM,GACP,MAAM,cAAc,CAAC"}

package/dist/fol-prover-equality/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.termAt = exports.replaceLiteralSubterm = exports.replaceAt = exports.isEqualityLiteral = exports.compareTerms = exports.allPositions = exports.allLiteralPositions = exports.proveWithEquality = exports.equalityFactor = exports.demodulate = exports.reflexivityResolve = exports.paramodulateWithSubst = exports.paramodulateAll = exports.paramodulate = exports.EQ_PREDICATE = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "EQ_PREDICATE", { enumerable: true, get: function () { return types_1.EQ_PREDICATE; } });
+var paramodulate_1 = require("./paramodulate");
+Object.defineProperty(exports, "paramodulate", { enumerable: true, get: function () { return paramodulate_1.paramodulate; } });
+Object.defineProperty(exports, "paramodulateAll", { enumerable: true, get: function () { return paramodulate_1.paramodulateAll; } });
+Object.defineProperty(exports, "paramodulateWithSubst", { enumerable: true, get: function () { return paramodulate_1.paramodulateWithSubst; } });
+Object.defineProperty(exports, "reflexivityResolve", { enumerable: true, get: function () { return paramodulate_1.reflexivityResolve; } });
+var demodulate_1 = require("./demodulate");
+Object.defineProperty(exports, "demodulate", { enumerable: true, get: function () { return demodulate_1.demodulate; } });
+Object.defineProperty(exports, "equalityFactor", { enumerable: true, get: function () { return demodulate_1.equalityFactor; } });
+var prove_1 = require("./prove");
+Object.defineProperty(exports, "proveWithEquality", { enumerable: true, get: function () { return prove_1.proveWithEquality; } });
+var term_utils_1 = require("./term-utils");
+Object.defineProperty(exports, "allLiteralPositions", { enumerable: true, get: function () { return term_utils_1.allLiteralPositions; } });
+Object.defineProperty(exports, "allPositions", { enumerable: true, get: function () { return term_utils_1.allPositions; } });
+Object.defineProperty(exports, "compareTerms", { enumerable: true, get: function () { return term_utils_1.compareTerms; } });
+Object.defineProperty(exports, "isEqualityLiteral", { enumerable: true, get: function () { return term_utils_1.isEqualityLiteral; } });
+Object.defineProperty(exports, "replaceAt", { enumerable: true, get: function () { return term_utils_1.replaceAt; } });
+Object.defineProperty(exports, "replaceLiteralSubterm", { enumerable: true, get: function () { return term_utils_1.replaceLiteralSubterm; } });
+Object.defineProperty(exports, "termAt", { enumerable: true, get: function () { return term_utils_1.termAt; } });
+//# sourceMappingURL=index.js.map

package/dist/fol-prover-equality/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/fol-prover-equality/index.ts"],"names":[],"mappings":";;;AAMA,iCAAuC;AAA9B,qGAAA,YAAY,OAAA;AAErB,+CAKwB;AAJtB,4GAAA,YAAY,OAAA;AACZ,+GAAA,eAAe,OAAA;AACf,qHAAA,qBAAqB,OAAA;AACrB,kHAAA,kBAAkB,OAAA;AAEpB,2CAA0D;AAAjD,wGAAA,UAAU,OAAA;AAAE,4GAAA,cAAc,OAAA;AAEnC,iCAA4C;AAAnC,0GAAA,iBAAiB,OAAA;AAC1B,2CAQsB;AAPpB,iHAAA,mBAAmB,OAAA;AACnB,0GAAA,YAAY,OAAA;AACZ,0GAAA,YAAY,OAAA;AACZ,+GAAA,iBAAiB,OAAA;AACjB,uGAAA,SAAS,OAAA;AACT,mHAAA,qBAAqB,OAAA;AACrB,oGAAA,MAAM,OAAA"}

package/dist/fol-prover-equality/paramodulate.d.ts

@@ -0,0 +1,46 @@
+import type { FOLClause, FOLTerm } from '../fol-prover/types';
+import { cloneClause, isEqualityLiteral, termKey, termsEqual } from './term-utils';
+export interface ParamodResult {
+    resolvent: FOLClause;
+    substitution: Map<string, FOLTerm>;
+}
+/**
+ * Paramodulation:
+ *
+ *   from C ∨ (s = t)         (eqClause, eq_idx points to the s=t literal)
+ *   and  D[u]                (target clause, target_idx points to literal containing u,
+ *                            target_pos points inside that literal's args)
+ *   if unify(s, u) = σ then  (C ∨ D[u → t])·σ
+ *
+ * The direction is fixed: args[0] = s (lhs), args[1] = t (rhs). To paramodulate
+ * "in the other direction" callers should retry with the equation flipped (see
+ * `paramodulateAll` for the symmetric enumeration).
+ *
+ * Returns null when the literals can't paramodulate (wrong kind, unification fails, etc.).
+ */
+export declare function paramodulate(c1Raw: FOLClause, eq_idx: number, c2Raw: FOLClause, target_idx: number, target_pos: number[]): FOLClause | null;
+export declare function paramodulateWithSubst(c1Raw: FOLClause, eq_idx: number, c2Raw: FOLClause, target_idx: number, target_pos: number[]): ParamodResult | null;
+/**
+ * Generate all paramodulation children between two clauses considering both directions
+ * of every equality literal in either clause and every interior position of every
+ * non-equality target literal in the other.
+ */
+export interface ParamodAllStep {
+    fromEqClause: number;
+    fromTargetClause: number;
+    eqIdx: number;
+    targetIdx: number;
+    targetPos: number[];
+    flipped: boolean;
+    resolvent: FOLClause;
+    substitution: Map<string, FOLTerm>;
+}
+export declare function paramodulateAll(idxA: number, cA: FOLClause, idxB: number, cB: FOLClause): ParamodAllStep[];
+/**
+ * Reflexivity resolution: drop a literal of the form ¬(t = t) from a clause.
+ * Useful both during search and for proving reflexive goals.
+ */
+export declare function reflexivityResolve(c: FOLClause): FOLClause | null;
+/** Re-export utilities used by tests. */
+export { isEqualityLiteral, termKey, termsEqual, cloneClause };
+//# sourceMappingURL=paramodulate.d.ts.map

package/dist/fol-prover-equality/paramodulate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paramodulate.d.ts","sourceRoot":"","sources":["../../src/fol-prover-equality/paramodulate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9D,OAAO,EAEL,WAAW,EAGX,iBAAiB,EAIjB,OAAO,EACP,UAAU,EACX,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAAE,GACnB,SAAS,GAAG,IAAI,CAGlB;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAAE,GACnB,aAAa,GAAG,IAAI,CAuCtB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,SAAS,EACb,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,SAAS,GACZ,cAAc,EAAE,CAKlB;AAkED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI,CAkBjE;AAED,yCAAyC;AACzC,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC"}