@stevenvo780/st-lang 4.0.1 → 4.2.0

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneClause = exports.termsEqual = exports.termKey = exports.isEqualityLiteral = void 0;
+exports.paramodulate = paramodulate;
+exports.paramodulateWithSubst = paramodulateWithSubst;
+exports.paramodulateAll = paramodulateAll;
+exports.reflexivityResolve = reflexivityResolve;
+const unify_1 = require("../fol-prover/unify");
+const term_utils_1 = require("./term-utils");
+Object.defineProperty(exports, "cloneClause", { enumerable: true, get: function () { return term_utils_1.cloneClause; } });
+Object.defineProperty(exports, "isEqualityLiteral", { enumerable: true, get: function () { return term_utils_1.isEqualityLiteral; } });
+Object.defineProperty(exports, "termKey", { enumerable: true, get: function () { return term_utils_1.termKey; } });
+Object.defineProperty(exports, "termsEqual", { enumerable: true, get: function () { return term_utils_1.termsEqual; } });
+/**
+ * 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.).
+ */
+function paramodulate(c1Raw, eq_idx, c2Raw, target_idx, target_pos) {
+    const out = paramodulateWithSubst(c1Raw, eq_idx, c2Raw, target_idx, target_pos);
+    return out ? out.resolvent : null;
+}
+function paramodulateWithSubst(c1Raw, eq_idx, c2Raw, target_idx, target_pos) {
+    // Standardize variables apart between the two parents.
+    const c1 = (0, term_utils_1.freshenClause)(c1Raw);
+    const c2 = (0, term_utils_1.freshenClause)(c2Raw);
+    const eqLit = c1[eq_idx];
+    if (eqLit === undefined)
+        return null;
+    if (!(0, term_utils_1.isEqualityLiteral)(eqLit))
+        return null;
+    if (eqLit.negated)
+        return null;
+    const s = eqLit.args[0];
+    const t = eqLit.args[1];
+    if (s === undefined || t === undefined)
+        return null;
+    const target = c2[target_idx];
+    if (target === undefined)
+        return null;
+    const u = (0, term_utils_1.getLiteralSubterm)(target, target_pos);
+    if (u === null)
+        return null;
+    // Don't try to paramodulate into a bare variable subterm — that produces
+    // an explosion of useless rewrites equivalent to factoring.
+    if (u.kind === 'var')
+        return null;
+    const sigma = new Map();
+    const unified = (0, unify_1.unify)(s, u, sigma);
+    if (unified === null)
+        return null;
+    // Build C·σ (rest of clause 1 minus the equation literal)
+    const rest1 = c1.filter((_, k) => k !== eq_idx).map((lit) => (0, unify_1.applyLiteral)(lit, sigma));
+    // Build the rewritten target: replace u with t at target_pos, then apply σ.
+    const rewritten = (0, term_utils_1.replaceLiteralSubterm)(target, target_pos, (0, unify_1.applyTerm)(t, sigma));
+    const rewrittenSigma = (0, unify_1.applyLiteral)(rewritten, sigma);
+    const rest2 = c2.filter((_, k) => k !== target_idx).map((lit) => (0, unify_1.applyLiteral)(lit, sigma));
+    const merged = factor([...rest1, rewrittenSigma, ...rest2]);
+    return { resolvent: merged, substitution: sigma };
+}
+function paramodulateAll(idxA, cA, idxB, cB) {
+    const out = [];
+    collectParamods(idxA, cA, idxB, cB, false, out);
+    if (idxA !== idxB)
+        collectParamods(idxB, cB, idxA, cA, false, out);
+    return out;
+}
+function collectParamods(idxEq, cEq, idxTgt, cTgt, _unusedFlip, out) {
+    for (let i = 0; i < cEq.length; i++) {
+        const lit = cEq[i];
+        if (lit === undefined)
+            continue;
+        if (!(0, term_utils_1.isEqualityLiteral)(lit) || lit.negated)
+            continue;
+        const lhs = lit.args[0];
+        const rhs = lit.args[1];
+        if (lhs === undefined || rhs === undefined)
+            continue;
+        for (const flip of [false, true]) {
+            // Build a virtual clause where, when flip=true, the equation is t = s instead of s = t.
+            const directedEq = flip
+                ? cEq.map((l, k) => k === i
+                    ? {
+                        negated: l.negated,
+                        predicate: l.predicate,
+                        args: [(0, term_utils_1.cloneTerm)(rhs), (0, term_utils_1.cloneTerm)(lhs)],
+                    }
+                    : l)
+                : cEq;
+            for (let j = 0; j < cTgt.length; j++) {
+                const tgtLit = cTgt[j];
+                if (tgtLit === undefined)
+                    continue;
+                for (const pos of (0, term_utils_1.allLiteralPositions)(tgtLit)) {
+                    const result = paramodulateWithSubst(directedEq, i, cTgt, j, pos);
+                    if (result === null)
+                        continue;
+                    out.push({
+                        fromEqClause: idxEq,
+                        fromTargetClause: idxTgt,
+                        eqIdx: i,
+                        targetIdx: j,
+                        targetPos: pos,
+                        flipped: flip,
+                        resolvent: result.resolvent,
+                        substitution: result.substitution,
+                    });
+                }
+            }
+        }
+    }
+}
+function factor(c) {
+    const seen = new Set();
+    const out = [];
+    for (const lit of c) {
+        const k = (0, term_utils_1.literalKey)(lit);
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(lit);
+    }
+    return out;
+}
+/**
+ * Reflexivity resolution: drop a literal of the form ¬(t = t) from a clause.
+ * Useful both during search and for proving reflexive goals.
+ */
+function reflexivityResolve(c) {
+    for (let i = 0; i < c.length; i++) {
+        const lit = c[i];
+        if (lit === undefined)
+            continue;
+        if (!(0, term_utils_1.isEqualityLiteral)(lit))
+            continue;
+        if (!lit.negated)
+            continue;
+        const a = lit.args[0];
+        const b = lit.args[1];
+        if (a === undefined || b === undefined)
+            continue;
+        const sigma = new Map();
+        const u = (0, unify_1.unify)(a, b, sigma);
+        if (u === null)
+            continue;
+        return (0, unify_1.applyClause)(c.filter((_, k) => k !== i), sigma);
+    }
+    return null;
+}
+//# sourceMappingURL=paramodulate.js.map

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

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

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

@@ -0,0 +1,7 @@
+import type { Formula } from '../types';
+import type { FOLClause } from '../fol-prover/types';
+import type { EqualityProveOptions, EqualityProveResult } from './types';
+declare function rewriteEqualityClause(c: FOLClause): FOLClause;
+export declare function proveWithEquality(premises: Formula[], goal: Formula, opts?: EqualityProveOptions): EqualityProveResult;
+export { rewriteEqualityClause };
+//# sourceMappingURL=prove.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prove.d.ts","sourceRoot":"","sources":["../../src/fol-prover-equality/prove.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAuB,MAAM,qBAAqB,CAAC;AAO1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAqB,MAAM,SAAS,CAAC;AAgC5F,iBAAS,qBAAqB,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAEtD;AA4FD,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,EAAE,OAAO,EACb,IAAI,GAAE,oBAAyB,GAC9B,mBAAmB,CA6KrB;AAGD,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

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

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proveWithEquality = proveWithEquality;
+exports.rewriteEqualityClause = rewriteEqualityClause;
+const cnf_1 = require("../fol-prover/cnf");
+const resolve_1 = require("../fol-prover/resolve");
+const unify_1 = require("../fol-prover/unify");
+const paramodulate_1 = require("./paramodulate");
+const demodulate_1 = require("./demodulate");
+const term_utils_1 = require("./term-utils");
+const types_1 = require("./types");
+const DEFAULT_TIMEOUT_MS = 3000;
+const DEFAULT_MAX_STEPS = 5000;
+/**
+ * Translate the FOL Formula's `equals` kind to our internal equality predicate.
+ * Currently the project's CNF pipeline does not natively know about `equals`; it
+ * would turn an `equals(t1, t2)` formula into a predicate literal with two
+ * parameters by name. To bring it into the equality prover we walk the Formula
+ * tree and rewrite any `equals` node into a `predicate` with the special name
+ * `__eq__` whose params are the term strings — but since the existing CNF only
+ * supports name-based terms, we explicitly construct the FOLClause for the goal
+ * and premises that contain equality.
+ *
+ * Strategy: parse premises and goal via the usual `toCNF`. After CNF, walk every
+ * literal and rewrite predicates that look like equalities into the canonical
+ * `__eq__(arg0, arg1)` form. The user-facing convention is: any literal of the
+ * form `equals(a, b)` (either as a predicate named "equals", "=", or "eq") is
+ * treated as an equality.
+ */
+const EQUALITY_ALIASES = new Set(['equals', '=', 'eq', '==']);
+function rewriteEqualityLiteral(lit) {
+    if (EQUALITY_ALIASES.has(lit.predicate) && lit.args.length === 2) {
+        return { negated: lit.negated, predicate: types_1.EQ_PREDICATE, args: lit.args };
+    }
+    return lit;
+}
+function rewriteEqualityClause(c) {
+    return c.map(rewriteEqualityLiteral);
+}
+function preprocessFormula(f) {
+    if (f.kind === 'equals') {
+        const params = (f.params ?? f.terms ?? []).slice();
+        const newF = { kind: 'predicate', name: '=', params, terms: params };
+        if (f.args !== undefined)
+            newF.args = f.args.map(preprocessFormula);
+        return newF;
+    }
+    if (f.args === undefined)
+        return f;
+    return { ...f, args: f.args.map(preprocessFormula) };
+}
+function reflexivityClauses() {
+    // The axiom ∀x. x = x  →  CNF clause  __eq__(x, x)
+    return [
+        [
+            {
+                negated: false,
+                predicate: types_1.EQ_PREDICATE,
+                args: [
+                    { kind: 'var', name: '__refl_x' },
+                    { kind: 'var', name: '__refl_x' },
+                ],
+            },
+        ],
+    ];
+}
+function isTautology(c) {
+    // Standard tautology: P and ¬P with identical args.
+    for (let i = 0; i < c.length; i++) {
+        for (let j = i + 1; j < c.length; j++) {
+            const li = c[i];
+            const lj = c[j];
+            if (li === undefined || lj === undefined)
+                continue;
+            if (li.negated === lj.negated)
+                continue;
+            if (li.predicate !== lj.predicate)
+                continue;
+            if (li.args.length !== lj.args.length)
+                continue;
+            let same = true;
+            for (let k = 0; k < li.args.length; k++) {
+                const a = li.args[k];
+                const b = lj.args[k];
+                if (a === undefined || b === undefined) {
+                    same = false;
+                    break;
+                }
+                if (!(0, term_utils_1.termsEqual)(a, b)) {
+                    same = false;
+                    break;
+                }
+            }
+            if (same)
+                return true;
+        }
+    }
+    // Reflexive tautology: positive __eq__(t, t).
+    for (const lit of c) {
+        if (!(0, term_utils_1.isEqualityLiteral)(lit) || lit.negated)
+            continue;
+        const a = lit.args[0];
+        const b = lit.args[1];
+        if (a === undefined || b === undefined)
+            continue;
+        if ((0, term_utils_1.termsEqual)(a, b))
+            return true;
+    }
+    return false;
+}
+function reflexivityResolveStep(c) {
+    for (let i = 0; i < c.length; i++) {
+        const lit = c[i];
+        if (lit === undefined)
+            continue;
+        if (!(0, term_utils_1.isEqualityLiteral)(lit))
+            continue;
+        if (!lit.negated)
+            continue;
+        const a = lit.args[0];
+        const b = lit.args[1];
+        if (a === undefined || b === undefined)
+            continue;
+        const sigma = new Map();
+        const u = (0, unify_1.unify)(a, b, sigma);
+        if (u === null)
+            continue;
+        const rest = c
+            .filter((_, k) => k !== i)
+            .map((l) => ({
+            negated: l.negated,
+            predicate: l.predicate,
+            args: l.args.map((t) => (0, unify_1.applyTerm)(t, sigma)),
+        }));
+        return { clause: rest, sigma };
+    }
+    return null;
+}
+function proveWithEquality(premises, goal, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxSteps = opts.maxSteps ?? DEFAULT_MAX_STEPS;
+    // Rewrite `equals` nodes so CNF treats them as binary predicates we can recognise.
+    const preProcessedPremises = premises.map(preprocessFormula);
+    const preGoal = preprocessFormula(goal);
+    const rawPremiseClauses = preProcessedPremises.flatMap((p) => (0, cnf_1.toCNF)(p));
+    const negatedGoal = { kind: 'not', args: [preGoal] };
+    const rawNegGoalClauses = (0, cnf_1.toCNF)(negatedGoal);
+    const premiseClauses = rawPremiseClauses.map(rewriteEqualityClause);
+    const negGoalClauses = rawNegGoalClauses.map(rewriteEqualityClause);
+    if (premiseClauses.some((c) => c.length === 0) || negGoalClauses.some((c) => c.length === 0)) {
+        return { proven: true, steps: [] };
+    }
+    const all = [];
+    const seen = new Set();
+    const addClause = (c) => {
+        if (isTautology(c))
+            return { idx: -1, novel: false };
+        const key = (0, term_utils_1.clauseKey)(c);
+        const existingIdx = all.findIndex((existing) => (0, term_utils_1.clauseKey)(existing) === key);
+        if (existingIdx >= 0)
+            return { idx: existingIdx, novel: false };
+        seen.add(key);
+        all.push(c);
+        return { idx: all.length - 1, novel: true };
+    };
+    // Seed: reflexivity axiom (used by paramodulation when a clause demands x = x).
+    for (const c of reflexivityClauses())
+        addClause(c);
+    for (const c of premiseClauses)
+        addClause(c);
+    for (const c of negGoalClauses)
+        addClause(c);
+    const steps = [];
+    const startedAt = Date.now();
+    const finishSuccess = () => ({ proven: true, steps });
+    // Saturation loop: classic given-clause-ish. For each new clause, try resolution
+    // and paramodulation with every older clause; apply reflexivity resolution and
+    // equality factoring inline.
+    let cursor = 0;
+    while (cursor < all.length) {
+        if (Date.now() - startedAt > timeoutMs) {
+            return { proven: false, steps, timeoutHit: true };
+        }
+        if (steps.length >= maxSteps) {
+            return { proven: false, steps, reason: 'max-steps' };
+        }
+        const ci = all[cursor];
+        if (ci === undefined) {
+            cursor++;
+            continue;
+        }
+        // Reflexivity resolution on the current clause itself.
+        {
+            const r = reflexivityResolveStep(ci);
+            if (r !== null) {
+                if (r.clause.length === 0) {
+                    steps.push({
+                        rule: 'reflex',
+                        from: [cursor],
+                        result: r.clause,
+                        substitution: (0, term_utils_1.substToRecordTerm)(r.sigma),
+                    });
+                    return finishSuccess();
+                }
+                const { idx, novel } = addClause(r.clause);
+                if (novel && idx >= 0) {
+                    steps.push({
+                        rule: 'reflex',
+                        from: [cursor],
+                        result: r.clause,
+                        substitution: (0, term_utils_1.substToRecordTerm)(r.sigma),
+                    });
+                }
+            }
+        }
+        // Equality factoring on the current clause.
+        for (const factored of (0, demodulate_1.equalityFactor)(ci)) {
+            const { idx, novel } = addClause(factored);
+            if (novel && idx >= 0) {
+                steps.push({
+                    rule: 'factor',
+                    from: [cursor],
+                    result: factored,
+                    substitution: {},
+                });
+                if (factored.length === 0)
+                    return finishSuccess();
+            }
+            if (steps.length >= maxSteps)
+                return { proven: false, steps, reason: 'max-steps' };
+        }
+        for (let j = 0; j <= cursor; j++) {
+            if (Date.now() - startedAt > timeoutMs) {
+                return { proven: false, steps, timeoutHit: true };
+            }
+            const cj = all[j];
+            if (cj === undefined)
+                continue;
+            // --- Binary resolution
+            const resolvents = (0, resolve_1.resolveWithRecord)({ c1Idx: cursor, c2Idx: j, c1: ci, c2: cj });
+            for (const r of resolvents) {
+                if (r.resolvent.length === 0) {
+                    steps.push({
+                        rule: 'resolve',
+                        from: [cursor, j],
+                        result: r.resolvent,
+                        substitution: {},
+                    });
+                    return finishSuccess();
+                }
+                const { idx, novel } = addClause(r.resolvent);
+                if (novel && idx >= 0) {
+                    steps.push({
+                        rule: 'resolve',
+                        from: [cursor, j],
+                        result: r.resolvent,
+                        substitution: {},
+                    });
+                    if (steps.length >= maxSteps)
+                        return { proven: false, steps, reason: 'max-steps' };
+                }
+            }
+            // --- Paramodulation in both directions
+            const paramods = (0, paramodulate_1.paramodulateAll)(cursor, ci, j, cj);
+            for (const p of paramods) {
+                if (p.resolvent.length === 0) {
+                    steps.push({
+                        rule: 'paramod',
+                        from: [p.fromEqClause, p.fromTargetClause],
+                        result: p.resolvent,
+                        substitution: (0, term_utils_1.substToRecordTerm)(p.substitution),
+                    });
+                    return finishSuccess();
+                }
+                // Apply reflexivity resolution to the paramodulant before adding; this
+                // catches the common pattern where paramod produces e.g. ¬(a = a) ∨ ...
+                let toAdd = p.resolvent;
+                const reflexed = reflexivityResolveStep(toAdd);
+                if (reflexed !== null)
+                    toAdd = reflexed.clause;
+                if (toAdd.length === 0) {
+                    steps.push({
+                        rule: 'paramod',
+                        from: [p.fromEqClause, p.fromTargetClause],
+                        result: toAdd,
+                        substitution: (0, term_utils_1.substToRecordTerm)(p.substitution),
+                    });
+                    return finishSuccess();
+                }
+                const { idx, novel } = addClause(toAdd);
+                if (novel && idx >= 0) {
+                    steps.push({
+                        rule: 'paramod',
+                        from: [p.fromEqClause, p.fromTargetClause],
+                        result: toAdd,
+                        substitution: (0, term_utils_1.substToRecordTerm)(p.substitution),
+                    });
+                    if (steps.length >= maxSteps)
+                        return { proven: false, steps, reason: 'max-steps' };
+                }
+            }
+        }
+        cursor++;
+    }
+    return { proven: false, steps, reason: 'saturated' };
+}
+//# sourceMappingURL=prove.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prove.js","sourceRoot":"","sources":["../../src/fol-prover-equality/prove.ts"],"names":[],"mappings":";;AAsIA,8CAiLC;AAGQ,sDAAqB;AAxT9B,2CAA0C;AAC1C,mDAA0D;AAC1D,+CAAuD;AACvD,iDAAiD;AACjD,6CAA8C;AAC9C,6CAA2F;AAE3F,mCAAuC;AAEvC,MAAM,kBAAkB,GAAG,IAAI,CAAC;AAChC,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAE/B;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAE9D,SAAS,sBAAsB,CAAC,GAAe;IAC7C,IAAI,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,SAAS,EAAE,oBAAY,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC;IAC3E,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,qBAAqB,CAAC,CAAY;IACzC,OAAO,CAAC,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC;AACvC,CAAC;AAED,SAAS,iBAAiB,CAAC,CAAU;IACnC,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QACxB,MAAM,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QACnD,MAAM,IAAI,GAAY,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAC9E,IAAI,CAAC,CAAC,IAAI,KAAK,SAAS;YAAE,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QACpE,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,CAAC,CAAC;IACnC,OAAO,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE,CAAC;AACvD,CAAC;AAED,SAAS,kBAAkB;IACzB,mDAAmD;IACnD,OAAO;QACL;YACE;gBACE,OAAO,EAAE,KAAK;gBACd,SAAS,EAAE,oBAAY;gBACvB,IAAI,EAAE;oBACJ,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE;oBACjC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE;iBAClC;aACF;SACF;KACF,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAAC,CAAY;IAC/B,oDAAoD;IACpD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAChB,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAChB,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,KAAK,SAAS;gBAAE,SAAS;YACnD,IAAI,EAAE,CAAC,OAAO,KAAK,EAAE,CAAC,OAAO;gBAAE,SAAS;YACxC,IAAI,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC,SAAS;gBAAE,SAAS;YAC5C,IAAI,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,EAAE,CAAC,IAAI,CAAC,MAAM;gBAAE,SAAS;YAChD,IAAI,IAAI,GAAG,IAAI,CAAC;YAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACxC,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACrB,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACrB,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;oBACvC,IAAI,GAAG,KAAK,CAAC;oBACb,MAAM;gBACR,CAAC;gBACD,IAAI,CAAC,IAAA,uBAAU,EAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;oBACtB,IAAI,GAAG,KAAK,CAAC;oBACb,MAAM;gBACR,CAAC;YACH,CAAC;YACD,IAAI,IAAI;gBAAE,OAAO,IAAI,CAAC;QACxB,CAAC;IACH,CAAC;IACD,8CAA8C;IAC9C,KAAK,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;QACpB,IAAI,CAAC,IAAA,8BAAiB,EAAC,GAAG,CAAC,IAAI,GAAG,CAAC,OAAO;YAAE,SAAS;QACrD,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,SAAS;YAAE,SAAS;QACjD,IAAI,IAAA,uBAAU,EAAC,CAAC,EAAE,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;IACpC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,sBAAsB,CAC7B,CAAY;IAEZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACjB,IAAI,GAAG,KAAK,SAAS;YAAE,SAAS;QAChC,IAAI,CAAC,IAAA,8BAAiB,EAAC,GAAG,CAAC;YAAE,SAAS;QACtC,IAAI,CAAC,GAAG,CAAC,OAAO;YAAE,SAAS;QAC3B,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,SAAS;YAAE,SAAS;QACjD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAmB,CAAC;QACzC,MAAM,CAAC,GAAG,IAAA,aAAK,EAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;QAC7B,IAAI,CAAC,KAAK,IAAI;YAAE,SAAS;QACzB,MAAM,IAAI,GAAG,CAAC;aACX,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;aACzB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACX,OAAO,EAAE,CAAC,CAAC,OAAO;YAClB,SAAS,EAAE,CAAC,CAAC,SAAS;YACtB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,iBAAS,EAAC,CAAC,EAAE,KAAK,CAAC,CAAC;SAC7C,CAAC,CAAC,CAAC;QACN,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IACjC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAgB,iBAAiB,CAC/B,QAAmB,EACnB,IAAa,EACb,OAA6B,EAAE;IAE/B,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,kBAAkB,CAAC;IACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,iBAAiB,CAAC;IAEpD,mFAAmF;IACnF,MAAM,oBAAoB,GAAG,QAAQ,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAC7D,MAAM,OAAO,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAExC,MAAM,iBAAiB,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,WAAK,EAAC,CAAC,CAAC,CAAC,CAAC;IACxE,MAAM,WAAW,GAAY,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IAC9D,MAAM,iBAAiB,GAAG,IAAA,WAAK,EAAC,WAAW,CAAC,CAAC;IAE7C,MAAM,cAAc,GAAG,iBAAiB,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;IACpE,MAAM,cAAc,GAAG,iBAAiB,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;IAEpE,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC;QAC7F,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;IACrC,CAAC;IAED,MAAM,GAAG,GAAgB,EAAE,CAAC;IAC5B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAE/B,MAAM,SAAS,GAAG,CAAC,CAAY,EAAmC,EAAE;QAClE,IAAI,WAAW,CAAC,CAAC,CAAC;YAAE,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QACrD,MAAM,GAAG,GAAG,IAAA,sBAAS,EAAC,CAAC,CAAC,CAAC;QACzB,MAAM,WAAW,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAA,sBAAS,EAAC,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC;QAC7E,IAAI,WAAW,IAAI,CAAC;YAAE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QAChE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACd,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACZ,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAC9C,CAAC,CAAC;IAEF,gFAAgF;IAChF,KAAK,MAAM,CAAC,IAAI,kBAAkB,EAAE;QAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACnD,KAAK,MAAM,CAAC,IAAI,cAAc;QAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAC7C,KAAK,MAAM,CAAC,IAAI,cAAc;QAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAE7C,MAAM,KAAK,GAAwB,EAAE,CAAC;IACtC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAE7B,MAAM,aAAa,GAAG,GAAwB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAE3E,iFAAiF;IACjF,+EAA+E;IAC/E,6BAA6B;IAC7B,IAAI,MAAM,GAAG,CAAC,CAAC;IAEf,OAAO,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,SAAS,EAAE,CAAC;YACvC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;QACpD,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,IAAI,QAAQ,EAAE,CAAC;YAC7B,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;QACvD,CAAC;QACD,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;QACvB,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;YACrB,MAAM,EAAE,CAAC;YACT,SAAS;QACX,CAAC;QAED,uDAAuD;QACvD,CAAC;YACC,MAAM,CAAC,GAAG,sBAAsB,CAAC,EAAE,CAAC,CAAC;YACrC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;gBACf,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBAC1B,KAAK,CAAC,IAAI,CAAC;wBACT,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,CAAC,MAAM,CAAC;wBACd,MAAM,EAAE,CAAC,CAAC,MAAM;wBAChB,YAAY,EAAE,IAAA,8BAAiB,EAAC,CAAC,CAAC,KAAK,CAAC;qBACzC,CAAC,CAAC;oBACH,OAAO,aAAa,EAAE,CAAC;gBACzB,CAAC;gBACD,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;gBAC3C,IAAI,KAAK,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC;oBACtB,KAAK,CAAC,IAAI,CAAC;wBACT,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,CAAC,MAAM,CAAC;wBACd,MAAM,EAAE,CAAC,CAAC,MAAM;wBAChB,YAAY,EAAE,IAAA,8BAAiB,EAAC,CAAC,CAAC,KAAK,CAAC;qBACzC,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;QACH,CAAC;QAED,4CAA4C;QAC5C,KAAK,MAAM,QAAQ,IAAI,IAAA,2BAAc,EAAC,EAAE,CAAC,EAAE,CAAC;YAC1C,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;YAC3C,IAAI,KAAK,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC;gBACtB,KAAK,CAAC,IAAI,CAAC;oBACT,IAAI,EAAE,QAAQ;oBACd,IAAI,EAAE,CAAC,MAAM,CAAC;oBACd,MAAM,EAAE,QAAQ;oBAChB,YAAY,EAAE,EAAE;iBACjB,CAAC,CAAC;gBACH,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;oBAAE,OAAO,aAAa,EAAE,CAAC;YACpD,CAAC;YACD,IAAI,KAAK,CAAC,MAAM,IAAI,QAAQ;gBAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;QACrF,CAAC;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACjC,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,SAAS,EAAE,CAAC;gBACvC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;YACpD,CAAC;YACD,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;YAClB,IAAI,EAAE,KAAK,SAAS;gBAAE,SAAS;YAE/B,wBAAwB;YACxB,MAAM,UAAU,GAAG,IAAA,2BAAiB,EAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;YAClF,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;gBAC3B,IAAI,CAAC,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBAC7B,KAAK,CAAC,IAAI,CAAC;wBACT,IAAI,EAAE,SAAS;wBACf,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC;wBACjB,MAAM,EAAE,CAAC,CAAC,SAAS;wBACnB,YAAY,EAAE,EAAE;qBACjB,CAAC,CAAC;oBACH,OAAO,aAAa,EAAE,CAAC;gBACzB,CAAC;gBACD,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;gBAC9C,IAAI,KAAK,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC;oBACtB,KAAK,CAAC,IAAI,CAAC;wBACT,IAAI,EAAE,SAAS;wBACf,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC;wBACjB,MAAM,EAAE,CAAC,CAAC,SAAS;wBACnB,YAAY,EAAE,EAAE;qBACjB,CAAC,CAAC;oBACH,IAAI,KAAK,CAAC,MAAM,IAAI,QAAQ;wBAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;gBACrF,CAAC;YACH,CAAC;YAED,wCAAwC;YACxC,MAAM,QAAQ,GAAG,IAAA,8BAAe,EAAC,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;YACpD,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;gBACzB,IAAI,CAAC,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBAC7B,KAAK,CAAC,IAAI,CAAC;wBACT,IAAI,EAAE,SAAS;wBACf,IAAI,EAAE,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,CAAC,gBAAgB,CAAC;wBAC1C,MAAM,EAAE,CAAC,CAAC,SAAS;wBACnB,YAAY,EAAE,IAAA,8BAAiB,EAAC,CAAC,CAAC,YAAY,CAAC;qBAChD,CAAC,CAAC;oBACH,OAAO,aAAa,EAAE,CAAC;gBACzB,CAAC;gBACD,uEAAuE;gBACvE,wEAAwE;gBACxE,IAAI,KAAK,GAAG,CAAC,CAAC,SAAS,CAAC;gBACxB,MAAM,QAAQ,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAC;gBAC/C,IAAI,QAAQ,KAAK,IAAI;oBAAE,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC;gBAC/C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBACvB,KAAK,CAAC,IAAI,CAAC;wBACT,IAAI,EAAE,SAAS;wBACf,IAAI,EAAE,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,CAAC,gBAAgB,CAAC;wBAC1C,MAAM,EAAE,KAAK;wBACb,YAAY,EAAE,IAAA,8BAAiB,EAAC,CAAC,CAAC,YAAY,CAAC;qBAChD,CAAC,CAAC;oBACH,OAAO,aAAa,EAAE,CAAC;gBACzB,CAAC;gBACD,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;gBACxC,IAAI,KAAK,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC;oBACtB,KAAK,CAAC,IAAI,CAAC;wBACT,IAAI,EAAE,SAAS;wBACf,IAAI,EAAE,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,CAAC,gBAAgB,CAAC;wBAC1C,MAAM,EAAE,KAAK;wBACb,YAAY,EAAE,IAAA,8BAAiB,EAAC,CAAC,CAAC,YAAY,CAAC;qBAChD,CAAC,CAAC;oBACH,IAAI,KAAK,CAAC,MAAM,IAAI,QAAQ;wBAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;gBACrF,CAAC;YACH,CAAC;QACH,CAAC;QACD,MAAM,EAAE,CAAC;IACX,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;AACvD,CAAC"}

package/dist/fol-prover-equality/term-utils.d.ts

@@ -0,0 +1,43 @@
+import type { FOLClause, FOLLiteral, FOLTerm } from '../fol-prover/types';
+export declare function isEqualityLiteral(lit: FOLLiteral): boolean;
+export declare function termKey(t: FOLTerm): string;
+export declare function literalKey(lit: FOLLiteral): string;
+export declare function clauseKey(c: FOLClause): string;
+export declare function termsEqual(a: FOLTerm, b: FOLTerm): boolean;
+export declare function cloneTerm(t: FOLTerm): FOLTerm;
+export declare function cloneLiteral(lit: FOLLiteral): FOLLiteral;
+export declare function cloneClause(c: FOLClause): FOLClause;
+export declare function termSize(t: FOLTerm): number;
+export declare function collectVars(t: FOLTerm, out: Set<string>): void;
+export declare function termVars(t: FOLTerm): Set<string>;
+/**
+ * Returns the subterm of `t` at the given position. Position [] returns t itself;
+ * position [i, j, ...] descends into args[i], then args[j], etc.
+ */
+export declare function termAt(t: FOLTerm, pos: number[]): FOLTerm | null;
+/**
+ * Returns a new term equal to `t` but with the subterm at `pos` replaced by `replacement`.
+ * If pos is invalid returns `t` unchanged.
+ */
+export declare function replaceAt(t: FOLTerm, pos: number[], replacement: FOLTerm): FOLTerm;
+/**
+ * Enumerate every (non-empty) position inside the term tree, including the root.
+ * Variables and constants only yield their own position; functions also yield children.
+ */
+export declare function allPositions(t: FOLTerm): number[][];
+/**
+ * Enumerate positions for a literal as (argIndex, ...termPath). Useful for paramodulation
+ * targets that point inside a literal's args.
+ */
+export declare function allLiteralPositions(lit: FOLLiteral): number[][];
+export declare function getLiteralSubterm(lit: FOLLiteral, pos: number[]): FOLTerm | null;
+export declare function replaceLiteralSubterm(lit: FOLLiteral, pos: number[], replacement: FOLTerm): FOLLiteral;
+/**
+ * Lexicographic path ordering–ish comparison used for orienting equations and
+ * for selecting which side rewrites the other in demodulation. Strictly compares
+ * (size, then key) so that the "bigger" term is rewritten into the "smaller" one.
+ */
+export declare function compareTerms(a: FOLTerm, b: FOLTerm): number;
+export declare function freshenClause(c: FOLClause): FOLClause;
+export declare function substToRecordTerm(s: Map<string, FOLTerm>): Record<string, FOLTerm>;
+//# sourceMappingURL=term-utils.d.ts.map

package/dist/fol-prover-equality/term-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"term-utils.d.ts","sourceRoot":"","sources":["../../src/fol-prover-equality/term-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAG1E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAE1D;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAI1C;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAGlD;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,CAE9C;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAE1D;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAI7C;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU,CAMxD;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAEnD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAM3C;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAO9D;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,CAIhD;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,GAAG,IAAI,CAWhE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO,CAUlF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,EAAE,CAanD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,EAAE,EAAE,CAU/D;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,GAAG,IAAI,CAOhF;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,UAAU,EACf,GAAG,EAAE,MAAM,EAAE,EACb,WAAW,EAAE,OAAO,GACnB,UAAU,CASZ;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAS3D;AAID,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAoBrD;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIlF"}