@stevenvo780/st-lang 4.2.0 → 4.4.0

package/dist/profiles/sequent-lk/cut-elimination.js

@@ -0,0 +1,216 @@
+"use strict";
+// ============================================================
+// LK — Eliminacion de cortes (Hauptsatz de Gentzen, 1934)
+// ============================================================
+//
+// El teorema fundamental dice que toda derivacion LK puede
+// transformarse en una sin cortes. La prueba procede por
+// induccion lexicografica sobre (rango, grado) del cut superior:
+//
+//   * rango = altura del cut en el arbol
+//   * grado = profundidad de la formula cortada
+//
+// La implementacion aqui combina dos estrategias:
+//
+//   1. Reducciones "principales": cuando la formula cortada es
+//      principal en ambas premisas, se aplica la regla de
+//      reduccion correspondiente al conectivo (notable: ∧/∨/→/¬).
+//   2. Reduccion estructural: para casos en que la reescritura
+//      directa no aplica (ej. cuts internos en sub-derivaciones
+//      con weakenings/contractions implicitas), reusamos el
+//      prover cut-free `proveLK` como oraculo: por el Hauptsatz,
+//      si el secuente es derivable con cortes, lo es sin ellos,
+//      y `proveLK` es completo para LK clasico cut-free.
+//
+// El resultado garantiza `hasCut(out) === false` cuando la entrada
+// es valida y derivable.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eliminateCut = eliminateCut;
+const util_1 = require("./util");
+const prover_1 = require("./prover");
+function eliminateCutAtRoot(proof) {
+    if (proof.rule !== 'cut')
+        return proof;
+    const [p1, p2] = proof.premises;
+    if (!p1 || !p2 || !proof.cutFormula)
+        return proof;
+    const A = proof.cutFormula;
+    const ak = (0, util_1.lkKey)(A);
+    // Caso axioma: A ⊢ A   cut   A, Σ ⊢ Π   ⟹   A, Σ ⊢ Π  (= p2)
+    if (p1.rule === 'axiom' && p1.principalFormula && (0, util_1.lkKey)(p1.principalFormula) === ak) {
+        return p2;
+    }
+    if (p2.rule === 'axiom' && p2.principalFormula && (0, util_1.lkKey)(p2.principalFormula) === ak) {
+        return p1;
+    }
+    // Reduccion principal por conectivo del cut formula.
+    // Solo aplicable cuando A es principal en ambas premisas.
+    const principalOnLeft = p1.principalFormula && (0, util_1.lkKey)(p1.principalFormula) === ak;
+    const principalOnRight = p2.principalFormula && (0, util_1.lkKey)(p2.principalFormula) === ak;
+    if (principalOnLeft && principalOnRight) {
+        switch (A.kind) {
+            case 'not': {
+                // p1 termina en notR: Γ ⊢ ¬B, Δ por premisa B, Γ ⊢ Δ
+                // p2 termina en notL: ¬B, Σ ⊢ Π por premisa Σ ⊢ B, Π
+                // Reescribimos como cut sobre B:
+                //   Σ ⊢ B, Π   cut   B, Γ ⊢ Δ   ⟹   Σ, Γ ⊢ Π, Δ
+                const sub1 = p2.premises[0];
+                const sub2 = p1.premises[0];
+                if (!sub1 || !sub2)
+                    break;
+                const newCut = {
+                    goal: proof.goal,
+                    rule: 'cut',
+                    cutFormula: A.arg,
+                    premises: [sub1, sub2],
+                };
+                return eliminateCut(newCut);
+            }
+            case 'and': {
+                // p1 termina en andR con A = B∧C, premisas: Γ ⊢ B, Δ y Γ ⊢ C, Δ
+                // p2 termina en andL con premisa B, C, Σ ⊢ Π
+                // Cut sobre B y C:
+                //   Γ ⊢ B, Δ   cut_B   ( Γ ⊢ C, Δ   cut_C   B, C, Σ ⊢ Π )
+                const subB = p1.premises[0];
+                const subC = p1.premises[1];
+                const subBC = p2.premises[0];
+                if (!subB || !subC || !subBC)
+                    break;
+                const innerCut = {
+                    goal: {
+                        left: [
+                            ...subC.goal.left,
+                            ...subBC.goal.left.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.right)),
+                        ],
+                        right: [
+                            ...subC.goal.right.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.right)),
+                            ...subBC.goal.right,
+                        ],
+                    },
+                    rule: 'cut',
+                    cutFormula: A.right,
+                    premises: [subC, subBC],
+                };
+                const outerCut = {
+                    goal: proof.goal,
+                    rule: 'cut',
+                    cutFormula: A.left,
+                    premises: [subB, innerCut],
+                };
+                return eliminateCut(outerCut);
+            }
+            case 'or': {
+                // p1 termina en orR con A = B∨C, premisa: Γ ⊢ B, C, Δ
+                // p2 termina en orL: premisas B, Σ ⊢ Π y C, Σ ⊢ Π
+                const subBC = p1.premises[0];
+                const subB = p2.premises[0];
+                const subC = p2.premises[1];
+                if (!subBC || !subB || !subC)
+                    break;
+                // Cut sobre B y luego C:
+                const innerCut = {
+                    goal: {
+                        left: [
+                            ...subBC.goal.left,
+                            ...subC.goal.left.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.right)),
+                        ],
+                        right: [
+                            ...subBC.goal.right.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.right) && (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.left)),
+                            ...subC.goal.right,
+                        ],
+                    },
+                    rule: 'cut',
+                    cutFormula: A.right,
+                    premises: [subBC, subC],
+                };
+                const outerCut = {
+                    goal: proof.goal,
+                    rule: 'cut',
+                    cutFormula: A.left,
+                    premises: [innerCut, subB],
+                };
+                return eliminateCut(outerCut);
+            }
+            case 'implies': {
+                // p1 termina en impR con A = B→C, premisa: B, Γ ⊢ C, Δ
+                // p2 termina en impL: premisas Σ ⊢ B, Π y C, Σ ⊢ Π
+                const subBC = p1.premises[0];
+                const subB = p2.premises[0];
+                const subC = p2.premises[1];
+                if (!subBC || !subB || !subC)
+                    break;
+                // Cut sobre B: Σ ⊢ B, Π  y  B, Γ ⊢ C, Δ  → Σ, Γ ⊢ C, Π, Δ
+                // Cut sobre C: ↑resultado  y  C, Σ ⊢ Π  → Σ, Γ, Σ ⊢ Π, Δ
+                const innerCut = {
+                    goal: {
+                        left: [...subB.goal.left, ...subBC.goal.left.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.left))],
+                        right: [
+                            ...subB.goal.right.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.left)),
+                            ...subBC.goal.right,
+                        ],
+                    },
+                    rule: 'cut',
+                    cutFormula: A.left,
+                    premises: [subB, subBC],
+                };
+                const outerCut = {
+                    goal: proof.goal,
+                    rule: 'cut',
+                    cutFormula: A.right,
+                    premises: [innerCut, subC],
+                };
+                return eliminateCut(outerCut);
+            }
+            case 'atom':
+                // Si A es atomico y aparece como principal en ambas premisas,
+                // el cut puede ser eliminado por reduccion estructural: una de
+                // las premisas debe ser un axioma A ⊢ A. Si llegamos aqui sin
+                // resolverlo arriba, dejamos que el oraculo cut-free lo cubra.
+                break;
+        }
+    }
+    // Caso difícil: el cut no es principal en ambas premisas. En lugar
+    // de implementar las ~20 reducciones permutativas de Gentzen
+    // (commutative cuts), usamos el oraculo cut-free `proveLK`. Esto
+    // es sano porque LK admite eliminacion de cortes (Hauptsatz): si la
+    // derivacion original es valida, el secuente es derivable, luego
+    // tambien lo es sin cortes.
+    const cutFree = (0, prover_1.proveLK)(proof.goal);
+    if (cutFree)
+        return cutFree;
+    // Si el oraculo falla (no deberia para una derivacion valida),
+    // devolvemos lo que tengamos como mejor esfuerzo.
+    return proof;
+}
+/**
+ * Elimina todos los cortes de la derivacion. Devuelve una derivacion
+ * estructuralmente equivalente al mismo secuente sin nodos `cut`.
+ *
+ * Implementacion: eliminamos primero los cortes interiores (de las
+ * hojas hacia la raiz) y luego reducimos el cut de la raiz aplicando
+ * la regla principal correspondiente.
+ */
+function eliminateCut(proof) {
+    // Recursion en premisas primero
+    const premises = proof.premises.map(eliminateCut);
+    const updated = { ...proof, premises };
+    if (updated.rule !== 'cut')
+        return updated;
+    const reduced = eliminateCutAtRoot(updated);
+    // Si tras una pasada todavia hay cortes, iteramos (con limite anti-loop).
+    let cur = reduced;
+    for (let i = 0; i < 32 && (0, prover_1.hasCut)(cur); i++) {
+        cur = { ...cur, premises: cur.premises.map(eliminateCut) };
+        if (cur.rule === 'cut')
+            cur = eliminateCutAtRoot(cur);
+    }
+    // Garantia final: si quedaron cortes, intentamos reprovar desde el
+    // mismo objetivo con el prover cut-free.
+    if ((0, prover_1.hasCut)(cur)) {
+        const cutFree = (0, prover_1.proveLK)(cur.goal);
+        if (cutFree && (0, prover_1.isValid)(cutFree))
+            return cutFree;
+    }
+    return cur;
+}
+//# sourceMappingURL=cut-elimination.js.map

package/dist/profiles/sequent-lk/cut-elimination.js.map

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

package/dist/profiles/sequent-lk/index.d.ts

@@ -0,0 +1,5 @@
+export type { LKFormula, LKRule, LKSequent, LKProof } from './types';
+export { proveLK, proveLKFormula, hasCut, isValid } from './prover';
+export { eliminateCut } from './cut-elimination';
+export { lkKey, eq, depth } from './util';
+//# sourceMappingURL=index.d.ts.map

package/dist/profiles/sequent-lk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/profiles/sequent-lk/index.ts"],"names":[],"mappings":"AAUA,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC"}

package/dist/profiles/sequent-lk/index.js

@@ -0,0 +1,24 @@
+"use strict";
+// ============================================================
+// LK Sequent Calculus — Entrada publica del perfil
+// ============================================================
+//
+// Calculo de secuentes LK de Gentzen (1934) para logica
+// proposicional clasica con cut-elimination (Hauptsatz).
+//
+//   import { proveLK, hasCut, eliminateCut, isValid }
+//     from 'src/profiles/sequent-lk';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.depth = exports.eq = exports.lkKey = exports.eliminateCut = exports.isValid = exports.hasCut = exports.proveLKFormula = exports.proveLK = void 0;
+var prover_1 = require("./prover");
+Object.defineProperty(exports, "proveLK", { enumerable: true, get: function () { return prover_1.proveLK; } });
+Object.defineProperty(exports, "proveLKFormula", { enumerable: true, get: function () { return prover_1.proveLKFormula; } });
+Object.defineProperty(exports, "hasCut", { enumerable: true, get: function () { return prover_1.hasCut; } });
+Object.defineProperty(exports, "isValid", { enumerable: true, get: function () { return prover_1.isValid; } });
+var cut_elimination_1 = require("./cut-elimination");
+Object.defineProperty(exports, "eliminateCut", { enumerable: true, get: function () { return cut_elimination_1.eliminateCut; } });
+var util_1 = require("./util");
+Object.defineProperty(exports, "lkKey", { enumerable: true, get: function () { return util_1.lkKey; } });
+Object.defineProperty(exports, "eq", { enumerable: true, get: function () { return util_1.eq; } });
+Object.defineProperty(exports, "depth", { enumerable: true, get: function () { return util_1.depth; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/profiles/sequent-lk/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,mDAAmD;AACnD,+DAA+D;AAC/D,EAAE;AACF,wDAAwD;AACxD,yDAAyD;AACzD,EAAE;AACF,sDAAsD;AACtD,sCAAsC;;;AAGtC,mCAAoE;AAA3D,iGAAA,OAAO,OAAA;AAAE,wGAAA,cAAc,OAAA;AAAE,gGAAA,MAAM,OAAA;AAAE,iGAAA,OAAO,OAAA;AACjD,qDAAiD;AAAxC,+GAAA,YAAY,OAAA;AACrB,+BAA0C;AAAjC,6FAAA,KAAK,OAAA;AAAE,0FAAA,EAAE,OAAA;AAAE,6FAAA,KAAK,OAAA"}

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

@@ -0,0 +1,25 @@
+import { LKFormula, LKProof, LKSequent } from './types';
+/**
+ * Demuestra el secuente `seq` en LK clasico (sin cortes).
+ * Devuelve `null` si no encuentra derivacion dentro del budget.
+ */
+export declare function proveLK(seq: LKSequent, options?: {
+    budget?: number;
+}): LKProof | null;
+/** Atajo: ⊢ φ. */
+export declare function proveLKFormula(formula: LKFormula, options?: {
+    budget?: number;
+}): LKProof | null;
+/**
+ * Verifica que `proof` sea una derivacion LK valida segun la regla
+ * declarada en cada nodo. La validacion es estructural — comprueba
+ * que las premisas y la conclusion encajen con el patron de la regla.
+ *
+ * Es deliberadamente flexible respecto al orden (multisets) y permite
+ * contraccion implicita en las reglas logicas (la formula principal
+ * puede aparecer en las premisas, como en presentaciones modernas).
+ */
+export declare function isValid(proof: LKProof): boolean;
+/** Cuenta si existe al menos un nodo `cut` en la derivacion. */
+export declare function hasCut(proof: LKProof): boolean;
+//# sourceMappingURL=prover.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prover.d.ts","sourceRoot":"","sources":["../../../src/profiles/sequent-lk/prover.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAsLxD;;;GAGG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,GAAG,IAAI,CAIzF;AAED,kBAAkB;AAClB,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,EAClB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAChC,OAAO,GAAG,IAAI,CAEhB;AAuBD;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CA2N/C;AAED,gEAAgE;AAChE,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAG9C"}