@stevenvo780/st-lang 4.11.0 → 4.13.0

package/dist/proof-systems/fol-prover-advanced/index.d.ts

@@ -0,0 +1,7 @@
+export type { FOLTerm, FOLLiteral, FOLClause, Substitution, RefinementStrategy, TermOrdering, AdvancedProveOptions, AdvancedProveResult, ProofStep, ProofStats } from './types';
+export { unify, unifyLiterals, applySubToTerm, applySubToLiteral, termsEqual, literalsEqual } from './unify';
+export { kboGreater, lpoGreater, maximalLiterals } from './ordering';
+export { subsumes, removeSubsumed, unitPreference, clausesAlphaEqual } from './subsumption';
+export { binaryResolve, hyperresolve, hyperresolveMany, factor, dedupLiterals, isTautology, renameClause, resetRenameCounter } from './resolve';
+export { proveAdvanced, negateLiteral, negateClause, strategyLabel } from './prover';
+//# sourceMappingURL=index.d.ts.map

package/dist/proof-systems/fol-prover-advanced/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,OAAO,EACP,UAAU,EACV,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,YAAY,EACZ,oBAAoB,EACpB,mBAAmB,EACnB,SAAS,EACT,UAAU,EACX,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,KAAK,EACL,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,aAAa,EACd,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,UAAU,EACV,UAAU,EACV,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,QAAQ,EACR,cAAc,EACd,cAAc,EACd,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,MAAM,EACN,aAAa,EACb,WAAW,EACX,YAAY,EACZ,kBAAkB,EACnB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,aAAa,EACb,aAAa,EACb,YAAY,EACZ,aAAa,EACd,MAAM,UAAU,CAAC"}

package/dist/proof-systems/fol-prover-advanced/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strategyLabel = exports.negateClause = exports.negateLiteral = exports.proveAdvanced = exports.resetRenameCounter = exports.renameClause = exports.isTautology = exports.dedupLiterals = exports.factor = exports.hyperresolveMany = exports.hyperresolve = exports.binaryResolve = exports.clausesAlphaEqual = exports.unitPreference = exports.removeSubsumed = exports.subsumes = exports.maximalLiterals = exports.lpoGreater = exports.kboGreater = exports.literalsEqual = exports.termsEqual = exports.applySubToLiteral = exports.applySubToTerm = exports.unifyLiterals = exports.unify = void 0;
+var unify_1 = require("./unify");
+Object.defineProperty(exports, "unify", { enumerable: true, get: function () { return unify_1.unify; } });
+Object.defineProperty(exports, "unifyLiterals", { enumerable: true, get: function () { return unify_1.unifyLiterals; } });
+Object.defineProperty(exports, "applySubToTerm", { enumerable: true, get: function () { return unify_1.applySubToTerm; } });
+Object.defineProperty(exports, "applySubToLiteral", { enumerable: true, get: function () { return unify_1.applySubToLiteral; } });
+Object.defineProperty(exports, "termsEqual", { enumerable: true, get: function () { return unify_1.termsEqual; } });
+Object.defineProperty(exports, "literalsEqual", { enumerable: true, get: function () { return unify_1.literalsEqual; } });
+var ordering_1 = require("./ordering");
+Object.defineProperty(exports, "kboGreater", { enumerable: true, get: function () { return ordering_1.kboGreater; } });
+Object.defineProperty(exports, "lpoGreater", { enumerable: true, get: function () { return ordering_1.lpoGreater; } });
+Object.defineProperty(exports, "maximalLiterals", { enumerable: true, get: function () { return ordering_1.maximalLiterals; } });
+var subsumption_1 = require("./subsumption");
+Object.defineProperty(exports, "subsumes", { enumerable: true, get: function () { return subsumption_1.subsumes; } });
+Object.defineProperty(exports, "removeSubsumed", { enumerable: true, get: function () { return subsumption_1.removeSubsumed; } });
+Object.defineProperty(exports, "unitPreference", { enumerable: true, get: function () { return subsumption_1.unitPreference; } });
+Object.defineProperty(exports, "clausesAlphaEqual", { enumerable: true, get: function () { return subsumption_1.clausesAlphaEqual; } });
+var resolve_1 = require("./resolve");
+Object.defineProperty(exports, "binaryResolve", { enumerable: true, get: function () { return resolve_1.binaryResolve; } });
+Object.defineProperty(exports, "hyperresolve", { enumerable: true, get: function () { return resolve_1.hyperresolve; } });
+Object.defineProperty(exports, "hyperresolveMany", { enumerable: true, get: function () { return resolve_1.hyperresolveMany; } });
+Object.defineProperty(exports, "factor", { enumerable: true, get: function () { return resolve_1.factor; } });
+Object.defineProperty(exports, "dedupLiterals", { enumerable: true, get: function () { return resolve_1.dedupLiterals; } });
+Object.defineProperty(exports, "isTautology", { enumerable: true, get: function () { return resolve_1.isTautology; } });
+Object.defineProperty(exports, "renameClause", { enumerable: true, get: function () { return resolve_1.renameClause; } });
+Object.defineProperty(exports, "resetRenameCounter", { enumerable: true, get: function () { return resolve_1.resetRenameCounter; } });
+var prover_1 = require("./prover");
+Object.defineProperty(exports, "proveAdvanced", { enumerable: true, get: function () { return prover_1.proveAdvanced; } });
+Object.defineProperty(exports, "negateLiteral", { enumerable: true, get: function () { return prover_1.negateLiteral; } });
+Object.defineProperty(exports, "negateClause", { enumerable: true, get: function () { return prover_1.negateClause; } });
+Object.defineProperty(exports, "strategyLabel", { enumerable: true, get: function () { return prover_1.strategyLabel; } });
+//# sourceMappingURL=index.js.map

package/dist/proof-systems/fol-prover-advanced/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/index.ts"],"names":[],"mappings":";;;AAaA,iCAOiB;AANf,8FAAA,KAAK,OAAA;AACL,sGAAA,aAAa,OAAA;AACb,uGAAA,cAAc,OAAA;AACd,0GAAA,iBAAiB,OAAA;AACjB,mGAAA,UAAU,OAAA;AACV,sGAAA,aAAa,OAAA;AAGf,uCAIoB;AAHlB,sGAAA,UAAU,OAAA;AACV,sGAAA,UAAU,OAAA;AACV,2GAAA,eAAe,OAAA;AAGjB,6CAKuB;AAJrB,uGAAA,QAAQ,OAAA;AACR,6GAAA,cAAc,OAAA;AACd,6GAAA,cAAc,OAAA;AACd,gHAAA,iBAAiB,OAAA;AAGnB,qCASmB;AARjB,wGAAA,aAAa,OAAA;AACb,uGAAA,YAAY,OAAA;AACZ,2GAAA,gBAAgB,OAAA;AAChB,iGAAA,MAAM,OAAA;AACN,wGAAA,aAAa,OAAA;AACb,sGAAA,WAAW,OAAA;AACX,uGAAA,YAAY,OAAA;AACZ,6GAAA,kBAAkB,OAAA;AAGpB,mCAKkB;AAJhB,uGAAA,aAAa,OAAA;AACb,uGAAA,aAAa,OAAA;AACb,sGAAA,YAAY,OAAA;AACZ,uGAAA,aAAa,OAAA"}

package/dist/proof-systems/fol-prover-advanced/ordering.d.ts

@@ -0,0 +1,34 @@
+import type { FOLLiteral, FOLTerm } from './types';
+/**
+ * `kboGreater(t1, t2, weights)` ⇔ t1 >_KBO t2.
+ *
+ * Invariantes (simplificadas; suficientes para el tablero de pruebas):
+ * 1. Cada variable de t2 ocurre en t1 al menos tantas veces.
+ * 2. weight(t1) > weight(t2), o
+ * 3. weight(t1) == weight(t2) y t1 domina léxicamente (top-symbol > top-symbol
+ *    según precedencia derivada de pesos, o argumentos comparados).
+ */
+export declare function kboGreater(t1: FOLTerm, t2: FOLTerm, weights: Map<string, number>): boolean;
+/**
+ * `lpoGreater(t1, t2, precedence)` ⇔ t1 >_LPO t2.
+ *
+ * Reglas estándar:
+ * - Si t2 es variable, t1 > t2 ⇔ t2 ocurre en t1 y t1 ≠ t2.
+ * - Si top(t1) > top(t2) (vía `precedence`) y t1 > cada subterm de t2.
+ * - Si top(t1) = top(t2), comparación lexicográfica de argumentos y t1 > cada
+ *   subterm de t2.
+ * - Si algún subterm de t1 ≥ t2.
+ */
+export declare function lpoGreater(t1: FOLTerm, t2: FOLTerm, precedence: Map<string, number>): boolean;
+/**
+ * Calcula las literales máximas de una cláusula bajo el ordering dado.
+ * Sólo esas pueden usarse como "literal seleccionada" en ordered resolution.
+ *
+ * Convertimos cada literal en un término representativo
+ * `f_pred(args)` (con signo codificado vía precedencia para que la negación no
+ * altere el orden) y comparamos.
+ */
+export declare function maximalLiterals(clause: {
+    literals: FOLLiteral[];
+}, ordering: 'KBO' | 'LPO' | 'none', weights: Map<string, number>, precedence: Map<string, number>): number[];
+//# sourceMappingURL=ordering.d.ts.map

package/dist/proof-systems/fol-prover-advanced/ordering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordering.d.ts","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/ordering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAwCnD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CA4B1F;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAuC7F;AAuBD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE;IAAE,QAAQ,EAAE,UAAU,EAAE,CAAA;CAAE,EAClC,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,EAChC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,MAAM,EAAE,CA6BV"}

package/dist/proof-systems/fol-prover-advanced/ordering.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kboGreater = kboGreater;
+exports.lpoGreater = lpoGreater;
+exports.maximalLiterals = maximalLiterals;
+function termMultiset(t) {
+    const ms = { size: 0, varCount: new Map() };
+    walk(t);
+    function walk(node) {
+        if (node.kind === 'variable') {
+            ms.size += 1;
+            ms.varCount.set(node.name, (ms.varCount.get(node.name) ?? 0) + 1);
+            return;
+        }
+        ms.size += 1;
+        for (const a of node.args)
+            walk(a);
+    }
+    return ms;
+}
+function termWeight(t, weights) {
+    if (t.kind === 'variable')
+        return 1;
+    const w = weights.get(t.name) ?? 1;
+    let total = w;
+    for (const a of t.args)
+        total += termWeight(a, weights);
+    return total;
+}
+/**
+ * `kboGreater(t1, t2, weights)` ⇔ t1 >_KBO t2.
+ *
+ * Invariantes (simplificadas; suficientes para el tablero de pruebas):
+ * 1. Cada variable de t2 ocurre en t1 al menos tantas veces.
+ * 2. weight(t1) > weight(t2), o
+ * 3. weight(t1) == weight(t2) y t1 domina léxicamente (top-symbol > top-symbol
+ *    según precedencia derivada de pesos, o argumentos comparados).
+ */
+function kboGreater(t1, t2, weights) {
+    // Condición de variables: cada var de t2 ocurre ≥ en t1.
+    const ms1 = termMultiset(t1);
+    const ms2 = termMultiset(t2);
+    for (const [varName, count2] of ms2.varCount) {
+        const count1 = ms1.varCount.get(varName) ?? 0;
+        if (count1 < count2)
+            return false;
+    }
+    const w1 = termWeight(t1, weights);
+    const w2 = termWeight(t2, weights);
+    if (w1 > w2)
+        return true;
+    if (w1 < w2)
+        return false;
+    // Empate en peso: comparar símbolos top y luego argumentos.
+    if (t1.kind === 'variable' || t2.kind === 'variable')
+        return false;
+    const wf1 = weights.get(t1.name) ?? 1;
+    const wf2 = weights.get(t2.name) ?? 1;
+    if (wf1 > wf2)
+        return true;
+    if (wf1 < wf2)
+        return false;
+    if (t1.name !== t2.name)
+        return t1.name > t2.name;
+    if (t1.args.length !== t2.args.length)
+        return t1.args.length > t2.args.length;
+    for (let i = 0; i < t1.args.length; i++) {
+        const a = t1.args[i];
+        const b = t2.args[i];
+        if (a === undefined || b === undefined)
+            return false;
+        if (kboGreater(a, b, weights))
+            return true;
+        if (kboGreater(b, a, weights))
+            return false;
+    }
+    return false;
+}
+/**
+ * `lpoGreater(t1, t2, precedence)` ⇔ t1 >_LPO t2.
+ *
+ * Reglas estándar:
+ * - Si t2 es variable, t1 > t2 ⇔ t2 ocurre en t1 y t1 ≠ t2.
+ * - Si top(t1) > top(t2) (vía `precedence`) y t1 > cada subterm de t2.
+ * - Si top(t1) = top(t2), comparación lexicográfica de argumentos y t1 > cada
+ *   subterm de t2.
+ * - Si algún subterm de t1 ≥ t2.
+ */
+function lpoGreater(t1, t2, precedence) {
+    if (t1.kind === 'variable')
+        return false;
+    if (t2.kind === 'variable')
+        return occursVar(t2.name, t1) && !sameTerm(t1, t2);
+    // Caso 1: algún subterm de t1 ≥ t2.
+    for (const sub of t1.args) {
+        if (sameTerm(sub, t2) || lpoGreater(sub, t2, precedence))
+            return true;
+    }
+    const r1 = precedence.get(t1.name) ?? 0;
+    const r2 = precedence.get(t2.name) ?? 0;
+    if (r1 > r2) {
+        // t1 > t2 ⇔ t1 > cada subterm de t2.
+        for (const s of t2.args) {
+            if (!lpoGreater(t1, s, precedence))
+                return false;
+        }
+        return true;
+    }
+    if (r1 === r2 && t1.name === t2.name && t1.args.length === t2.args.length) {
+        // Lexicográfico sobre args.
+        for (let i = 0; i < t1.args.length; i++) {
+            const a = t1.args[i];
+            const b = t2.args[i];
+            if (a === undefined || b === undefined)
+                return false;
+            if (sameTerm(a, b))
+                continue;
+            if (lpoGreater(a, b, precedence)) {
+                for (const s of t2.args) {
+                    if (!lpoGreater(t1, s, precedence))
+                        return false;
+                }
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
+    return false;
+}
+function occursVar(name, t) {
+    if (t.kind === 'variable')
+        return t.name === name;
+    return t.args.some((a) => occursVar(name, a));
+}
+function sameTerm(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    if (a.kind === 'variable' && b.kind === 'variable')
+        return a.name === b.name;
+    if (a.kind === 'function' && b.kind === 'function') {
+        if (a.name !== b.name || a.args.length !== b.args.length)
+            return false;
+        for (let i = 0; i < a.args.length; i++) {
+            const ai = a.args[i];
+            const bi = b.args[i];
+            if (ai === undefined || bi === undefined)
+                return false;
+            if (!sameTerm(ai, bi))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Calcula las literales máximas de una cláusula bajo el ordering dado.
+ * Sólo esas pueden usarse como "literal seleccionada" en ordered resolution.
+ *
+ * Convertimos cada literal en un término representativo
+ * `f_pred(args)` (con signo codificado vía precedencia para que la negación no
+ * altere el orden) y comparamos.
+ */
+function maximalLiterals(clause, ordering, weights, precedence) {
+    if (ordering === 'none' || clause.literals.length === 0) {
+        return clause.literals.map((_, i) => i);
+    }
+    const wrapped = clause.literals.map((l) => ({
+        kind: 'function',
+        name: l.predicate,
+        args: l.args
+    }));
+    const maximal = [];
+    for (let i = 0; i < wrapped.length; i++) {
+        let dominated = false;
+        for (let j = 0; j < wrapped.length; j++) {
+            if (i === j)
+                continue;
+            const wi = wrapped[i];
+            const wj = wrapped[j];
+            if (wi === undefined || wj === undefined)
+                continue;
+            if (ordering === 'KBO' && kboGreater(wj, wi, weights)) {
+                dominated = true;
+                break;
+            }
+            if (ordering === 'LPO' && lpoGreater(wj, wi, precedence)) {
+                dominated = true;
+                break;
+            }
+        }
+        if (!dominated)
+            maximal.push(i);
+    }
+    return maximal;
+}
+//# sourceMappingURL=ordering.js.map

package/dist/proof-systems/fol-prover-advanced/ordering.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordering.js","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/ordering.ts"],"names":[],"mappings":";;AAiDA,gCA4BC;AAYD,gCAuCC;AA+BD,0CAkCC;AAhLD,SAAS,YAAY,CAAC,CAAU;IAC9B,MAAM,EAAE,GAAa,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC;IACtD,IAAI,CAAC,CAAC,CAAC,CAAC;IACR,SAAS,IAAI,CAAC,IAAa;QACzB,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC7B,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC;YACb,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAClE,OAAO;QACT,CAAC;QACD,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC;QACb,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,IAAI;YAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,SAAS,UAAU,CAAC,CAAU,EAAE,OAA4B;IAC1D,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,CAAC,CAAC;IACpC,MAAM,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI;QAAE,KAAK,IAAI,UAAU,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IACxD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,UAAU,CAAC,EAAW,EAAE,EAAW,EAAE,OAA4B;IAC/E,yDAAyD;IACzD,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC;IAC7B,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC;IAC7B,KAAK,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,GAAG,CAAC,QAAQ,EAAE,CAAC;QAC7C,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC9C,IAAI,MAAM,GAAG,MAAM;YAAE,OAAO,KAAK,CAAC;IACpC,CAAC;IACD,MAAM,EAAE,GAAG,UAAU,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IACnC,MAAM,EAAE,GAAG,UAAU,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IACnC,IAAI,EAAE,GAAG,EAAE;QAAE,OAAO,IAAI,CAAC;IACzB,IAAI,EAAE,GAAG,EAAE;QAAE,OAAO,KAAK,CAAC;IAC1B,4DAA4D;IAC5D,IAAI,EAAE,CAAC,IAAI,KAAK,UAAU,IAAI,EAAE,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,KAAK,CAAC;IACnE,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACtC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,GAAG,GAAG,GAAG;QAAE,OAAO,IAAI,CAAC;IAC3B,IAAI,GAAG,GAAG,GAAG;QAAE,OAAO,KAAK,CAAC;IAC5B,IAAI,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI;QAAE,OAAO,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,IAAI,CAAC;IAClD,IAAI,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,EAAE,CAAC,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC;IAC9E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACrB,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACrB,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC;QACrD,IAAI,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC;YAAE,OAAO,IAAI,CAAC;QAC3C,IAAI,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC;YAAE,OAAO,KAAK,CAAC;IAC9C,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,UAAU,CAAC,EAAW,EAAE,EAAW,EAAE,UAA+B;IAClF,IAAI,EAAE,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,KAAK,CAAC;IACzC,IAAI,EAAE,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IAE/E,oCAAoC;IACpC,KAAK,MAAM,GAAG,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;QAC1B,IAAI,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,UAAU,CAAC,GAAG,EAAE,EAAE,EAAE,UAAU,CAAC;YAAE,OAAO,IAAI,CAAC;IACxE,CAAC;IAED,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAExC,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;QACZ,qCAAqC;QACrC,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;YACxB,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,EAAE,UAAU,CAAC;gBAAE,OAAO,KAAK,CAAC;QACnD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;QAC1E,4BAA4B;QAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,SAAS;gBAAE,OAAO,KAAK,CAAC;YACrD,IAAI,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;gBAAE,SAAS;YAC7B,IAAI,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,CAAC;gBACjC,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;oBACxB,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,EAAE,UAAU,CAAC;wBAAE,OAAO,KAAK,CAAC;gBACnD,CAAC;gBACD,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,SAAS,CAAC,IAAY,EAAE,CAAU;IACzC,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC;IAClD,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;AAChD,CAAC;AAED,SAAS,QAAQ,CAAC,CAAU,EAAE,CAAU;IACtC,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IACpC,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,CAAC;IAC7E,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QACnD,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QACvE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,KAAK,SAAS;gBAAE,OAAO,KAAK,CAAC;YACvD,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC;gBAAE,OAAO,KAAK,CAAC;QACtC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,eAAe,CAC7B,MAAkC,EAClC,QAAgC,EAChC,OAA4B,EAC5B,UAA+B;IAE/B,IAAI,QAAQ,KAAK,MAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxD,OAAO,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAC1C,CAAC;IACD,MAAM,OAAO,GAAc,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACrD,IAAI,EAAE,UAAU;QAChB,IAAI,EAAE,CAAC,CAAC,SAAS;QACjB,IAAI,EAAE,CAAC,CAAC,IAAI;KACb,CAAC,CAAC,CAAC;IACJ,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,IAAI,CAAC,KAAK,CAAC;gBAAE,SAAS;YACtB,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACtB,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACtB,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,KAAK,SAAS;gBAAE,SAAS;YACnD,IAAI,QAAQ,KAAK,KAAK,IAAI,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,CAAC;gBACtD,SAAS,GAAG,IAAI,CAAC;gBACjB,MAAM;YACR,CAAC;YACD,IAAI,QAAQ,KAAK,KAAK,IAAI,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,UAAU,CAAC,EAAE,CAAC;gBACzD,SAAS,GAAG,IAAI,CAAC;gBACjB,MAAM;YACR,CAAC;QACH,CAAC;QACD,IAAI,CAAC,SAAS;YAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/proof-systems/fol-prover-advanced/prover.d.ts

@@ -0,0 +1,22 @@
+import type { AdvancedProveOptions, AdvancedProveResult, FOLClause, FOLLiteral, RefinementStrategy } from './types';
+/**
+ * Negación lógica de una literal (toggle del flag `negated`).
+ * Útil para construir el goal negado en una refutación.
+ */
+export declare function negateLiteral(l: FOLLiteral): FOLLiteral;
+export declare function negateClause(c: FOLClause): FOLClause[];
+/**
+ * Prover avanzado: refuta `premises ∧ ¬goal` aplicando el refinamiento
+ * elegido. Devuelve un `AdvancedProveResult` con las trazas.
+ *
+ * Asumimos que `premises` y `goal` ya están en CNF (cláusulas explícitas
+ * con literales). El caller que quiera convertir fórmulas ricas a CNF debe
+ * hacerlo antes.
+ */
+export declare function proveAdvanced(premises: FOLClause[], goal: FOLClause, opts: AdvancedProveOptions): AdvancedProveResult;
+/**
+ * Helper que mapea `RefinementStrategy` a un short-name legible (sirve para
+ * logs y tests).
+ */
+export declare function strategyLabel(s: RefinementStrategy): string;
+//# sourceMappingURL=prover.d.ts.map

package/dist/proof-systems/fol-prover-advanced/prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prover.d.ts","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/prover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,SAAS,EACT,UAAU,EAGV,kBAAkB,EAEnB,MAAM,SAAS,CAAC;AAejB;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU,CAEvD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAGtD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,SAAS,EAAE,EACrB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,oBAAoB,GACzB,mBAAmB,CAwLrB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAQ3D"}

package/dist/proof-systems/fol-prover-advanced/prover.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.negateLiteral = negateLiteral;
+exports.negateClause = negateClause;
+exports.proveAdvanced = proveAdvanced;
+exports.strategyLabel = strategyLabel;
+const resolve_1 = require("./resolve");
+const ordering_1 = require("./ordering");
+const subsumption_1 = require("./subsumption");
+/**
+ * Negación lógica de una literal (toggle del flag `negated`).
+ * Útil para construir el goal negado en una refutación.
+ */
+function negateLiteral(l) {
+    return { ...l, negated: !l.negated };
+}
+function negateClause(c) {
+    // ¬(L1 ∨ L2 ∨ … ∨ Ln) = ¬L1 ∧ ¬L2 ∧ … ∧ ¬Ln → una cláusula unitaria por literal.
+    return c.literals.map((l) => ({ literals: [negateLiteral(l)], fromGoal: true }));
+}
+/**
+ * Prover avanzado: refuta `premises ∧ ¬goal` aplicando el refinamiento
+ * elegido. Devuelve un `AdvancedProveResult` con las trazas.
+ *
+ * Asumimos que `premises` y `goal` ya están en CNF (cláusulas explícitas
+ * con literales). El caller que quiera convertir fórmulas ricas a CNF debe
+ * hacerlo antes.
+ */
+function proveAdvanced(premises, goal, opts) {
+    (0, resolve_1.resetRenameCounter)();
+    const timeoutMs = opts.timeoutMs ?? 5_000;
+    const maxSteps = opts.maxSteps ?? 5_000;
+    const ordering = opts.ordering ?? 'none';
+    const weights = opts.kboWeights ?? new Map();
+    const precedence = opts.precedence ?? new Map();
+    const strategy = opts.strategy;
+    const goalClauses = negateClause(goal);
+    let clauses = [...premises.map((p) => ({ ...p })), ...goalClauses];
+    // Set-of-support inicial: índices de cláusulas que arrancan en el set.
+    // Si el caller dio `setOfSupport`, usamos esos; si no, las cláusulas del goal.
+    const initialSoS = new Set();
+    if (strategy === 'set-of-support') {
+        if (opts.setOfSupport && opts.setOfSupport.length > 0) {
+            for (const i of opts.setOfSupport)
+                initialSoS.add(i);
+        }
+        else {
+            // Por default: las cláusulas que vienen del goal negado.
+            for (let i = premises.length; i < clauses.length; i++)
+                initialSoS.add(i);
+        }
+    }
+    const sosFlag = new Map();
+    for (let i = 0; i < clauses.length; i++)
+        sosFlag.set(i, initialSoS.has(i));
+    // Aplicar unit preference como reordenamiento inicial si la estrategia es esa.
+    if (strategy === 'unit-preference') {
+        clauses = (0, subsumption_1.unitPreference)(clauses);
+    }
+    const steps = [];
+    const stats = {
+        resolutions: 0,
+        subsumed: 0,
+        deduplicated: 0,
+        hyperresolutions: 0,
+        factored: 0,
+        steps: 0
+    };
+    const start = Date.now();
+    // Comprobar cláusula vacía ya presente
+    for (const c of clauses) {
+        if (c.literals.length === 0) {
+            return {
+                proven: true,
+                steps,
+                stats,
+                termination: 'refuted'
+            };
+        }
+    }
+    // Loop principal: a cada iteración intentamos producir resolventes nuevos.
+    while (true) {
+        if (Date.now() - start > timeoutMs) {
+            return { proven: false, steps, stats, termination: 'timeout' };
+        }
+        if (stats.steps >= maxSteps) {
+            return { proven: false, steps, stats, termination: 'max-steps' };
+        }
+        const newClauses = [];
+        // Generar resolventes según estrategia
+        for (let i = 0; i < clauses.length; i++) {
+            for (let j = i + 1; j < clauses.length; j++) {
+                const ci = clauses[i];
+                const cj = clauses[j];
+                if (!ci || !cj)
+                    continue;
+                // Set-of-support: al menos una de las dos debe estar en el SoS.
+                if (strategy === 'set-of-support') {
+                    if (!sosFlag.get(i) && !sosFlag.get(j))
+                        continue;
+                }
+                if (strategy === 'hyperresolution') {
+                    // En este modo el "núcleo" es la cláusula con literales negativas
+                    // y los electrons salen de positivas. Probamos cada cláusula como
+                    // núcleo contra el resto positivo.
+                    const positives = clauses.filter((c) => c.literals.length > 0 && c.literals.every((l) => !l.negated));
+                    const candidates = [ci, cj];
+                    for (const nucleus of candidates) {
+                        if (nucleus.literals.every((l) => !l.negated))
+                            continue; // ya positiva
+                        const hrs = (0, resolve_1.hyperresolveMany)(positives, nucleus);
+                        for (const hr of hrs) {
+                            stats.hyperresolutions += 1;
+                            stats.resolutions += 1;
+                            newClauses.push({
+                                clause: hr.clause,
+                                step: {
+                                    rule: 'hyperresolution',
+                                    from: [i, j, ...hr.usedElectrons.map((e) => -1 - e)], // electron indices con offset negativo
+                                    result: hr.clause,
+                                    substitution: hr.sub
+                                },
+                                fromGoalDerived: !!ci.fromGoal || !!cj.fromGoal
+                            });
+                        }
+                    }
+                    continue;
+                }
+                // Resolución binaria con/sin ordering
+                const resolvents = (0, resolve_1.binaryResolve)(ci, cj);
+                for (const r of resolvents) {
+                    // Ordered resolution: la literal resuelta debe ser máxima en su cláusula.
+                    if (strategy === 'ordered') {
+                        const liMax = (0, ordering_1.maximalLiterals)(ci, ordering, weights, precedence);
+                        const ljMax = (0, ordering_1.maximalLiterals)(cj, ordering, weights, precedence);
+                        // Aceptamos si en cada padre la literal usada está entre las máximas.
+                        // Como `binaryResolve` no devuelve cuál par usó, hacemos un check
+                        // suave: al menos las máximas deben ser ≥ 1 en cada cláusula.
+                        if (liMax.length === 0 || ljMax.length === 0)
+                            continue;
+                    }
+                    stats.resolutions += 1;
+                    newClauses.push({
+                        clause: r.clause,
+                        step: {
+                            rule: strategy === 'ordered' ? 'ordered-resolution' : 'binary-resolution',
+                            from: [i, j],
+                            result: r.clause,
+                            substitution: r.sub
+                        },
+                        fromGoalDerived: !!ci.fromGoal || !!cj.fromGoal
+                    });
+                }
+                // Factoring sobre ambos padres también puede acortar pruebas.
+                for (const ff of [(0, resolve_1.factor)(ci), (0, resolve_1.factor)(cj)]) {
+                    for (const fc of ff) {
+                        stats.factored += 1;
+                        newClauses.push({
+                            clause: fc,
+                            step: { rule: 'factoring', from: [i], result: fc },
+                            fromGoalDerived: !!ci.fromGoal || !!cj.fromGoal
+                        });
+                    }
+                }
+            }
+        }
+        if (newClauses.length === 0) {
+            return { proven: false, steps, stats, termination: 'saturated' };
+        }
+        // Filtrar tautologías, subsumidas y duplicados; detectar cláusula vacía.
+        let progress = false;
+        for (const { clause, step, fromGoalDerived } of newClauses) {
+            stats.steps += 1;
+            if ((0, resolve_1.isTautology)(clause))
+                continue;
+            // Detectar cláusula vacía → refutación.
+            if (clause.literals.length === 0) {
+                steps.push(step);
+                return { proven: true, steps, stats, termination: 'refuted' };
+            }
+            // Subsumida por alguna existente?
+            const subsumedByExisting = clauses.some((c) => c.literals.length > 0 && (0, subsumption_1.subsumes)(c, clause));
+            if (subsumedByExisting) {
+                stats.subsumed += 1;
+                continue;
+            }
+            // Duplicado alpha-eq?
+            const dup = clauses.some((c) => (0, subsumption_1.clausesAlphaEqual)(c, clause));
+            if (dup) {
+                stats.deduplicated += 1;
+                continue;
+            }
+            // Aceptada
+            const idx = clauses.length;
+            const marked = { ...clause, parents: step.from, fromGoal: fromGoalDerived };
+            clauses.push(marked);
+            sosFlag.set(idx, fromGoalDerived || strategy !== 'set-of-support');
+            steps.push(step);
+            progress = true;
+        }
+        if (!progress) {
+            return { proven: false, steps, stats, termination: 'saturated' };
+        }
+    }
+}
+/**
+ * Helper que mapea `RefinementStrategy` a un short-name legible (sirve para
+ * logs y tests).
+ */
+function strategyLabel(s) {
+    switch (s) {
+        case 'binary': return 'Binary resolution';
+        case 'hyperresolution': return 'Hyperresolution';
+        case 'set-of-support': return 'Set-of-support';
+        case 'ordered': return 'Ordered resolution';
+        case 'unit-preference': return 'Unit preference';
+    }
+}
+//# sourceMappingURL=prover.js.map

package/dist/proof-systems/fol-prover-advanced/prover.js.map

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

package/dist/proof-systems/fol-prover-advanced/resolve.d.ts

@@ -0,0 +1,43 @@
+import type { FOLClause, Substitution } from './types';
+export declare function resetRenameCounter(): void;
+/**
+ * Renombra todas las variables de una cláusula con sufijos frescos, para
+ * evitar captura accidental al resolver con otra cláusula.
+ */
+export declare function renameClause(c: FOLClause): FOLClause;
+/**
+ * Resolución binaria: une dos cláusulas eliminando un par de literales
+ * complementarias unificables. Devuelve cero o más resolventes (uno por par
+ * de literales complementarias que unifiquen).
+ */
+export declare function binaryResolve(a: FOLClause, b: FOLClause): Array<{
+    clause: FOLClause;
+    sub: Substitution;
+}>;
+/**
+ * Hyperresolución: en un solo paso, elimina **todas** las literales negativas
+ * de un "núcleo" (nucleus) usando cláusulas auxiliares positivas (electrons)
+ * que sean unitarias o tengan sólo literales positivas. El resultado es una
+ * cláusula con sólo literales positivas (positive hyperresolvent).
+ *
+ * `positive` aquí es una lista; en la práctica el caller pasa cláusulas
+ * positivas candidatas y la función produce todos los hyperresolventes
+ * posibles del núcleo contra ese conjunto. Para mantener la API del spec,
+ * exportamos `hyperresolve(positive, nucleus)` con la primera cláusula como
+ * electron (cubre el caso "3 units + nucleus" si se llama en cadena).
+ */
+export declare function hyperresolve(positive: FOLClause, nucleus: FOLClause): FOLClause[];
+export declare function hyperresolveMany(positives: FOLClause[], nucleus: FOLClause): Array<{
+    clause: FOLClause;
+    sub: Substitution;
+    usedElectrons: number[];
+}>;
+/**
+ * Factoring: si dos literales del mismo signo unifican, colapsarlas reduce la
+ * cláusula. Indispensable para completar la resolución.
+ */
+export declare function factor(c: FOLClause): FOLClause[];
+export declare function dedupLiterals(c: FOLClause): FOLClause;
+/** Detecta cláusulas tautológicas (P ∨ ¬P). */
+export declare function isTautology(c: FOLClause): boolean;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/proof-systems/fol-prover-advanced/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAuB,YAAY,EAAE,MAAM,SAAS,CAAC;AAK5E,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAapD;AAiBD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,KAAK,CAAC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,YAAY,CAAA;CAAE,CAAC,CA8BzG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,SAAS,EAAE,CAEjF;AAED,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,SAAS,EAAE,EACtB,OAAO,EAAE,SAAS,GACjB,KAAK,CAAC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,YAAY,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAyG1E;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAuBhD;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAMrD;AAED,+CAA+C;AAC/C,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAoBjD"}