@stevenvo780/st-lang 4.1.0 → 4.3.0

package/dist/profiles/sequent-g3/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/profiles/sequent-g3/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,mDAAmD;AACnD,+DAA+D;AAC/D,EAAE;AACF,qEAAqE;AACrE,oEAAoE;AACpE,wEAAwE;AACxE,aAAa;AACb,EAAE;AACF,wDAAwD;AACxD,sCAAsC;;;AAGtC,mCAAsD;AAA7C,sGAAA,YAAY,OAAA;AAAE,sGAAA,YAAY,OAAA;AACnC,iCAAuC;AAA9B,qGAAA,YAAY,OAAA;AACrB,yCAAyD;AAAhD,2GAAA,cAAc,OAAA;AAAE,uGAAA,UAAU,OAAA"}

package/dist/profiles/sequent-g3/latex.d.ts

@@ -0,0 +1,7 @@
+import { ProofTree } from './types';
+/**
+ * Convierte un `ProofTree` G3 en codigo LaTeX bussproofs listo para
+ * embeberse dentro de un documento. Asume `\usepackage{bussproofs}`.
+ */
+export declare function proofToLatex(proof: ProofTree): string;
+//# sourceMappingURL=latex.d.ts.map

package/dist/profiles/sequent-g3/latex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latex.d.ts","sourceRoot":"","sources":["../../../src/profiles/sequent-g3/latex.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,SAAS,EAAwB,MAAM,SAAS,CAAC;AA8F1D;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAIrD"}

package/dist/profiles/sequent-g3/latex.js

@@ -0,0 +1,107 @@
+"use strict";
+// ============================================================
+// G3 — Export de arboles de prueba a LaTeX (bussproofs)
+// ============================================================
+//
+// Genera codigo bussproofs valido para LaTeX. Cada nodo del arbol
+// produce un bloque \AxiomC / \UnaryInfC / \BinaryInfC con la
+// regla anotada en \RightLabel. La raiz queda envuelta en un
+// $\DisplayProof$ para ser inmediatamente renderizable.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proofToLatex = proofToLatex;
+const RULE_LABEL = {
+    axiom: '\\textsc{Ax}',
+    falseL: '$\\bot_L$',
+    trueR: '$\\top_R$',
+    andL: '$\\wedge_L$',
+    andR: '$\\wedge_R$',
+    orL: '$\\vee_L$',
+    orR: '$\\vee_R$',
+    impL: '$\\to_L$',
+    impR: '$\\to_R$',
+    notL: '$\\neg_L$',
+    notR: '$\\neg_R$',
+};
+function formulaToLatex(f) {
+    switch (f.kind) {
+        case 'atom':
+            return escapeAtom(f.name ?? '?');
+        case 'true':
+            return '\\top';
+        case 'false':
+            return '\\bot';
+        case 'not': {
+            const inner = f.args && f.args[0] ? f.args[0] : undefined;
+            if (!inner)
+                return '\\neg ?';
+            return inner.kind === 'atom' || inner.kind === 'true' || inner.kind === 'false'
+                ? `\\neg ${formulaToLatex(inner)}`
+                : `\\neg (${formulaToLatex(inner)})`;
+        }
+        case 'and':
+            return binop(f, '\\wedge');
+        case 'or':
+            return binop(f, '\\vee');
+        case 'implies':
+            return binop(f, '\\to');
+        case 'biconditional':
+            return binop(f, '\\leftrightarrow');
+        default:
+            // Fallback: usar `kind` como etiqueta opaca
+            return `\\mathit{${escapeAtom(f.kind)}}`;
+    }
+}
+function binop(f, op) {
+    const a = f.args && f.args[0] ? formulaToLatex(f.args[0]) : '?';
+    const b = f.args && f.args[1] ? formulaToLatex(f.args[1]) : '?';
+    return `(${a} ${op} ${b})`;
+}
+function escapeAtom(name) {
+    // bussproofs corre dentro de math mode: hay que escapar caracteres
+    // problematicos como `_` y `#` para evitar romper el render.
+    return name.replace(/([\\#$%&_{}])/g, '\\$1');
+}
+function sequentToLatex(seq) {
+    const left = seq.left.map(formulaToLatex).join(', ');
+    const right = seq.right.map(formulaToLatex).join(', ');
+    return `$${left} \\vdash ${right}$`;
+}
+function emit(tree, lines) {
+    // Recorrido post-orden: emitimos premisas primero porque bussproofs
+    // consume el stack de \AxiomC en orden top-down.
+    if (!tree.rule || tree.premises.length === 0) {
+        // Hoja: axiom, falseL, trueR, o rama abierta.
+        if (tree.rule === 'axiom' || tree.rule === 'falseL' || tree.rule === 'trueR') {
+            lines.push(`\\AxiomC{${sequentToLatex(tree.goal)}}`);
+            lines.push(`\\RightLabel{${RULE_LABEL[tree.rule]}}`);
+            lines.push(`\\UnaryInfC{${sequentToLatex(tree.goal)}}`);
+        }
+        else {
+            // Rama abierta (no cerrable): emitimos como axioma marcado.
+            lines.push(`\\AxiomC{${sequentToLatex(tree.goal)}}`);
+            lines.push(`\\RightLabel{\\textsc{open}}`);
+            lines.push(`\\UnaryInfC{${sequentToLatex(tree.goal)}}`);
+        }
+        return;
+    }
+    for (const premise of tree.premises) {
+        emit(premise, lines);
+    }
+    lines.push(`\\RightLabel{${RULE_LABEL[tree.rule]}}`);
+    const infCmd = tree.premises.length === 1
+        ? 'UnaryInfC'
+        : tree.premises.length === 2
+            ? 'BinaryInfC'
+            : 'TrinaryInfC';
+    lines.push(`\\${infCmd}{${sequentToLatex(tree.goal)}}`);
+}
+/**
+ * Convierte un `ProofTree` G3 en codigo LaTeX bussproofs listo para
+ * embeberse dentro de un documento. Asume `\usepackage{bussproofs}`.
+ */
+function proofToLatex(proof) {
+    const lines = [];
+    emit(proof, lines);
+    return `\\begin{prooftree}\n${lines.join('\n')}\n\\end{prooftree}`;
+}
+//# sourceMappingURL=latex.js.map

package/dist/profiles/sequent-g3/latex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"latex.js","sourceRoot":"","sources":["../../../src/profiles/sequent-g3/latex.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,wDAAwD;AACxD,+DAA+D;AAC/D,EAAE;AACF,kEAAkE;AAClE,8DAA8D;AAC9D,6DAA6D;AAC7D,wDAAwD;;AAqGxD,oCAIC;AApGD,MAAM,UAAU,GAAgC;IAC9C,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,WAAW;IACnB,KAAK,EAAE,WAAW;IAClB,IAAI,EAAE,aAAa;IACnB,IAAI,EAAE,aAAa;IACnB,GAAG,EAAE,WAAW;IAChB,GAAG,EAAE,WAAW;IAChB,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,WAAW;IACjB,IAAI,EAAE,WAAW;CAClB,CAAC;AAEF,SAAS,cAAc,CAAC,CAAU;IAChC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,MAAM;YACT,OAAO,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC;QACnC,KAAK,MAAM;YACT,OAAO,OAAO,CAAC;QACjB,KAAK,OAAO;YACV,OAAO,OAAO,CAAC;QACjB,KAAK,KAAK,CAAC,CAAC,CAAC;YACX,MAAM,KAAK,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC1D,IAAI,CAAC,KAAK;gBAAE,OAAO,SAAS,CAAC;YAC7B,OAAO,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;gBAC7E,CAAC,CAAC,SAAS,cAAc,CAAC,KAAK,CAAC,EAAE;gBAClC,CAAC,CAAC,UAAU,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC;QACzC,CAAC;QACD,KAAK,KAAK;YACR,OAAO,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QAC7B,KAAK,IAAI;YACP,OAAO,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;QAC3B,KAAK,SAAS;YACZ,OAAO,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;QAC1B,KAAK,eAAe;YAClB,OAAO,KAAK,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;QACtC;YACE,4CAA4C;YAC5C,OAAO,YAAY,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;IAC7C,CAAC;AACH,CAAC;AAED,SAAS,KAAK,CAAC,CAAU,EAAE,EAAU;IACnC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IAChE,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IAChE,OAAO,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC;AAC7B,CAAC;AAED,SAAS,UAAU,CAAC,IAAY;IAC9B,mEAAmE;IACnE,6DAA6D;IAC7D,OAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;AAChD,CAAC;AAED,SAAS,cAAc,CAAC,GAAY;IAClC,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACrD,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvD,OAAO,IAAI,IAAI,YAAY,KAAK,GAAG,CAAC;AACtC,CAAC;AAED,SAAS,IAAI,CAAC,IAAe,EAAE,KAAe;IAC5C,oEAAoE;IACpE,iDAAiD;IACjD,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7C,8CAA8C;QAC9C,IAAI,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC7E,KAAK,CAAC,IAAI,CAAC,YAAY,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACrD,KAAK,CAAC,IAAI,CAAC,gBAAgB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACrD,KAAK,CAAC,IAAI,CAAC,eAAe,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC1D,CAAC;aAAM,CAAC;YACN,4DAA4D;YAC5D,KAAK,CAAC,IAAI,CAAC,YAAY,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACrD,KAAK,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;YAC3C,KAAK,CAAC,IAAI,CAAC,eAAe,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC1D,CAAC;QACD,OAAO;IACT,CAAC;IAED,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;QACpC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACvB,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,gBAAgB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACrD,MAAM,MAAM,GACV,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC;QACxB,CAAC,CAAC,WAAW;QACb,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC;YAC1B,CAAC,CAAC,YAAY;YACd,CAAC,CAAC,aAAa,CAAC;IACtB,KAAK,CAAC,IAAI,CAAC,KAAK,MAAM,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC1D,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAC,KAAgB;IAC3C,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACnB,OAAO,uBAAuB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC;AACrE,CAAC"}

package/dist/profiles/sequent-g3/normalize.d.ts

@@ -0,0 +1,15 @@
+import { Formula } from '../../types';
+/**
+ * Reescribe la formula al nucleo {atom, true, false, not, and, or, implies}
+ * preservando las locaciones. Las formulas no proposicionales se dejan tal
+ * cual: el prover las tratara como atomicas y normalmente no podra cerrar
+ * la prueba salvo coincidencia sintactica exacta.
+ */
+export declare function normalizeForG3(f: Formula): Formula;
+/**
+ * Canoniza una formula a una representacion textual estable que ignora
+ * `source` y normaliza orden interno donde aplica. Sirve como clave para
+ * comparar formulas en multisets.
+ */
+export declare function formulaKey(f: Formula): string;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/profiles/sequent-g3/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/profiles/sequent-g3/normalize.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAgElD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CA2B7C"}

package/dist/profiles/sequent-g3/normalize.js

@@ -0,0 +1,121 @@
+"use strict";
+// ============================================================
+// G3 — Normalizacion de formulas a {atom, not, and, or, implies}
+// ============================================================
+//
+// El nucleo G3 razona sobre 5 conectivos. Las formulas con
+// biconditional, xor, nand, nor se reescriben a esa base; tambien
+// se expanden cuantificadores y operadores aritmeticos no
+// soportados (devolviendo error semantico via NaN-formula).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeForG3 = normalizeForG3;
+exports.formulaKey = formulaKey;
+/**
+ * Reescribe la formula al nucleo {atom, true, false, not, and, or, implies}
+ * preservando las locaciones. Las formulas no proposicionales se dejan tal
+ * cual: el prover las tratara como atomicas y normalmente no podra cerrar
+ * la prueba salvo coincidencia sintactica exacta.
+ */
+function normalizeForG3(f) {
+    switch (f.kind) {
+        case 'atom':
+        case 'true':
+        case 'false':
+            return f;
+        case 'not': {
+            const inner = f.args && f.args[0] ? normalizeForG3(f.args[0]) : f;
+            return { kind: 'not', args: [inner], source: f.source };
+        }
+        case 'and':
+        case 'or':
+        case 'implies': {
+            const a = f.args && f.args[0] ? normalizeForG3(f.args[0]) : f;
+            const b = f.args && f.args[1] ? normalizeForG3(f.args[1]) : f;
+            return { kind: f.kind, args: [a, b], source: f.source };
+        }
+        case 'biconditional': {
+            // A ↔ B  ≡  (A → B) ∧ (B → A)
+            if (!f.args || !f.args[0] || !f.args[1])
+                return f;
+            const a = normalizeForG3(f.args[0]);
+            const b = normalizeForG3(f.args[1]);
+            return {
+                kind: 'and',
+                args: [
+                    { kind: 'implies', args: [a, b] },
+                    { kind: 'implies', args: [b, a] },
+                ],
+                source: f.source,
+            };
+        }
+        case 'xor': {
+            // A ⊕ B  ≡  (A ∧ ¬B) ∨ (¬A ∧ B)
+            if (!f.args || !f.args[0] || !f.args[1])
+                return f;
+            const a = normalizeForG3(f.args[0]);
+            const b = normalizeForG3(f.args[1]);
+            return {
+                kind: 'or',
+                args: [
+                    { kind: 'and', args: [a, { kind: 'not', args: [b] }] },
+                    { kind: 'and', args: [{ kind: 'not', args: [a] }, b] },
+                ],
+                source: f.source,
+            };
+        }
+        case 'nand': {
+            // A ↑ B  ≡  ¬(A ∧ B)
+            if (!f.args || !f.args[0] || !f.args[1])
+                return f;
+            const a = normalizeForG3(f.args[0]);
+            const b = normalizeForG3(f.args[1]);
+            return { kind: 'not', args: [{ kind: 'and', args: [a, b] }], source: f.source };
+        }
+        case 'nor': {
+            // A ↓ B  ≡  ¬(A ∨ B)
+            if (!f.args || !f.args[0] || !f.args[1])
+                return f;
+            const a = normalizeForG3(f.args[0]);
+            const b = normalizeForG3(f.args[1]);
+            return { kind: 'not', args: [{ kind: 'or', args: [a, b] }], source: f.source };
+        }
+        default:
+            // Cuantificadores, predicados, modales, aritmetica: el prover
+            // proposicional los trata como atomos opacos.
+            return f;
+    }
+}
+/**
+ * Canoniza una formula a una representacion textual estable que ignora
+ * `source` y normaliza orden interno donde aplica. Sirve como clave para
+ * comparar formulas en multisets.
+ */
+function formulaKey(f) {
+    switch (f.kind) {
+        case 'atom':
+            return `a:${f.name ?? '?'}`;
+        case 'true':
+            return 'T';
+        case 'false':
+            return 'F';
+        case 'not':
+            return `n(${f.args && f.args[0] ? formulaKey(f.args[0]) : '?'})`;
+        case 'and':
+        case 'or':
+        case 'implies':
+        case 'biconditional': {
+            const a = f.args && f.args[0] ? formulaKey(f.args[0]) : '?';
+            const b = f.args && f.args[1] ? formulaKey(f.args[1]) : '?';
+            return `${f.kind}(${a},${b})`;
+        }
+        case 'predicate':
+            return `p:${f.name ?? '?'}(${(f.params ?? f.terms ?? []).join(',')})`;
+        case 'forall':
+        case 'exists':
+            return `${f.kind}:${f.variable ?? '?'}(${f.args && f.args[0] ? formulaKey(f.args[0]) : '?'})`;
+        default:
+            // Fallback: usar kind + estructura recursiva
+            return `${f.kind}(${(f.args ?? []).map(formulaKey).join(',')})`;
+    }
+}
+//# sourceMappingURL=normalize.js.map

package/dist/profiles/sequent-g3/normalize.js.map

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

package/dist/profiles/sequent-g3/prover.d.ts

@@ -0,0 +1,16 @@
+import { Formula } from '../../types';
+import { Sequent, ProveResult } from './types';
+/**
+ * Demuestra `seq` (Γ ⊢ Δ) por backward search en G3.
+ * Normaliza las formulas antes de comenzar.
+ */
+export declare function proveSequent(seq: Sequent, options?: {
+    budget?: number;
+}): ProveResult;
+/**
+ * Atajo: demuestra que `⊢ φ` (formula sin hipotesis) es valida en G3.
+ */
+export declare function proveFormula(formula: Formula, options?: {
+    budget?: number;
+}): ProveResult;
+//# sourceMappingURL=prover.d.ts.map

package/dist/profiles/sequent-g3/prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prover.d.ts","sourceRoot":"","sources":["../../../src/profiles/sequent-g3/prover.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAa,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAyV1D;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,WAAW,CAOzF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,WAAW,CAE7F"}

package/dist/profiles/sequent-g3/prover.js

@@ -0,0 +1,348 @@
+"use strict";
+// ============================================================
+// G3 — Backward proof search
+// ============================================================
+//
+// Busqueda hacia atras (root-first). Las reglas de G3 son
+// invertibles, por lo que NO hay que retroceder al elegir la
+// proxima regla: cualquier formula compleja que aplique cierra
+// el subgoal sii la version sin descomponer era cerrable.
+//
+// Terminacion: cada paso reemplaza una formula compleja por
+// sub-formulas estrictamente menores. Para evitar contracciones
+// redundantes en multisets, se dedupica por clave sintactica
+// antes de aplicar la siguiente regla.
+//
+// Branching:
+//   - andR, orL, impL ramifican en 2 premisas (cada una debe cerrar).
+//   - andL, orR, impR, notL, notR son lineales (1 premisa).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proveSequent = proveSequent;
+exports.proveFormula = proveFormula;
+const normalize_1 = require("./normalize");
+function slotsOf(list) {
+    return list.map((f) => ({ formula: f, key: (0, normalize_1.formulaKey)(f) }));
+}
+function dedupSlots(slots) {
+    const seen = new Set();
+    const out = [];
+    for (const slot of slots) {
+        if (!seen.has(slot.key)) {
+            seen.add(slot.key);
+            out.push(slot);
+        }
+    }
+    return out;
+}
+function isAtomic(f) {
+    // En G3, los atomos del calculo proposicional son atom/true/false.
+    // Tambien tratamos como opacas las formulas no-proposicionales
+    // (predicados, modales, ...) para que el prover no las descomponga.
+    switch (f.kind) {
+        case 'atom':
+        case 'true':
+        case 'false':
+            return true;
+        case 'not':
+        case 'and':
+        case 'or':
+        case 'implies':
+            return false;
+        default:
+            // Predicados/cuantificadores/etc: opacos.
+            return true;
+    }
+}
+function findAxiomMatch(left, right) {
+    const rightKeys = new Set(right.map((s) => s.key));
+    for (const slot of left) {
+        if (rightKeys.has(slot.key))
+            return slot.formula;
+    }
+    return undefined;
+}
+function findFalseLeft(left) {
+    return left.find((s) => s.formula.kind === 'false')?.formula;
+}
+function findTrueRight(right) {
+    return right.find((s) => s.formula.kind === 'true')?.formula;
+}
+/**
+ * Busca la primera formula no-atomica en `slots` y devuelve su indice y
+ * el slot. Si no hay ninguna, devuelve undefined.
+ */
+function findFirstComplex(slots) {
+    for (let i = 0; i < slots.length; i++) {
+        const slot = slots[i];
+        if (slot && !isAtomic(slot.formula))
+            return { index: i, slot };
+    }
+    return undefined;
+}
+function removeAt(arr, idx) {
+    const copy = arr.slice();
+    copy.splice(idx, 1);
+    return copy;
+}
+function toSequent(left, right) {
+    return {
+        left: left.map((s) => s.formula),
+        right: right.map((s) => s.formula),
+    };
+}
+function exhausted(ctx) {
+    return ctx.used >= ctx.budget;
+}
+function prove(left, right, ctx) {
+    ctx.used++;
+    if (exhausted(ctx))
+        return undefined;
+    const dedupL = dedupSlots(left);
+    const dedupR = dedupSlots(right);
+    const goal = toSequent(dedupL, dedupR);
+    // 1. Axioma: misma formula a izquierda y derecha.
+    const axiomFormula = findAxiomMatch(dedupL, dedupR);
+    if (axiomFormula) {
+        return { goal, rule: 'axiom', principalFormula: axiomFormula, premises: [], closed: true };
+    }
+    // 2. ⊥ en la izquierda cierra inmediatamente.
+    const bottomLeft = findFalseLeft(dedupL);
+    if (bottomLeft) {
+        return { goal, rule: 'falseL', principalFormula: bottomLeft, premises: [], closed: true };
+    }
+    // 3. ⊤ en la derecha cierra inmediatamente.
+    const topRight = findTrueRight(dedupR);
+    if (topRight) {
+        return { goal, rule: 'trueR', principalFormula: topRight, premises: [], closed: true };
+    }
+    // 4. Reglas no-ramificantes primero (siempre que existan).
+    //    Esto reduce el espacio antes de ramificar y produce arboles mas
+    //    pequenos sin sacrificar completitud (las reglas son invertibles).
+    // notL: Γ, ¬A ⊢ Δ  ↦  Γ ⊢ A, Δ
+    for (let i = 0; i < dedupL.length; i++) {
+        const slot = dedupL[i];
+        if (slot && slot.formula.kind === 'not' && slot.formula.args && slot.formula.args[0]) {
+            const inner = slot.formula.args[0];
+            const newL = removeAt(dedupL, i);
+            const newR = [{ formula: inner, key: (0, normalize_1.formulaKey)(inner) }, ...dedupR];
+            const sub = prove(newL, newR, ctx);
+            if (!sub)
+                return undefined;
+            return {
+                goal,
+                rule: 'notL',
+                principalFormula: slot.formula,
+                premises: [sub],
+                closed: sub.closed,
+            };
+        }
+    }
+    // notR: Γ ⊢ ¬A, Δ  ↦  Γ, A ⊢ Δ
+    for (let i = 0; i < dedupR.length; i++) {
+        const slot = dedupR[i];
+        if (slot && slot.formula.kind === 'not' && slot.formula.args && slot.formula.args[0]) {
+            const inner = slot.formula.args[0];
+            const newR = removeAt(dedupR, i);
+            const newL = [{ formula: inner, key: (0, normalize_1.formulaKey)(inner) }, ...dedupL];
+            const sub = prove(newL, newR, ctx);
+            if (!sub)
+                return undefined;
+            return {
+                goal,
+                rule: 'notR',
+                principalFormula: slot.formula,
+                premises: [sub],
+                closed: sub.closed,
+            };
+        }
+    }
+    // andL: Γ, A∧B ⊢ Δ  ↦  Γ, A, B ⊢ Δ
+    for (let i = 0; i < dedupL.length; i++) {
+        const slot = dedupL[i];
+        if (slot &&
+            slot.formula.kind === 'and' &&
+            slot.formula.args &&
+            slot.formula.args[0] &&
+            slot.formula.args[1]) {
+            const a = slot.formula.args[0];
+            const b = slot.formula.args[1];
+            const newL = [
+                { formula: a, key: (0, normalize_1.formulaKey)(a) },
+                { formula: b, key: (0, normalize_1.formulaKey)(b) },
+                ...removeAt(dedupL, i),
+            ];
+            const sub = prove(newL, dedupR, ctx);
+            if (!sub)
+                return undefined;
+            return {
+                goal,
+                rule: 'andL',
+                principalFormula: slot.formula,
+                premises: [sub],
+                closed: sub.closed,
+            };
+        }
+    }
+    // orR: Γ ⊢ A∨B, Δ  ↦  Γ ⊢ A, B, Δ
+    for (let i = 0; i < dedupR.length; i++) {
+        const slot = dedupR[i];
+        if (slot &&
+            slot.formula.kind === 'or' &&
+            slot.formula.args &&
+            slot.formula.args[0] &&
+            slot.formula.args[1]) {
+            const a = slot.formula.args[0];
+            const b = slot.formula.args[1];
+            const newR = [
+                { formula: a, key: (0, normalize_1.formulaKey)(a) },
+                { formula: b, key: (0, normalize_1.formulaKey)(b) },
+                ...removeAt(dedupR, i),
+            ];
+            const sub = prove(dedupL, newR, ctx);
+            if (!sub)
+                return undefined;
+            return {
+                goal,
+                rule: 'orR',
+                principalFormula: slot.formula,
+                premises: [sub],
+                closed: sub.closed,
+            };
+        }
+    }
+    // impR: Γ ⊢ A→B, Δ  ↦  Γ, A ⊢ B, Δ
+    for (let i = 0; i < dedupR.length; i++) {
+        const slot = dedupR[i];
+        if (slot &&
+            slot.formula.kind === 'implies' &&
+            slot.formula.args &&
+            slot.formula.args[0] &&
+            slot.formula.args[1]) {
+            const a = slot.formula.args[0];
+            const b = slot.formula.args[1];
+            const newL = [{ formula: a, key: (0, normalize_1.formulaKey)(a) }, ...dedupL];
+            const newR = [{ formula: b, key: (0, normalize_1.formulaKey)(b) }, ...removeAt(dedupR, i)];
+            const sub = prove(newL, newR, ctx);
+            if (!sub)
+                return undefined;
+            return {
+                goal,
+                rule: 'impR',
+                principalFormula: slot.formula,
+                premises: [sub],
+                closed: sub.closed,
+            };
+        }
+    }
+    // 5. Reglas ramificantes (despues de las lineales).
+    // andR: Γ ⊢ A∧B, Δ  ↦  Γ ⊢ A, Δ  ∧  Γ ⊢ B, Δ
+    for (let i = 0; i < dedupR.length; i++) {
+        const slot = dedupR[i];
+        if (slot &&
+            slot.formula.kind === 'and' &&
+            slot.formula.args &&
+            slot.formula.args[0] &&
+            slot.formula.args[1]) {
+            const a = slot.formula.args[0];
+            const b = slot.formula.args[1];
+            const restR = removeAt(dedupR, i);
+            const subA = prove(dedupL, [{ formula: a, key: (0, normalize_1.formulaKey)(a) }, ...restR], ctx);
+            if (!subA)
+                return undefined;
+            const subB = prove(dedupL, [{ formula: b, key: (0, normalize_1.formulaKey)(b) }, ...restR], ctx);
+            if (!subB)
+                return undefined;
+            return {
+                goal,
+                rule: 'andR',
+                principalFormula: slot.formula,
+                premises: [subA, subB],
+                closed: subA.closed && subB.closed,
+            };
+        }
+    }
+    // orL: Γ, A∨B ⊢ Δ  ↦  Γ, A ⊢ Δ  ∧  Γ, B ⊢ Δ
+    for (let i = 0; i < dedupL.length; i++) {
+        const slot = dedupL[i];
+        if (slot &&
+            slot.formula.kind === 'or' &&
+            slot.formula.args &&
+            slot.formula.args[0] &&
+            slot.formula.args[1]) {
+            const a = slot.formula.args[0];
+            const b = slot.formula.args[1];
+            const restL = removeAt(dedupL, i);
+            const subA = prove([{ formula: a, key: (0, normalize_1.formulaKey)(a) }, ...restL], dedupR, ctx);
+            if (!subA)
+                return undefined;
+            const subB = prove([{ formula: b, key: (0, normalize_1.formulaKey)(b) }, ...restL], dedupR, ctx);
+            if (!subB)
+                return undefined;
+            return {
+                goal,
+                rule: 'orL',
+                principalFormula: slot.formula,
+                premises: [subA, subB],
+                closed: subA.closed && subB.closed,
+            };
+        }
+    }
+    // impL: Γ, A→B ⊢ Δ  ↦  Γ ⊢ A, Δ  ∧  Γ, B ⊢ Δ
+    for (let i = 0; i < dedupL.length; i++) {
+        const slot = dedupL[i];
+        if (slot &&
+            slot.formula.kind === 'implies' &&
+            slot.formula.args &&
+            slot.formula.args[0] &&
+            slot.formula.args[1]) {
+            const a = slot.formula.args[0];
+            const b = slot.formula.args[1];
+            const restL = removeAt(dedupL, i);
+            const subA = prove(restL, [{ formula: a, key: (0, normalize_1.formulaKey)(a) }, ...dedupR], ctx);
+            if (!subA)
+                return undefined;
+            const subB = prove([{ formula: b, key: (0, normalize_1.formulaKey)(b) }, ...restL], dedupR, ctx);
+            if (!subB)
+                return undefined;
+            return {
+                goal,
+                rule: 'impL',
+                principalFormula: slot.formula,
+                premises: [subA, subB],
+                closed: subA.closed && subB.closed,
+            };
+        }
+    }
+    // 6. Si llegamos aca, no quedan formulas complejas que descomponer y
+    //    no se encontro axioma: el secuente no es derivable (es una hoja
+    //    abierta del arbol de busqueda).
+    const complexL = findFirstComplex(dedupL);
+    const complexR = findFirstComplex(dedupR);
+    if (!complexL && !complexR) {
+        return { goal, premises: [], closed: false };
+    }
+    // Si todavia queda complejidad pero nuestras ramas fueron consumidas,
+    // significa que el algoritmo no encontro forma de avanzar. No deberia
+    // ocurrir con la base normalizada; devolvemos undefined como senal.
+    return undefined;
+}
+/**
+ * Demuestra `seq` (Γ ⊢ Δ) por backward search en G3.
+ * Normaliza las formulas antes de comenzar.
+ */
+function proveSequent(seq, options = {}) {
+    const normLeft = seq.left.map(normalize_1.normalizeForG3);
+    const normRight = seq.right.map(normalize_1.normalizeForG3);
+    const ctx = { budget: options.budget ?? 5_000, used: 0 };
+    const tree = prove(slotsOf(normLeft), slotsOf(normRight), ctx);
+    if (!tree)
+        return { provable: false };
+    return { provable: tree.closed, proof: tree };
+}
+/**
+ * Atajo: demuestra que `⊢ φ` (formula sin hipotesis) es valida en G3.
+ */
+function proveFormula(formula, options = {}) {
+    return proveSequent({ left: [], right: [formula] }, options);
+}
+//# sourceMappingURL=prover.js.map